SYSTÈME ANDROID

OHA – Open Handset Alliance

 Alliance internationale d’entreprises collaborant pour développer
Android.
 Composée de plusieurs types de compagnies :
o Opérateurs mobiles : Vodafone, Telefónica, Telecom Italia, China
Mobile...
o Fabricants de téléphones mobiles : Asus, HTC, LG, Motorola...
o Fabricants de semi-conducteurs : Intel, Nvidia, ARM...
o Éditeurs de logiciels : Google, eBay, PacketVideo...
o Distributeurs : Aplix Corporation, Borqs, TAT...

Application Framework – Android

Le framework Android est une couche logicielle qui fournit des outils et des
services aux développeurs pour créer des applications.
Il agit comme une interface entre le système d’exploitation Android et les
applications.

Composants principaux :

 Content Providers :
o Permettent à une application d’accéder aux données d'autres (ex :
Contacts).
o Permettent aussi de partager ses propres données.
 : Activity Manager
o Gère le cycle de vie des applications (lancement, pause, arrêt…).
 Location Manager :
o Fournit l’accès aux services de localisation (ex : GPS).
 Package Manager :
o Gère les informations des applications installées sur l’appareil.

 Notification Manager :
o Affiche des alertes et notifications personnalisées.
 Resource Manager :
o Accès aux ressources non-code (chaînes de caractères, images,
etc.).
 Telephony Manager :
o Accès aux services de téléphonie (appels, numéro de téléphone…).
 Window Manager :
o Gère les fenêtres d’affichage de l’interface.
  View System :
o Système riche et extensible de vues graphiques pour créer des
interfaces :
 Listes, grilles, boutons, zones de texte, etc.

Librairies Android

Caractéristiques générales :
 Android utilise des librairies spécifiques et tierces.
 Fournissent des fonctionnalités bas niveau.
 Légères et chargées dans chaque processus.
 Rapides à l'exécution.

Exemples de librairies :

1. Bionic libc :
2. WebKit :
3. SQLite :

 Stockage dans un fichier local, taille < 2 Mo.

4. Media Framework :
5. SSL .
6. FreeType :
7. SurfaceManager :
8. Opengles :
9. Sgl
Android Runtime (ART)

Rôle :

 Gère l'exécution des applications Android.

 Remplace l'ancienne machine virtuelle Dalvik.

Ajouts spécifiques Android :

 org.apache.commons.codec
 org.apache.commons.httpclient
 org.bluez, org.json

Caractéristiques de Dalvik :

 Basé sur une architecture à registre.

  Exécute des fichiers .dex (Dalvik Executable).

Types de compilation :

 JIT (Just In Time) : compilation au moment de l'exécution.

 AOT (Ahead Of Time) : traduire le code de l’application en code
machine au moment de l’installation de l’application(Android L)
 Android N combine JIT + AOT (partie fréquemment utilisée = AOT, le
reste = JIT).

Améliorations apportées par ART :

 Meilleure gestion du Garbage Collector (GC).

 Temps de pause réduit lors du GC.
 Prise en charge du profilage sans ralentissement.
 Nouvelles options pour débogage et diagnostic.

Noyau Linux Android

Basé sur le noyau Linux

 S'occupe de la gestion matérielle et des ressources systèmes.

Rôles principaux :

 Pilotes de périphériques : caméra, audio, clavier, affichage…

 Gestion des processus
 Gestion de la mémoire
 Gestion du réseau

Ajouts spécifiques pour Android :

 Alarme :
 Ashmem (Android Shared Memory) :
o Permet aux applications de partager la mémoire efficacement.

Binder IPC (Inter-Process Communication) :

 Système de communication entre processus.

 Chaque application s'exécute dans son propre processus.
 Permet le partage sécurisé des ressources.
 Gère la concurrence et la synchronisation.

Gestion de l’énergie
 PROCESSUS DE BOOT
 BOOT ROM

Le processus d’exécution démarre le « Boot Rom code » (A) Le boot ROM code
détecte le NAND (la mémoire interne du téléphone) en utilisant un registre
système qui est lié à des spécificités physiques de l’ASIC.

 BOOTLOADER
preparer la memoire pour pouvoir acquérir le noyaux(kernel)
 Kernel
Initialise les contrôleurs d’interruptions, les protections de
mémoire, le cache et le Scheduling. Le noyau lancer comme étant
le tout premier processus utilisateur le init process
 INIT PROCESS
Le processus init exécute le script d’initialisation init.rc. Et lance
les processus de service système.
 ZYGOTE

Le Zygote est le père de tous les processus lancés par le processu

init et démarre l’exécution la machine virtuelle de Dalvik.

 SYSTEM SERVER

Le premier composant java qui va s’exécuter sur le système.

Il démarre tous les services Android

 Fournisseurs de contenus Services(Service):Une tache qui
(android.content.ContentProvider) s’exécute sans interface, en avant
permettent le partage au sein ou plan ou en arrière plan dans une
entre applications longue période

Application

Activités(Activity): c’est une partie

ou l'interface d'une application Récepteurs d'Intents
ANDROID (android.content.BroadcastReceiver):
permet de déclarer être capable de
la 1ere activité est repondre a des intents
MAINACTIVITY

pour utiliser java on a besoin de déclarer un fichier

qui contient les balises(comme balise d'activité)
 TÂCHES
 Une tâche est un ensemble d’activités.
 Une activité ne provient pas nécessairement d’une seule
application.
 Android gère une pile de retour d’activités (Activity backstack).
 Lorsqu’on lance une activité, elle est empilée dans la pile.
 Lorsqu’on appuie sur le bouton Retour, l’activité courante est
dépilée de la pile.
 Forground activity :si l’orque user interagir avec l’application

Mainactivty ne sera jamais détruites

contrairement
ACTIVITÉ– au activités
CYCLE DE VIE
secondaires dans le retour en arrière

Ces méthodes sont protected void

*************************************
ÉTATS D’ACTIVITÉ
 Les applications peuvent être fréquemment tuées et redémarrées par le
système.
  L’état interne de l’application est sauvegardé avant sa fermeture.

 L’état sauvegardé est rechargé au redémarrage de l’application.

Cela se fait à travers des callbacks :
onSaveInstanceState : appelé avant que l’app soit tuée.
onRestoreInstanceState : appelé au redémarrage de l’app.

 Ces callbacks sont aussi appelés lors de la rotation de l’appareil.

 L’activité est alors tuée et redémarrée pour charger les nouvelles
ressources.
 Ces callbacks ne sont pas appelés si l’utilisateur ferme volontairement
l’application.
***************************************************************
Linux récupère la mémoire en supprimant les processus de faible priorité
Il y a cinq (05) niveaux de priorité
Android classe un processus dans le plus haut niveau qu’il peut lui affecter

Processus en avant plan (Foreground process) :Un processus

qui est nécessaire pour ce que l’utilisateur est entrain de faire
Processus visible (Visible process) :Un processus qui
**
n’interagit pas avec l’utilisateur mais il peut affecter ce que
l’utilisateur voit à l’écran
Processus service (Service process) :Un processus qui
exécute un service Lancé avec la méthode startService()
 INTENT
 Un Intent est une sous-classe de android.content.Intent.
 Il sert à lier deux composants Android (ex. : activités, services).
 Un Intent représente une intention de faire une action vers un composant.
 Utilisé pour communiquer entre Activités ou avec des Services.

Attributs d’un Intent

Nom : désignation de l’intent.
Action : identifiant de l’action (chaîne de caractères).
Data : URI ou type MIME représentant l’objet de l’intent.
Catégorie : chaîne précisant le type ou contexte de l’action.
Type : définit le type MIME des données.
Composant : nom du composant cible (ex. activité).
Extras : paramètres supplémentaires sous forme clé/valeur.
Flags : méta-informations pour un usage avancé.
IntentFilter :Spécifie quels types d’Intents une activité peut gérer.

INTENT implicite :
INTENT Permet de demander
INTENT
explicite :permet de au système de réaliser
lancer ne activité une action
particulière particulière sans viser
une Activité
spécifique

**********************************************************

Types de servie

 Foreground : Service qui s'exécute en premier plan, interactif avec

l'utilisateur.
  Background : Service qui fonctionne en arrière-plan, sans interaction
directe.
 Bound : Service lié à un processus ou ressource spécifique, dépend
d'autres éléments pour fonctionner.

BROADCASTRECEIVERS

 BroadcastReceiver : Classe qui reçoit des Intents et applique une

réaction sans interface utilisateur.
 Intent : Diffusé dans le système et reçu via la méthode onReceive().
Exemple : Réception d'un SMS.

Enregistrement des BroadcastReceivers :

1. Statique : Déclaré dans le fichier AndroidManifest.xml.
2. Dynamique : Enregistré à l'exécution avec Context.registerReceiver()
ou LocalBroadcastManager.registerReceiver().

Diffusion d'événements :
1. Normale : Traitement non ordonné (aucune priorité définie) avec
sendBroadcast().
2. Ordonnée : Traitement séquentiel dans l'ordre de priorité avec
sendOrderedBroadcast().

Méthode onReceive() :
 Courte durée : Ne permet pas de lancer une activité, un dialogue ou un
service.
 Si le traitement est lent, un service peut être lancé.
 Priorité élevée pendant l'exécution de onReceive()

**************************************************
CONTENT PROVIDER
 Permet de partager des données entre applications (ex. : contacts,
médias, historique).
  Les données sont stockées sous forme de tables de bases de données et
accessibles via des URIs.

Principales méthodes :
 ContentResolver : Gère l'accès aux données via des Content
Providers.
 query() : Permet de récupérer des données, renvoie un Cursor.
 insert(), update(), delete() : Méthodes pour manipuler les données.

Implémentation :
 Utiliser SQLiteOpenHelper pour gérer la base de données.
 Implémenter une sous-classe ContentProvider et surcharger les méthodes
nécessaires.
 Déclarer le Content Provider dans AndroidManifest.xml.

*************************************************
PROCESSUS ET THREAD
Le Main Thread (ou IU Thread) est le thread principal où s'exécutent :

 Méthodes liées aux événements : Gestion des interactions utilisateur.

 Méthodes du cycle de vie du service : Exécution des méthodes
onStart(), onPause(), etc., des services.
 Événements d'un BroadcastReceiver : Traitement des événements reçus
via onReceive().

Un thread :C’est un flux d'exécution indépendant dans un

programme.
→ Il permet d'exécuter des instructions en parallèle ou
indépendamment des autres parties du programme.
→ Par exemple, dans une application Android, un thread peut
afficher l'interface pendant qu’un autre télécharge des données.
  L'application doit répondre rapidement (moins de 5 secondes).
 Le Main Thread ne doit jamais être bloqué (risque de gel de l'interface).
 Éviter les opérations lourdes (réseau, base de données, etc.) sur le Main
Thread.

Solution : utiliser des Worker Threads:Permettent d’exécuter les tâches

lourdes en arrière-plan.

Types de Threads :

1. Thread rattaché à une activité

o S’arrête dès que l’activité est détruite.
o Pratique mais limité à la durée de vie de l’activité.
2. Thread non rattaché à une activité
o Continue même après la fermeture de l’activité.
o Utile pour des tâches longues comme le téléchargement ou la
synchronisation.

************************************************************

MÉCANISME DE THREADING ANDROID

 Seul le Main Thread (UI Thread) peut modifier l’interface utilisateur.

 Pour accéder à l’UI depuis un autre thread, on utilise :

1. Activity.runOnUiThread(Runnable) : exécute un code sur le thread UI.

2. View.post(Runnable) : ajoute une tâche à la file du thread UI via une
vue.
3. View.postDelayed(Runnable, long) : ajoute une tâche avec un délai.

Temps de réponse (<5secs)

****************************************************************
Thread Safe

 Une méthode est thread safe si elle peut être appelée par plusieurs
threads en même temps sans erreur.

Handler :
 Outil Android pour gérer les tâches en arrière-plan.
 Attaché à un thread spécifique.
  Utilise une file de messages pour exécuter des tâches via une méthode
callback (comme handleMessage()).
 Permet d’exécuter des opérations longues ou complexes de manière
organisée.

AsyncTask
 Exécute des tâches courtes en arrière-plan.
 Met à jour automatiquement l’UI sans gérer les threads.
 Utilise trois types : Params (entrée), Progress (avancement),
Result (résultat).

Méthodes de AsyncTask

 onPreExecute() :
→ Préparation avant exécution (UI Thread).
 doInBackground() :
→ Traitement en arrière-plan (Background Thread).
 onProgressUpdate() :
→ Affiche l’avancement (UI Thread).
 onPostExecute() :
→ Affiche le résultat final (UI Thread).

*************************************************************

GESTION DE PROCESSUS
CFS COMPLETELY FAIRE SCHEDULING
Le Quantum pour chaque processus (fixe) :

TL : Latence ciblée (période de temps ou les runnable(thrad) sont exécuté au

moins une fois)
Wi : le poids de la tâche i
n : le nombre de tâches dans l’état runnable
 Le nice : - entre -20 et 19 (la valeur la plus faible désigne une plus
haute priorité)
-induit le temps de calcul alloué a chaque processus
 Le poids : - pré calculé: Weight(nice) ≈ 1024/1.25^(nice)

le vruntime est incrémenté par :

 t: temps d’exécution dans l’UC (temps cumuler passer dans CPU)

 Wo: le poids avec nice 0
 Wi: le poids avec nice i

Le vruntime le plus petite indique

le processus le plus prioritaire

**************************************************************
GESTION DE LA MÉMOIRE
 La taille d’une page est de 4KB
 RAM
Cached Memory

Mémoire associée à des fichiers déjà stockés (ex. : code app, fichiers).

 Privée : utilisée par un seul processus.

 Partagée : utilisée par plusieurs processus.

Chaque type peut être :

 Originale : copie non modifiée → libérable par kswapd.

 Modifiée :
o Privée → peut être compressée via zRam.
o Partagée → peut être enregistrée sur le disque via kswapd, msync()
ou munmap().

Mémoire Anonyme

 Allouée sans fichier, avec mmap() + MAP_ANONYMOUS.

 Si modifiée → peut être compressée par zRam (via kswapd).

Young Catégories d'objets selon leur durée de vie Permanent

GENERATION
Generation
Older Generation

Garbage Collector (GC) – Android

Identifier et libérer automatiquement la

mémoire occupée par des objets inutilisés
sans intervention du programmeur.
 KSWAPD
Libère les pages qui sont enregistrées en Storage et qui n’ont pas été modifiées
(page originale)
 Dans le cas où le kswapd ne libère pas assez de mémoire, le système
utilise LOW MEMORY KILLER LMK
****************************************************************
CALCUL ESPACE OCCUPÉ PAR APPLICATION
Pour calculer l’espace occupé le systèmes utilise les métriques suivantes :

 Resident Set Size (RSS): le nombre de pages partagées et non partagées

 Proportional Set Size (PSS): le nombre de pages non partagé et une distribution des
pages partagées
 Unique Set Size (USS): le nombre de pages non partagées,
**************************************************************
GESTION DE L’ENERGIE
 Power manager : Contrôle la gestion de l’energie pour l’appareil
 Power Service : surveille l'état de la batterie (niveau, température…).
 Batterie Driver : communique avec la batterie physique.
Fonctionnement :

 Le Batterie Driver envoie des infos ➝

 Le Power Service réagit (ex : arrêt du système si surchauffe ou batterie
critique).

Wake Locks
 But : empêcher CPU/écran de s’éteindre pendant une tâche critique (mode
veille).
 Types :
o PARTIAL_WAKE_LOCK → CPU ON, écran OFF
o SCREEN_DIM_WAKE_LOCK → écran DIM, clavier OFF
o SCREEN_BRIGHT_WAKE_LOCK → écran BRIGHT, clavier
OFF
o FULL_WAKE_LOCK → CPU + écran + clavier ON

Doze Mode :économiser la batterie quand

l’appareil est inactif.contrairemnt a IDLE qui
économise la batterie de chaque application

 Après une période d’inactivité (écran éteint

et immobile), le système entre en Doze.