INTRODUCTION

Android est un système d'exploitation basé sur Linux. Il est conçu principalement pour les
appareils mobiles à écran tactile tels que les tablettes et les smartphones. Le système
d'exploitation Android s'est développé au cours des 15 dernières années, depuis les téléphones
noirs et blancs jusqu'aux smartphones ou mini-ordinateurs récents.

android est un système d'exploitation puissant qui prend en charge un grand nombre
d'applications dans les smartphones et autres appareils compatibles. Ces applications sont plus
confortables et plus avancées pour les utilisateurs. Le matériel qui supporte le logiciel android
est basé sur une plateforme d'architecture ARM. android est un système d'exploitation open
source, ce qui signifie qu'il n'y a pas de frais de licence, de distribution ou de développement
et que tout le monde peut l'utiliser. L'android a des millions d'applications disponibles qui
peuvent vous aider à gérer votre vie facilement et il est disponible à bas prix sur le marché,
c'est pourquoi l'android est très populaire.

Le développement d'android prend en charge l'intégralité du langage de programmation java.

Même les autres paquets qui sont API et JSE ne sont pas supportés. La première version 1.0
du kit de développement logiciel (SDK) a été publiée en 2008 et la dernière version mise à
jour est la 9.0 avec le nom de code de Pie.

Histoire d'Android
Les noms de code d'Android sont actuellement de A à P, tels que Aestro, Blender, Cupcake,
Donut, Eclair, Froyo, Gingerbread, Honeycomb, Ice Cream Sandwitch, Jelly Bean, KitKat,
Lollipop, Marshmallow, Nougat, Oreo et Pie. Comprenons l'histoire d'Android ci-dessous.

Andy Rubin a fondé Android Incorporation à Palo Alto, en Californie (États-Unis) en octobre
2003.
Google a acquis android Incorporation le 17 août 2005. Depuis lors, elle est dans la filiale de
Google Incorporation.
Les principaux employés d'Android Incorporation sont Andy Rubin, Rich Miner, Chris White
et Nick Sears.
Android est le surnom d'Andy Rubin donné par ses collègues de travail en raison de son
amour pour les robots. Google annonce le développement de l'OS Android en 2007.
Le premier téléphone fonctionnant sous le système d'exploitation Android est le T-Mobile G1.
HTC a lancé le premier mobile Android en 2008.

Caractéristiques d'Android
Étant donné qu'Android est open source et que les fabricants peuvent le personnaliser
librement, il n'existe pas de configuration matérielle et logicielle fixe.

Cependant, Android lui-même prend en charge les fonctionnalités suivantes :

1. Stockage - Utilise SQLite, une base de données relationnelle légère, pour le stockage des
données.
2. Connectivité - Prise en charge de GSM/EDGE, IDEN, CDMA, EV-DO, UMTS, Bluetooth
(y compris A2DP et AVRCP), WiFi, LTE et WiMAX.
3. Messagerie - Prend en charge les SMS et les MMS.
4. Navigateur Web - Basé sur le logiciel libre WebKit, ainsi que sur le moteur JavaScript V8
de Chrome.
5. Prise en charge des médias - Comprend la prise en charge des médias suivants : H.263,
H.264 (dans un conteneur 3GP ou MP4), MPEG-4 SP, AMR, AMR- WB (dans un conteneur
3GP), AAC, HE-AAC (dans un conteneur MP4 ou 3GP), MP3, MIDI, Ogg Vorbis, WAV,
JPEG, PNG, GIF et BMP.
6. Support matériel - Accéléromètre, appareil photo, boussole numérique, capteur de
proximité et GPS Multi.
7. Multi-touch - Prise en charge des écrans multi-touch Multi.
8. Multi-tâches - Prise en charge des applications multi-tâches.
9. Support Flash - Android 2.3 supporte Flash 10.1.
10. Tethering - Prise en charge du partage de connexions Internet en tant que point d'accès
filaire ou sans fil.

Versions d'Android
Version Date Nom de code Niveau API
1.0 23 septembre 2008 Aucun nom de version 1
1.1 9 février 2009 Petit Four 2
1.5 27 avril 2009 Cupcake 3
1.6 15 septembre 2009 Donut 4
2.1 26 octobre 2009 Eclair 7
2.2 20 mai 2010 Froyo 8
2.3 6 décembre 2010 Gingerbread 9 et 10
3.1 et 3.3 22 février 2011 Honeycomb 12 et 13
4.0 18 octobre 2011 Ice Cream Sandwitch 15
4.1, 4.2 et 4.3 9 juillet 2012 Jelly Bean 16, 17 et 18
4.4 31 octobre 2013 KitKat 19
5.0 12 novembre 2014 Lollipop 21
6.0 5 octobre 2015 Marshmallow 23
7.0 22 août 2016 Nougat 24-25
8.0 21 août 2017 Oreo 26-27
9.0 6 août 2018 Pie 28
10 3 septembre 2019 Android 10 29
11 8 septembre 2020 Android 11 30

ARCHITECTURE ANDROID
Noyau Linux ou Linux kernel

Android utilise le puissant noyau Linux et prend en charge une large gamme de pilotes
matériels. Le noyau est le cœur du système d'exploitation qui gère les demandes d'entrée et de
sortie des logiciels. Il fournit les fonctionnalités de base du système comme la gestion des
processus, la gestion de la mémoire, la gestion des périphériques tels que la caméra, le clavier,
l'écran, etc. Linux est très bon en réseau et il n'est pas nécessaire de l'interfacer avec le
matériel périphérique. Le noyau lui-même n'interagit pas directement avec l'utilisateur mais
plutôt avec le shell et d'autres programmes ainsi qu'avec les périphériques du système.

Bibliothèques Android
En plus d'un ensemble de bibliothèques de développement Java standard (fournissant un
support pour des tâches d'usage général telles que la manipulation des chaînes de caractères,
la mise en réseau et la manipulation des fichiers), l'environnement de développement Android
comprend également les bibliothèques Android. Il s'agit d'un ensemble de bibliothèques
basées sur Java qui sont spécifiques au développement d'Android. Parmi les exemples de
bibliothèques de cette catégorie figurent les bibliothèques du cadre d'application, ainsi que
celles qui facilitent la création d'interfaces utilisateur, le dessin graphique et l'accès aux bases
de données.

Voici un résumé de certaines des principales bibliothèques de base d'Android mises à la

disposition du développeur Android :
[Link] - Fournit l'accès au modèle d'application et constitue la pierre angulaire de toutes
les applications Android.
[Link] - Facilite l'accès au contenu, la publication et la messagerie entre les
applications et les composants applicatifs.
[Link] - Utilisé pour accéder aux données publiées par les fournisseurs de contenu
et comprend des classes de gestion de base de données SQLite.
[Link] - Une API de dessin graphique 2D de bas niveau comprenant des couleurs,
des points, des filtres, des rectangles et des toiles.
[Link] - Présente une API permettant d'accéder au matériel tel que l'accéléromètre
et le capteur de lumière.
[Link] - Interface Java de l'API de rendu graphique 3D OpenGL ES.
[Link] - Fournit aux applications un accès aux services standard du système
d'exploitation, notamment les messages, les services système et la communication
interprocessus.
[Link] - Fournit des classes pour permettre la lecture de fichiers audio et vidéo.
[Link] - Ensemble d'API permettant d'accéder à la pile réseau. Comprend
[Link], qui permet d'accéder à la pile sans fil du périphérique.
[Link] - Comprend un ensemble de classes qui permettent d'envoyer du contenu à des
imprimantes configurées à partir d'applications Android.
[Link] - Ensemble de classes pratiques permettant d'accéder aux bases de données
standard des fournisseurs de contenu Android, telles que celles gérées par les applications de
calendrier et de contact.
[Link]' - Utilisé pour rendre et manipuler le texte sur l'écran d'un appareil.
[Link] - Ensemble de classes utilitaires permettant d'effectuer des tâches telles que la
conversion de chaînes et de nombres, la manipulation de XML et la manipulation de la date et
de l'heure.
[Link] - Les blocs de construction fondamentaux des interfaces utilisateur des
applications.
[Link] - Une riche collection de composants d'interface utilisateur préconstruits tels
que des boutons, des étiquettes, des vues de liste, des gestionnaires de mise en page, des
boutons radio, etc.
[Link] - Ensemble de classes destinées à permettre l'intégration de fonctionnalités de
navigation sur le Web dans les applications.
Après avoir couvert les bibliothèques basées sur Java dans le runtime Android, il est
maintenant temps de s'intéresser aux bibliothèques basées sur C/C++ contenues dans cette
couche de la pile logicielle Android.

Bibliothèques C/C++
Les bibliothèques centrales du moteur d'exécution d'Android décrites dans la section
précédente sont basées sur Java et fournissent les principales API aux développeurs qui
écrivent des applications Android. Il est important de noter, cependant, que les bibliothèques
centrales n'effectuent pas une grande partie du travail réel et sont, en fait, essentiellement des
"enveloppes" Java autour d'un ensemble de bibliothèques C/C++. Lorsque l'on fait appel, par
exemple, à la bibliothèque [Link] pour dessiner des graphiques 3D sur l'écran du
périphérique, la bibliothèque fait en fait appel à la bibliothèque OpenGL ES C++ qui, à son
tour, travaille avec le noyau Linux sous-jacent pour effectuer les tâches de dessin.

Les bibliothèques C/C++ sont incluses pour remplir un large éventail de fonctions,
notamment le dessin graphique 2D et 3D, la communication SSL (Secure Sockets Layer), la
gestion de la base de données SQLite, la lecture audio et vidéo, le rendu des polices bitmap et
vectorielles, la gestion du sous-système d'affichage et de la couche graphique, ainsi qu'une
mise en œuvre de la bibliothèque système C standard (libc).

En pratique, le développeur d'applications Android typique accèdera à ces bibliothèques

uniquement par le biais des API de la bibliothèque centrale Android basée sur Java. Si un
accès direct à ces bibliothèques est nécessaire, il est possible d'utiliser le kit de développement
natif Android (NDK), dont le but est d'appeler les méthodes natives des langages de
programmation non Java ou Kotlin (tels que C et C++) à partir du code Java en utilisant
l'interface native Java (JNI).

Le runtime Android
Au même niveau que les bibliothèques, le moteur d'exécution Android fournit un ensemble
de bibliothèques de base qui permettent aux développeurs d'écrire des applications Android à
l'aide de la plate-forme Java.

Le runtime Android comprend également la machine virtuelle Dalvik, qui permet à chaque application
Android de s'exécuter dans son propre processus, avec sa propre instance de la machine virtuelle Dalvik
(les applications Android sont compilées dans les exécutables Dalvik). Dalvik est une machine virtuelle
spécialisée conçue spécifiquement pour Android et optimisée pour les appareils mobiles alimentés par
batterie et dotés d'une mémoire et d'une unité centrale limitées.

Cadre d'application
Le cadre applicatif est un ensemble de services qui forment collectivement l'environnement dans lequel les
applications Android s'exécutent et sont gérées. Ce cadre met en œuvre le concept selon lequel les
applications Android sont construites à partir de composants réutilisables, interchangeables et
remplaçables. Ce concept est poussé un peu plus loin dans la mesure où une application est également
capable de publier ses capacités ainsi que les données correspondantes afin qu'elles puissent être trouvées et
réutilisées par d'autres applications.

Le cadre Android comprend les services clés suivants :

Gestionnaire d'activités - Contrôle tous les aspects du cycle de vie de l'application et de la pile d'activités.
Fournisseurs de contenu - Permet aux applications de publier et de partager des données avec d'autres
applications.
Gestionnaire de ressources - Permet d'accéder aux ressources intégrées non codées, telles que les chaînes
de caractères, les paramètres de couleur et les dispositions de l'interface utilisateur.
Gestionnaire de notifications - Permet aux applications d'afficher des alertes et des notifications à
l'utilisateur.
Système de vues - Ensemble extensible de vues utilisé pour créer des interfaces utilisateur d'applications.
Package Manager - Système permettant aux applications de trouver des informations sur les autres
applications actuellement installées sur l'appareil.
Telephony Manager - Fournit des informations à l'application sur les services de téléphonie disponibles
sur l'appareil, comme l'état et les informations sur les abonnés.
Location Manager - Fournit un accès aux services de localisation permettant à une application de recevoir
des mises à jour sur les changements de localisation.

Applications
Au sommet du cadre android, il y a les applications. Toutes les applications telles que l'accueil, les contacts,
les paramètres, les jeux, les navigateurs utilisent le cadre android qui utilise le runtime et les bibliothèques
android. Le runtime Android et les bibliothèques natives utilisent le noyau linux.
INTRODUCTION À L'IDE ANDROID
STUDIO
android studio

Android Studio est l'environnement de développement intégré (IDE) officiel pour le développement
d'applications Android, basé sur IntelliJ IDEA .
structure du projet

L'image ci-dessus montre la vue du projet Android où vous aurez tous vos fichiers liés à votre projet. Ici,
nous avons un module Android Application qui se compose de Manifest, Java, Res Folders.

Dossier Manifest : Ce dossier se compose d'un fichier [Link] que le système Android exige pour
toutes les informations essentielles de l'application, comme :

Nom du paquet - Identifiant unique de l'application.

Composants - Nous devons décrire tous les composants de l'application (nous aborderons les composants
dans les chapitres suivants).
Permissions-Décrire toutes les permissions dont l'application aura besoin.
<manifest xmlns:android="[Link]
xmlns:tools="[Link]
package="[Link]">

<uses-permission android:name="[Link].ACCESS_NETWORK_STATE" />

<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/AppTheme"
tools:replace="android:icon">
<activity android:name=".TutorialsPanel"
android:parentActivityName=".Tutorials"></activity>
<activité
android:name=".Tutorials"
android:parentActivityName=".Tableau de bord" />
<activité
android:name=".QuizPanel"
android:parentActivityName=".QuizActivity" />
<activité
android:name=".QuizActivity"
android:parentActivityName=".Dashboard" />
<activité
android:name=".Questionnaires d'entretien" et
android:parentActivityName=".Dashboard" />
<activité
 android:name=".Tableau de bord" (Dashboard)
android:label="@string/title_activity_dashboard"
android:theme="@style/[Link]" />
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="[Link]" />

<category android:name="[Link]" />

</intent-filter>
</activity>
</application>

</manifest>
Dossier Java : C'est ici que vous aurez tous vos fichiers Java et Kotlin.

Res Folder : Ce dossier se compose de tous les besoins médiatiques de l'application comme les dispositions
d'écran à l'intérieur de la mise en page, les images à l'intérieur de drawable, les polices, la couleur, les
chaînes et la dimension seront à l'intérieur des valeurs.

Interface utilisateur de l'IDE

image java

Barre d'outils : Toutes les actions nécessaires comme copier, coller, trouver, etc. avec l'exécution de
l'application, l'ouverture du gestionnaire SDK et d'autres outils.
Barre de navigation : Elle vous montre le chemin du fichier sur lequel vous travaillez.
Fenêtre de l'éditeur : Il s'agit de l'écran où tous vos fichiers sont ouverts, et où vous pouvez écrire du code,
concevoir des mises en page, etc. en fonction du type de fichier.
Barre d'outils : Il s'agit d'une fenêtre composée de plusieurs options que vous pouvez développer en
cliquant dessus.
Fenêtre d'outils : Vous verrez ici l'option que vous avez sélectionnée dans la barre de la fenêtre d'outils.
Barre d'état : Vous pouvez y vérifier l'état de votre projet.
Système de construction Gradle
Dans Android Studio, Gradle est un outil de construction personnalisé utilisé pour construire des fichiers
APK, en gérant les dépendances et en fournissant une logique de construction personnalisée.

Le fichier APK (Android Application Package) est un fichier zip spécialement formaté qui se compose de
Bytecode, de ressources (images, UI, XML, etc.) et d'autres éléments.

Dans ce chapitre, vous avez pris connaissance de tous les détails initiaux de l'EDI Android Studio. Cet EDI
comprend de nombreuses fonctionnalités qui rendront votre voyage en tant que développeur Android plus
confortable. Nous aborderons d'autres fonctionnalités une par une dans les prochains
chapitres.Android_Cours_03

COMPOSANTS DE L'APPLICATION
ANDROID
Les composants de l'application Android ou les blocs de construction de base sont les blocs de
construction de base d'une application Android et ces composants permettront au système ou
à l'utilisateur d'accéder à notre application.

Les éléments suivants sont les blocs de construction de base des composants d'application
Android qui peuvent être utilisés dans une application Android :
Activités
Intent
Services
Récepteurs de diffusion
Fournisseurs de contenu

Les Activités
Une activité représente un écran unique avec une interface utilisateur (IU) et sert de point
d'entrée aux utilisateurs pour interagir avec l'application.

Par exemple, une application de contacts qui comporte plusieurs activités comme l'affichage
d'une liste de contacts, l'ajout d'un nouveau contact et une autre activité qui permet de
rechercher les contacts dans la liste de contacts d'une application. Toutes les activités d'une
application de contacts sont indépendantes les unes des autres, mais ces activités fonctionnent
ensemble pour offrir une meilleure expérience à l'utilisateur.

Intents
Un intent est un objet de messagerie qui est utilisé pour demander une action à un autre
composant.

Il est principalement utilisé pour effectuer les actions suivantes :

 Démarrer une activité

 Lancer un service
 Diffuser une émission
 Afficher une page Web, etc.

Il existe deux types d'intent dans android :

 Intents implicites
 Intents explicites

Services
Le service est un composant qui est un processus d'arrière-plan pour effectuer des opérations
de longue durée en fonction de nos besoins. Le service n'a pas d'interface utilisateur (UI) et il
peut exécuter les applications en arrière-plan pendant une longue période, comme jouer de la
musique en arrière-plan lorsque l'utilisateur est dans une autre application.

Il existe deux types de services disponibles dans Android :

 Services locaux
 Services distants

Le service local est un service auquel on accède depuis l'application, tandis que le service
distant est un service auquel on accède à distance depuis d'autres applications fonctionnant sur
le même appareil.
Les Récepteurs de diffusion
Les récepteurs de diffusion sont des composants qui permettent à un système de transmettre
des événements à l'application, comme l'écoute d'un appel entrant, des sms, l'envoi d'un
message de batterie faible à l'application, etc. Les applications peuvent également lancer des
diffusions pour faire savoir aux autres applications que les données requises sont disponibles
sur un appareil pour l'utiliser. Il est utilisé pour gérer la communication entre le système
d'exploitation Android et les applications.

En général, nous utilisons des intentions pour transmettre des événements de diffusion à
d'autres applications et les récepteurs de diffusion utilisent les notifications de la barre d'état
pour informer l'utilisateur qu'un événement de diffusion se produit.

Fournisseurs de contenu
Les fournisseurs de contenu sont utilisés pour échanger les données entre les applications en
fonction des demandes. Les fournisseurs de contenu peuvent partager les données de
l'application qui sont stockées dans le système de fichiers, la base de données SQLite, sur le
Web ou tout autre emplacement de stockage auquel notre application peut accéder.

En utilisant les fournisseurs de contenu, d'autres applications peuvent interroger ou modifier

les données de notre application en fonction des autorisations fournies par les fournisseurs de
contenu. Par exemple, android fournit un fournisseur de contenu ([Link])
pour gérer les informations relatives aux contacts. En utilisant les autorisations appropriées,
toute application peut interroger le fournisseur de contenu pour effectuer des opérations de
"lecture" et d'"écriture" sur les informations relatives aux contacts.

LE FICHIER MANIFESTE DE
L'APPLICATION ANDROID
Aujourd'hui, je voudrais vous aider du mieux que je le peux à comprendre le fichier manifeste
de l'application Android en tant que développeur android. Chaque application android que
vous construisez comprendra un fichier appelé [Link] qui est placé à la racine
de la hiérarchie du projet. Pourquoi est-il important ? Parce qu'il vous permet de définir la
structure et les métadonnées de votre application android et de ses composants.

//Image du manifeste

Le fichier Manifest de l'application Android comprend des nœuds pour chacun des
composants suivants :

 Activités
 Services
 Fournisseurs de contenu
 Récepteurs de diffusion

qui composent votre application et utilise les filtres d'intention et les autorisations pour
déterminer comment ils interagissent entre eux et avec les autres applications. Il vous offre
également des attributs que vous pouvez utiliser pour spécifier les métadonnées de
l'application, comme l'icône et le thème, entre autres.
Le fichier Android Application Manifest est composé d'une balise manifest racine dont
l'attribut package est défini sur le package du projet. Il comprend normalement un
attribut xmlns:android qui fournit plusieurs attributs système utilisés dans le fichier manifeste
de l'application Android.

Un exemple de Fichier manifeste de l'application Android

<manifest xmlns:android="[Link]
xmlns:tools="[Link]
package="[Link]">

<uses-permission android:name="[Link].ACCESS_NETWORK_STATE" />

<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/AppTheme"
tools:replace="android:icon">
<activity android:name=".TutorialsPanel"
android:parentActivityName=".Tutorials"></activity>
<activité
android:name=".Tutorials"
android:parentActivityName=".Tableau de bord" />
<activité
android:name=".QuizPanel"
android:parentActivityName=".QuizActivity" />
<activité
android:name=".QuizActivity"
android:parentActivityName=".Dashboard" />
<activité
android:name=".Questionnaires d'entretien" et
android:parentActivityName=".Dashboard" />
<activité
android:name=".Tableau de bord" (Dashboard)
android:label="@string/title_activity_dashboard"
android:theme="@style/[Link]" />
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="[Link]" />

<category android:name="[Link]" />

</intent-filter>
</activity>
</application>

</manifest>
Comme indiqué précédemment, la balise manifest comprend des nœuds qui définissent les
composants de l'application, les paramètres de sécurité et même les classes de test qui
composent votre application cool. Faisons maintenant connaissance avec ces balises de nœud
de manifeste avec des exemples xml.

Balises de nœud de manifeste d'application Android

1)application - Un manifeste ne peut contenir qu'un seul nœud d'application. Il utilise des
attributs pour spécifier les métadonnées de votre application Android (titre, icône et thème).
En outre, il agit comme un conteneur qui inclut les balises Activity, Service, Content Provider
et Broadcast Receiver pour spécifier les composants de l'application :

 activity - Pour chaque activité affichée par votre application android, une
balise activity est nécessaire. Vous la définissez en utilisant l'attribut
android:name pour spécifier le nom de la classe. Elle doit inclure l'activité
principale de lancement et tout autre écran ou boîte de dialogue qui peut
être affiché. Si vous essayez de lancer une activité qui n'est pas définie,
vous obtiendrez une exception d'exécution. Chaque nœud d'activité prend
en charge les balises enfant intent-filter qui spécifient les intents qui
lancent l'activité.
 service - Comme pour l'étiquette Activity, vous devez créer un nouveau
service pour chaque classe Service utilisée dans votre application. Les
balises de service prennent également en charge les balises enfant intent-
filter pour permettre une liaison tardive au moment de l'exécution.
 provider - Les balises provider sont utilisées pour chacun des
fournisseurs de contenu de votre application. Les fournisseurs de contenu
sont utilisés pour gérer l'accès aux bases de données et leur partage au
sein des applications et entre elles.
 receiver - Vous pouvez enregistrer un récepteur de diffusion en ajoutant
une balise receiver sans avoir à lancer votre application au préalable. Les
récepteurs de diffusion ressemblent davantage à des écouteurs
d'événements globaux : une fois enregistrés, ils s'exécutent dès qu'une
application diffuse une intention correspondante.

2)uses-permission - fait partie du modèle de sécurité. Il déclare les permissions dont vous
avez déterminé que votre application a besoin pour fonctionner correctement. Les permissions
que vous incluez seront toujours présentées à l'utilisateur pour qu'il les accorde ou les refuse
pendant l'installation. De nombreux services android natifs nécessitent des permissions, par
exemple ceux qui ont des implications en termes de coût ou de sécurité. Exemples : services
de localisation, SMS, etc.

3)permission - Vous devez définir une permission dans le fichier manifeste de l'application
android avant de restreindre l'accès à un composant de l'application. Utilisez la balise
permission pour créer les définitions de permission. Les composants de l'application peuvent
ensuite les exiger en ajoutant l'attribut android:permission. Les autres applications devront
alors inclure une balise uses-permission dans leur fichier manifeste et obtenir une autorisation
avant de pouvoir utiliser ces composants protégés.
Dans la balise permission, vous pouvez spécifier le niveau d'accès autorisé (normal,
dangereux, signature, signatureOrSystem), un label et une ressource externe contenant la
description des risques liés à l'octroi de cette permission.

4)instrumentation - Les classes d'instrumentation fournissent un cadre pour l'exécution de

tests sur vos activités et services au moment de l'exécution. Elles fournissent simplement des
crochets pour surveiller votre application et son interaction avec les ressources du système.
Vous devez créer un nouveau nœud pour chacune des classes de test que vous avez créées
dans votre application.

<< PREC

ACTIVITÉS ANDROID
Une activité est l'un des principaux éléments constitutifs du développement d'une
application Android. Elle représente un écran unique avec une interface utilisateur
(UI). ContextThemeWrapper est la super classe d'une activité. L'activité est le point
d'entrée principal d'une application Android, tout comme la méthode principale
d'un programme écrit en Java ou en C++. Une activité interagit avec l'utilisateur,
elle crée donc une fenêtre pour placer les éléments de l'interface utilisateur. Une
application Android peut contenir plusieurs activités, c'est-à-dire plusieurs écrans
différents qui peuvent interagir les uns avec les autres et indépendamment avec
l'utilisateur.

Cycle de vie d'une activité Android

L'activité Android a son propre cycle de vie. Au cours de sa vie, elle peut effectuer
de nombreuses opérations. Les activités Android sont stockées et gérées dans une
pile appelée pile d'activités. Une nouvelle activité arrive en haut de la pile et
s'exécute, tandis que la précédente reste en dessous de la nouvelle activité dans la
pile. Lorsque l'activité supérieure de la pile sort, l'activité inférieure au sommet
devient active.

Les États d'une activité Android

Une activité a quatre états

 En cours d'exécution : Une activité est en cours d'exécution lorsqu'une

activité située en haut de la pile est en cours d'exécution ou active, ce qui
signifie qu'elle est au premier plan de l'écran.
 En pause : Une activité est en état de pause lorsqu'une activité est vivante
mais qu'elle n'est pas focalisée dans l'état de pause. (Il s'agit d'un message
contextuel affiché sur l'activité).
 Reprise : Une activité est en état de reprise Lorsqu'une activité en pause
devient active, elle est rafraîchie et redémarrée.
  Arrêtée : Une activité est arrêtée lorsqu'une activité n'est plus visible à
l'écran pour l'utilisateur.

Méthodes de rappel des activités Android

Une activité met en œuvre les méthodes de rappel suivantes :

OnCreate() : C'est la première méthode de rappel d'une activité Android. Elle est
appelée lorsqu'une activité est créée. C'est là que vous définissez tous les trucs
comme les boutons, les vues, la case à cocher, TextView etc.
OnStart() : C'est la deuxième méthode de rappel. Elle est appelée lorsque
l'activité est visible à l'écran par l'utilisateur.
OnResume() : Elle est appelée après la méthode OnStart() si l'activité passe au
premier plan. C'est le moment où l'utilisateur commence à interagir avec l'activité.
OnPause() : Cette méthode est suivie de OnResume(). Cette méthode est appelée
lorsqu'une activité précédente est reprise.
OnStop() : Elle est appelée lorsqu'une autre activité est reprise et que cette activité
n'est plus visible pour l'utilisateur. Elle devient cachée.
OnDestroy() : C'est la méthode de rappel final lorsque l'activité est terminée.
OnRestart() : Elle est appelée lorsqu'une activité redémarre.

Le diagramme suivant montre le cycle de vie complet d'une activité Android.

 Cycle de vie d'une activité Android

Les rectangles de la figure représentent les méthodes de rappel.

Exemple de cycle de vie d'une activité

Voici l'exemple d'une activité Android. La première étape consiste à ouvrir votre
Android Studio et à créer un nouveau projet. L'assistant de nouveau projet vous
permettra de créer une nouvelle activité et le nom du nouveau projet est Activity
Lifecycle.

Nom du fichier : [Link]

package [Link] ;

import [Link] ;
import [Link] ;
import [Link] ;
import [Link] ;

public class MainActivity extends AppCompatActivity {

@Override
protected void onStart() {
[Link]() ;
Log.d("Activity Lifecycle", "onStart is invoked") ;
[Link]([Link], "onStart is
invoked",Toast.LENGTH_SHORT).show() ;
}
@Override
protected void onCreate(Bundle savedInstanceState) {
[Link](savedInstanceState) ;
setContentView([Link].activity_main) ;
Log.d("Activity Lifecycle", "onCreate is invoked") ;
[Link]([Link], "onCreate is
invoked",Toast.LENGTH_SHORT).show() ;
}
@Override
protected void onStop() {
[Link]() ;
Log.d("Activity Lifecycle", "onStop is invoked") ;
[Link]([Link], "onStop is
invoked",Toast.LENGTH_SHORT).show() ;
}
@Override
protected void onResume() {
[Link]() ;
Log.d("Activity Lifecycle", "onResume is invoked") ;
[Link]([Link], "onResume is
invoked",Toast.LENGTH_SHORT).show() ;
}
@Override
protected void onPause() {
[Link]() ;
Log.d("Activity Lifecycle", "onPause is invoked") ;
[Link]([Link], "onPause is
invoked",Toast.LENGTH_SHORT).show() ;
}
@Override
protected void onDestroy() {
[Link]() ;
Log.d("Activity Lifecycle", "onDestroy is invoked") ;
 [Link]([Link], "onDestroy is
invoked",Toast.LENGTH_SHORT).show() ;
}
}

Nom du fichier : activty_main.xml

<?xml version="1.0" encoding="utf-8"?>

<[Link]
xmlns:android="[Link]
xmlns:app="[Link]
xmlns:tools="[Link]
android:layout_width="match_parent" (en anglais)
android:layout_height="match_parent"
tools:context=".MainActivity">

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello World !"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintTop_toTopOf="parent" />

</[Link]>
Nom du fichier : [Link]

<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="[Link]
package="[Link]">

<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
<filtre d'intention>
<action android:name="[Link]" />
 <category android:name="[Link]" />
</intent-filter>
</activity>
</application>

</manifest>
Sortie :
Vous verrez la sortie sur l'émulateur ou l'appareil ou logcot dans android studio.
Vous devez ouvrir logcat dans android studio.

// sortie IMAGE

Maintenant vous pouvez voir sur le logcat : les méthodes onCreate, onStart et
onResume sont invoquées et aussi voir dans le toast.

..// IMAGE logcat

Maintenant vous pouvez cliquer sur le bouton HOME. Vous verrez que la méthode
onPause est invoquée.

Après un certain temps, vous verrez que la méthode onStop est invoquée.

Vous voyez maintenant qu'il est sur la page d'accueil. Cliquez maintenant sur le
bouton central pour relancer l'application.

Cliquez maintenant sur l'icône Activity Lifecycle.

Maintenant vous pouvez également voir sur le logcat : les méthodes onRestart,
onStart et onResume sont invoquées.

Votre application est maintenant redémarrée.

Cliquez maintenant sur le bouton retour. Vous pouvez maintenant voir que la
méthode onPause est invoquée.

Après un certain temps, vous verrez que les méthodes onStop et onDestroy sont
invoquées.

Dans le cycle de vie de l'activité, les méthodes onCreate() et onDestroy() ne sont

appelées qu'une seule fois au cours du cycle de vie de l'activité.

ANDROID FRAGMENT
Un fragment Android est un morceau d'une activité qui permet une conception plus
modulaire de l'activité. Il ne serait pas faux de dire qu'un fragment est une sorte de
sous-activité. Dans une activité Android, il est utilisé pour créer une interface
utilisateur (UI) dynamique et flexible. Un fragment Android a son propre cycle de
vie, mais il est toujours intégré à une activité de sorte que le cycle de vie des
fragments Android est directement affecté par le cycle de vie des activités hôtes et
les fragments Android reçoivent leurs propres événements d'entrée. Dans une
application androïde, nous pouvons utiliser plusieurs fragments androïdes dans une
seule activité d'une application pour créer une interface utilisateur (UI) multivolets
et nous pouvons également utiliser un seul fragment dans plusieurs activités.
Maintenant, le gestionnaire de fragments est responsable de l'ajout ou la
suppression ou le remplacement des fragments au moment de l'exécution dans
n'importe où d'une activité. Lorsque nous ajoutons un fragment dans une activité, il
vit dans un ViewGroup dans le côté de la hiérarchie de vue des activités et le
fragment définit sa propre disposition de vue en déclarant le fragment dans le
fichier de mise en page des activités comme un élément <fragment> ou à partir du
code de l'application en l'ajoutant à un ViewGroup existant.

Il y a quelques points concernant les fragments android :

Un fragment a son comportement et sa mise en page avec ses méthodes de

callbacks de cycle de [Link] pouvez ajouter ou supprimer des fragments dans
l'activité. Lorsque l'activité est en cours d'exécution, qui est dans l'état de reprise du
cycle de [Link] pouvez également combiner plusieurs fragments dans une seule
activité pour créer une interface utilisateur (IU) à plusieurs [Link] cela permet de
réutiliser un fragment dans plusieurs activités.
Le cycle de vie d'un fragment est très étroitement lié au cycle de vie de son activité
hôte, ce qui signifie que lorsque l'activité est en état de pause, tous les fragments
disponibles dans l'activité s'arrêtent également. Les fragments ont été ajoutés à
l'API Android dans la version 11 d'Android 3.0 afin de prendre en charge une
interface utilisateur flexible sur les appareils à grand é[Link] les sous-classes
d'un Fragment Class-

 ListFragment
 DialogFragment
 PreferenceFragment
 WebViewFragment

ListFragment
ListFragment est similaire à ListActivity et contient une ListView par défaut. Son
but est d'afficher une liste d'éléments. Nous avons utilisé ListFragment ; voir la
section Création et gestion des fragments pour ListFragment.

DialogFragment
Un DialogFragment affiche un dialogue au-dessus de l'activité de son propriétaire.
Nous allons créer un fragment qui possède un bouton Supprimer. Lorsque l'on
clique sur le bouton, une boîte de dialogue DialogFragment s'affiche.

PreferenceFragment
PreferenceFragment contient une hiérarchie d'objets de préférences sous forme de
listes. Ces préférences seront automatiquement enregistrées dans sharedPreferences
au fur et à mesure que l'utilisateur interagit avec elles. Pour récupérer une instance
de SharedPreferences que la hiérarchie de préférences de ce fragment utilisera,
appelez [Link]([Link])
avec un contexte dans le même package que ce fragment.

WebViewFragment

WebView peut également vous aider à utiliser les métaphores de navigation

courantes, telles que l'historique des URL visitées pour prendre en charge la
navigation vers l'avant et vers l'arrière. Cependant, WebView a ses propres
inconvénients, notamment le fait qu'il s'agit d'un widget beaucoup plus coûteux à
utiliser, en termes de consommation de mémoire, qu'un TextView. La raison de
l'augmentation de la mémoire est que WebView est alimenté par WebKit/Blink qui
sont des moteurs de rendu Web open source pour alimenter le contenu dans les
navigateurs comme Chrome.

Cycle de vie des fragments d'Android

Voici le cycle de vie des fragments d'Android.

//image

Voici les calbacks du cycle de vie des fragments android.

onAttach()
Cette méthode est appelée avant même les méthodes de rappel onCreate() et après
avoir attaché le fragment à l'activité. Si Android SDK Version(API Level<23) il
prend une activité comme une référence qui accueillera le fragment sinon il prend
Contexte comme une référence. En utilisant cette référence, nous pouvons obtenir
les services du système et initialiser les événements interactifs du fragment, etc.

onCreate()

Cette méthode est appelée lors de la création du fragment et il prend Bundle comme
une référence qui est utilisé pour initialiser les composants nécessaires et de stocker
sa valeur que vous voulez conserver lorsque le fragment est en pause ou arrêté
l'état, puis [Link] le fragment est mis en œuvre pour la première fois dans
l'activité Bundle objet est nul.

onCreateView()

Dans cette méthode lorsque le fragment est ajouté à une activité pour la première
[Link] devez retourner une vue de cette méthode qui est la racine de la mise en
page de votre fragment. Si le fragment ne fournit pas une interface utilisateur (UI),
vous pouvez retourner null.

onActivityCreated()

Cette méthode est appelée après que le callback Activity onCreate() ait terminé son
exécution. Cette méthode est une indication que l'activité a terminé son exécution
avant que nous essayions d'accéder sans interruption et de modifier les éléments de
l'interface utilisateur (IU) de l'activité.

onStart()

Cette méthode est appelée une fois que le fragment android devient visible dans
l'activité après le callback onStart() de l'activité.

onResume()

Cette méthode est appelée lorsque l'utilisateur interagit avec les fragments android
dans l'activité après le callback onResume() de l'activité.

Si un fragment n'est plus utilisé, il passe par une série inverse de rappels.

onPause()

Cette méthode est appelée lorsque le fragment n'est plus utilisé pour interagir avec
l'utilisateur, soit parce que son activité est en état de pause, soit parce qu'une
opération du fragment le modifie dans l'activité.
onStop()

Cette méthode est appelée lorsque le fragment n'est plus utilisé pour interagir avec
l'utilisateur, soit parce que son activité est en état d'arrêt, soit parce qu'une
opération de fragment le modifie dans l'activité.

onDestroyView()

Cette méthode est appelée pour permettre au fragment de nettoyer les ressources
associées à sa vue dans l'activité.

onDestroy()

Cette méthode est appelée pour faire le nettoyage final de l'état du fragment.

onDetach()

Cette méthode est appelée pour que le fragment ne soit plus associé à son activité.

Bon a Savoir : Normalement, vous devriez implémenter au moins les méthodes de

rappel du cycle de vie suivantes: onCreate(), onCreateView(), onPause() Par
l'activité hôte, nous pouvons sauvegarder chaque transaction de fragment dans une
pile arrière gérée et l'utilisateur peut inverser une transaction de fragment par cette
pile arrière.
Dans le cas où nous avons une méthode avec le même nom dans l'activité et le
fragment pendant la phase de création, la méthode de l'activité s'exécute en premier
et la méthode du fragment s'exécute ensuite. onSaveInstaceState() : Ce callback est
appelé où vous avez permis de sauvegarder certaines données sur les événements
fragment juste avant que l'application est en état de pause de sorte que lorsque
l'utilisateur revient à l'application, ils obtiennent les données enregistrées. Ici, il
prend la référence Bundle afin que nous puissions stocker les données comme (clé,
valeur) paires.

INTENT ANDROID
Un Intent est un objet de messagerie que vous pouvez utiliser pour stimuler un
composant d'une application. Les intents vous permettent d'interagir avec des
composants qui appartiennent soit à la même application, soit à l'extérieur de cette
application. Il s'agit d'une description abstraite d'une opération à effectuer. L'objet
Intent contient des informations qui sont utilisées soit par les composants qui
reçoivent cette intention, soit par le système Android lui-même. L'intention peut
être utilisée pour : Démarrer une activité, Démarrer un service, Diffuser une
émission, Afficher une page web, etc.
Objets d'intent

Un objet d'intent est un ensemble d'informations utilisées par le composant android

qui reçoit l'intention ainsi que des informations utilisées par le système android.

Les objets d'intent contiennent les éléments suivants :

Nom du composant ( component name ) : Cette information est facultative. Si le

nom du composant est défini, alors le système Android fait directement
correspondre l'intention au composant cible. Sinon, le système android utilise
d'autres informations pour localiser la cible appropriée. Le nom du composant est
défini par setComponent (), setClass () et est lu par getComponent ().
Action : Il s'agit d'une partie nécessaire de l'information qui nomme l'action qu'un
composant Android devra Le système Android définit un certain nombre de
constantes d'action.

Voici quelques-unes des actions les plus courantes :

Data (Données) : elles contiennent l'identifiant de ressource uniforme (URI) des

données. Il existe différents types de plan de données pour différentes actions. Par
exemple, si l'action définie était ACTION_CALL, le champ de données
contiendrait un numéro à appeler (tel : URI). Il est utile de faire correspondre
l'intention à un composant applicable et de définir le type de données (en plus de
l'URI). De plus, un composant permettant d'afficher une image doit être appelé
pour afficher l'image uniquement, et non pour lire un fichier audio.
Category (Catégorie) : Cette catégorie est facultative et définit la catégorie du
composant qui est géré par l'intention.

Extras : Il s'agit de la "paire clé-valeur" pour les informations supplémentaires qui

doivent être fournies au composant qui gère l'intention.

Flags (Drapeaux) : Ces drapeaux sont définis dans la classe d'intention qui
fonctionnent comme des métadonnées pour l'intention et les drapeaux peuvent
demander au système Android de lancer une activité d'une manière spécifique.

Les intents peuvent être divisées en deux types :

Les intents explicites : Un intent explicite est le type d'intention dans lequel vous
définissez explicitement le composant qui doit être appelé par le système Android.
En général, les intentions explicites sont utilisées pour lancer des composants dans
votre propre application. Pour créer une intent explicite

Intents implicites : L'intent implicite est le type d'intention où, au lieu de définir les
composants exacts, vous devez définir l'action que vous voulez exécuter pour les
différentes activités. Pour créer une intent implicite :
Filtres d'intents
Un filtre d'intent Android est une expression. Elle est exprimée dans le fichier
manifeste d'une application andoid. Il définit le type d'intention que le composant
doit recevoir. Android Os utilise des filtres pour identifier l'ensemble des activités,
des services et des récepteurs de diffusion qui peuvent traiter l'intention à l'aide
d'un ensemble spécifié de catégories d'actions, de données et de schémas associés à
une intention. S'il n'y a pas de filtre d'intent pour une activité, seule une intention
explicite peut la lancer.

Pour des raisons de sécurité, le filtre d'intent ne peut pas être utilisé pour le service.
Le service peut démarrer sans avertir l'utilisateur et s'exécuter en arrière-plan.
L'architecture Android de votre appareil trouvera le composant déclaré dans un
filtre d'intention et le recherchera dans toute l'application Android. Lorsqu'il est
trouvé, il démarre l'activité correspondante et exécute l'action appropriée.

Dans Android, un composant a des filtres séparés pour chaque tâche qu'il peut faire,
chaque visage qu'il peut montrer à l'utilisateur. Par exemple, l'activité NoteEditor
de l'exemple d'application de bloc-notes a deux filtres : un pour démarrer une note
spécifique que l'utilisateur peut visualiser ou modifier, et un autre pour démarrer
une nouvelle note vierge que l'utilisateur peut remplir et enregistrer.