Développement des Applications Mobiles

Click icon to add picture

Android Activity
and
Fragment
Badis Djamaa & Adnane Benaissa
Ecole Militaire Polytechnique
 2

Sujets d’aujourd'hui

1. La classe activité

2. La pile (backstack) et le cycle de vie des activités

3. Commencer des activités et gérer les changements

4. La classe Fragment

5. Cycle de vie du fragment et ses interactions avec l’activité

6. Les Fragments et les changements de configuration

 3

Les composantes d’une applications (1)

Les composants peuvent être classés en éléments applicatifs et éléments d’interaction

• Les éléments d'une application

• des activités (android.app.Activity): il s'agit d'une partie de

l'application présentant une vue à l'utilisateur

• des services (android.app.Service): il s'agit d'une activité tâche de fond

sans vue associée
• des fournisseurs de contenus (android.content.ContentProvider): permet
le partage d'informations au sein ou entre applications
• des Intents (android.content.Intent): permet d'envoyer un message pour
un composant externe sans le nommer explicitement
• des récepteurs d'Intents (android.content.BroadcastReceiver): permet de
déclarer être capable de répondre à des Intents
 4

Les composantes d’une applications (2)

Le code source est un ensemble d’Activités

 5

Les activités des applications (1)

Elle correspond à la partie présentation de l'application : correspond à un écran

• Représente le bloc de base d'une application

• Fonctionne par le biais de vues qui affichent des interfaces graphiques
• Elle est composée d'une hiérarchie de vues contenant elles-mêmes d'autres vues
• Une application comportant plusieurs écrans, possédera donc autant d'activités
 6

Les activités des applications (2)

Une activité est composée de deux volets :

• Sa logique métier et la gestion de son cycle de vie

• Implémentés en Java dans une classe héritant de Activity

• Son interface utilisateur

• Deux façons alternatives pour sa définition:

• Dans le code de l'activité

• Dans un fichier XML

 7

Logique métier d'une activité : Squelette minimal

 8

L’Activité dans le Manifest

La balise <activity> déclare une activité

• Les paramètres généralement utilisés sont :

• name qui désigne la classe de l'activité
• label qui désigne le nom sous lequel elle apparaîtra sur le terminal
• icon qui désigne l'icône à afficher sur le terminal

• Structure
 9

Navigation entre les activités

Android soutient la navigation de plusieurs façons:

• Les tâches (La pile des activités)

• Une tâche est un ensemble d'activités connexes

• Ces activités connexes ne doivent pas nécessairement faire
partie de la même application
• La plupart des tâches commencent à l'écran d'accueil

• Les Intents

• Le graph de navigation

• un fichier de ressources qui contient toutes les activités de

votre application ainsi que les connexions / actions pour
naviguer entre les destinations.
• Vous pouvez le gérer à l'aide de l'éditeur de navigation
dans Android Studio

https://developer.android.com/guide/navigation/navigation-design-graph
 10

Les tâches et la pile backstack (1)

• Une tâche est un ensemble d'activités avec lesquelles les • Lorsqu'une Activité d’une tâche est
utilisateurs interagissent lorsqu'ils effectuent un travail. lancée, elle passe au-dessus de la pile

• Les activités sont organisées dans une pile (la pile arrière). • Lorsque l'activité est détruite, elle est
extraite de la pile arrière

une tâche
 11

Les tâches et la pile backstack (2)

• Lorsque l'utilisateur quitte une tâche en appuyant sur le

• Lorsque l'activité A démarre l'activité B, A est arrêtée, mais
bouton Accueil, l'activité en cours est arrêtée et sa tâche
le système conserve son état (comme la position de
passe en arrière-plan. Le système conserve l'état de
défilement, le texte entré dans les formulaires).
chaque activité de la tâche.
• Si l'utilisateur appuie sur le bouton Retour pendant
• Si l'utilisateur reprend tâche en sélectionnant l'icône du
l'activité B, l'activité A reprend avec son état restauré.
lanceur, la tâche vient au premier plan et reprend
l'activité B est extraite de la pile et détruite
l'activité en haut de la pile.
https://developer.android.com/guide/components/activities/tasks-and-back-stack
 12

Cycle de vie d’une activité

• Les activités sont créées, suspendues, reprises et détruites au besoin lorsqu'une application exécute
• Certaines de ces actions dépendent du comportement de l'utilisateur
• Certains dépendent d'Android, par exemple, Android peut tuer les activités quand il a besoin de ses ressources

Les états principaux du cycle de vie

• Active: Reprise/Exécution - visible, interaction de l'utilisateur
• Activité visible qui détient le focus utilisateur et attend les entrées utilisateur
• Appel à la méthode onResume()

• En pause - visible, l'utilisateur n'interagit pas, peut être terminé*

• Activité au moins en partie visible à l'écran mais qui ne détient pas le focus
• Appel à la méthode onPause() pour entrer dans cet état

• Arrêté - non visible, peut être résilié

• Appel de la méthode onStop()

Android annonce les changements d'état du cycle de vie d'activité en appelant des méthodes d'activité spécifiques.
 13

Les méthodes du cycle de vie d’une activité (1)

protected void onCreate (Bundle savedInstanceState): on instancie les objets

protected void onStart() on lance les traitements

protected void onResume() on s'abonne et on remet le contexte utilisateur

protected void onPause() on se désabonne et on enregistre le contexte utilisateur 

protected void onRestart() on relance les traitements

protected void onStop() on arrête les traitements et on désalloue les objets

protected void onDestroy() généralement on ne fait rien

 14

Les méthodes du cycle de vie d’une activité (2)

protected void onCreate (Bundle savedInstanceState)

• Appelé lorsque l'activité est créée

• Configure l'état initial
• Appelez super.onCreate ()
• Définir la vue du contenu de l'activité
• Conserver les références aux vues de l'interface utilisateur si nécessaire
• Configurer les vues si nécessaire

protected void onStart()

• OnStart: l'activité est sur le point de devenir visible

• Actions typiques: démarrer des comportements visibles (visible-only

behaviors), chargement de l'état d'application persistant
 15

Les méthodes du cycle de vie d’une activité (3) : exemple onCreate()

 16

Les méthodes du cycle de vie d’une activité (4)

protected void onResume()

• L'activité est visible et sur le point de commencer à interagir avec

l'utilisateur

• Actions typiques: démarrer des comportements au premier plan

uniquement (foreground-only behaviours)

protected void onRestart()

• Appelé si l'activité a été arrêtée et est sur le point de recommencer

• Actions typiques: traitement spécial nécessaire uniquement après avoir

été arrêté
 17

Les méthodes du cycle de vie d’une activité (5) : exemple

Click icon to add picture Click icon to add picture

 18

Les méthodes du cycle de vie d’une activité (6)

protected void onPause()

• Appelé lorsque durant le passage à une autre activité (focus about to switch)
• Actions typiques: arrêter les comportements au premier plan uniquement, enregistrer
l'état persistant

protected void onStop()

• L'activité n'est plus visible par l'utilisateur peut être redémarrée plus tard
• Actions typiques: mettre en cache l'état de l'activité et libérer ses ressources
• Remarque: ne peut pas être appelé si Android tue votre application

protected void onDestroy()

• L'activité est sur le point d'être détruite

• Actions typiques: libérer des ressources d'activité
• Remarque: ne peut pas être appelé si Android tue votre application

Généralement, on surcharge: onCreate, onResume, onPause, onSaveInstance, onRestoreInstance et onStop ;

 19

Les méthodes du cycle de vie d’une activité (7) : exemple

 20

cycle de vie complet d’une activité (1)

 21

cycle de vie complet d’une activité (2)

cycle de vie complet (3)
22
 23

Commencer une activité (1)

Créer un objet Intent spécifiant l'activité à démarrer

Passent nouvellement créé Intent à des méthodes, telles que:

• StartActivity ()

• StartActivityForResult ()

• Appelle une méthode de rappel lorsque l'activité appelée se

termine pour retourner un résultat

Intent sera détailler dans une prochaine séance.

 24

Commencer une activité (2)

 25

Les Activités et les changement de configurations

Clavier, orientation, etc.

• Configuration de l'appareil peut changer lors de l'exécution

• Pour chaque changement de configuration, Android tue

habituellement l'activité en cours et la redémarre.

• Le redémarrage de l'activité devrait être rapide.

• Si nécessaire, vous pouvez:

• Conserver un objet contenant des informations importantes lors

d'un changement de configuration.

• Manipuler manuellement le changement de configuration

 26

Changement de configurations : Retenir un objet

Les données difficiles à recalculer peuvent être mises en cache pour accélérer la gestion des changements de
configuration.

• Redefinir onRetainNonConfigurationInstance () pour construire et renvoyer l'objet de configuration

• Sera appelé entre onStop () et onDestroy ()

Appeler getLastNonConfigurationInstance () pendant onCreate () pour récupérer l'objet conservé

Note: Ces méthodes ont été abandonnées en faveur des méthodes dans la class Fragment a
partir de la version 3.0 (L'activité meurt mais le fragment “top-level” reste)
 27

Gestion manuelle du changement de configurations

• Peut empêcher le système de tuer et redémarrer Activité

• Pour ce faire, déclarez les changements de configuration de vos descripteurs d'activité dans le fichier
AndroidManifest.xml,

• Lors des changements de configuration, la méthode onConfigurationChanged () de l'activité s'appelle. On lui

passe un objet de configuration spécifiant la nouvelle configuration du périphérique
 28

Adaptation des activités à touts les appareils existants

Gestion Manuelle dans la class Activity:

• Créer plusieurs layouts selon les tailles d'écrans (layout-small, layout-normal, layout-large, layout-xlarge), pour
obtenir l'I.H.M. souhaitée en fonction des caractéristiques de l'écran.

• Par contre, l'activité qui contrôlait tous ces cas devenait très complexe; la capacité d'un esprit humain à
comprendre, modifier, corriger ou faire évoluer l'activité devenait réduite, les méthodes du cycle de vie faisaient 50 à
100 lignes. Et finalement, l'activité devenait ingérable.

La class Fragment:

• Créer une manière simple, efficace et réutilisable pour l'adaptation d'une application Android à toutes les tailles
d'appareils existants.
 29

Les Fragments (1)

• Un fragment: sous-activité introduite par la version 11 (Android 3.0). Est un composant indépendant qui permet de
découper un écran en plusieurs partie, plusieurs fragments.

• Les fragments permettent de scinder vos activités en composants encapsulés et réutilisables qui possèdent leur
propre cycle de vie et leur propre interface graphique.
 30

Les Fragments (2)

De même que pour une Activity, un fragment à:

• Typiquement une interface (layout) en XML, mais peut aussi être utilisés
pour retenir un état lors de la destruction/reconstruction de leur activité
parente (remplacer onRetainNonConfigurationInstance);

• et une classe associée en code source, cette classe doit hérité de la

classe android.app.Fragment

Un fragment s'exécute dans le contexte d'une activité mais possède son propre cycle de vie

Les fragments peuvent être ajoutés à une activité de manière statique (définis une fois pour toutes dans le fichier de
layout) ; ou dynamique (créés, supprimés, ajoutés dynamiquement)

Les classes fondamentales de gestion des fragments sont : Fragment, FragmentManager et FragmentTransaction.
On peut aussi utiliser les sous-classes  : ListFragment and DialogFragment
 31

Cycle de vie d'un fragment

Comme l'activité, un fragment possède son propre cycle de vie mais il est toujours connecté au cycle de vie de
l'activité qui l'utilise. Comme une activité, un fragment peut exister dans trois états:

• A repris (Actif): Le fragment est visible dans l'activité en

cours d'exécution.

• En pause: Une autre activité est au premier plan et a le focus,

mais l'activité dans laquelle vit ce fragment est toujours visible
(l'activité au premier plan est partiellement transparente ou ne
couvre pas tout l'écran).

• Arrêté: Le fragment n'est pas visible. Soit l'activité hôte a été

arrêtée, soit le fragment a été supprimé de l'activité mais
ajouté à la pile backstack. Un fragment arrêté est toujours
vivant (toutes les informations d'état et de membre sont
conservées par le système). Cependant, il n'est plus visible
pour l'utilisateur et est supprimé si l'activité est supprimée.
 32

Méthodes du cycle de vie d'un fragment (1)

• onAttach, Appelé lorsque le fragment a été associé à l'activité (l'activité est passée ici).
• on récupère un pointeur vers l'activité contenante ;

• onCreate, on instancie les objets non graphiques ;

• onCreateView, Appelé pour créer la hiérarchie de vues associée au fragment

• on instancie la vue et les composants graphiques ;

• onActivityCreated, Appelé lorsque la méthode onCreate () de l'activité est retournée

• on récupère un pointeur sur l'activité (qui est construite), on lance les initialisations qui ont
besoin de cette activité, on restaure le contexte des fragments et utilisateur.

• onStart, on lance les traitements ;

• onResume, on s'abonne et on remet le contexte utilisateur ;

• onPause, on se désabonne et on enregistre le contexte utilisateur ;

 33

Méthodes du cycle de vie d'un fragment (1)

• onStop, on arrête les traitements et on désalloue les objets ;

• onDestroyView, Appelé lorsque la hiérarchie de vues associée au fragment est supprimée.

• la vue est détachée de celle de l'activité, on peut délivrer la mémoire des objets graphiques ;

• onDestroy, généralement , ne rien faire  ;

• onDetach, Appelé lorsque le fragment est dissocié de l'activité.

• généralement , ne rien faire.

Généralement en surcharge: onCreate, onCreateView, onActivityCreated, onResume, onPause, et

onStop.
Au minimum: vous devez implémenter au moins les méthodes de cycle de vie suivantes: onCreate
(), onCreateView () et onPause ()
 34

Méthodes principales du cycle de vie d'un fragment (1)

La plupart des applications doivent implémenter au moins ces trois méthodes pour chaque fragment

• onCreate (): Le système appelle cette methode lors de la création du fragment.

• Dans votre implémentation, vous devez initialiser les composants essentiels du fragment que vous souhaitez
conserver lorsque le fragment est suspendu ou arrêté, puis repris.

• onCreateView (): Le système appelle cette methode lorsqu'il est temps que le fragment dessine son interface
utilisateur pour la première fois.

• Pour dessiner une interface utilisateur pour votre fragment, vous devez renvoyer une vue de cette méthode
qui est la racine du layout de votre fragment. Vous pouvez retourner null si le fragment ne fournit pas
d'interface utilisateur.

• onPause () : Le système appelle cette méthode comme la première indication que l'utilisateur quitte le fragment
(bien que cela ne signifie pas toujours que le fragment est détruit).

• C'est généralement là que vous devez valider toutes les modifications qui devraient persister au-delà de la
session utilisateur en cours (car l'utilisateur peut ne pas revenir).
 35

Méthodes principales du cycle de vie d'un fragment (2)

onCreateView: Dans la pratique, la méthode onCreateView est la méthode que l'on utilise pour créer la vue qui
sera affichée par le fragment. C'est la méthode qui est systématiquement surchargée.

Le code typique de la méthode onCreateView instancie le fichier xml pour en construire une vue et la renvoyer :

• inflater : Il permet d’instancier le fichier layout XML dans l’objet View correspondant.

• container : Si non-null, correspond à la vue parente qui contient le fragment et à laquelle la vue du fragment va
s'attacher ;
• savedInstanceState : si non-null, le fragment est reconstruit à partir d'un état précédent sauvegardé et transmis par
ce paramètre.
 Le cycle de vie d'un fragment
(pendant que son activité est en cours).

le fragment est ajouté au backstack

l'utilisateur navigue vers l'arrière ou le

fragment est supprimé/remplacé
Cycle de vie complet d'un fragment

le fragment revient au layout

depuis le backstack
36
 37

Ajout d'un fragment à une activité: statique

Habituellement, un fragment contribue une partie de l’UI à l'activité hôte, qui est incorporée dans le cadre de la
hiérarchie de vue globale de l'activité. Il existe deux façons d'ajouter un fragment à l'activité:

• Déclarez le fragment dans le fichier de mise en page de l'activité (statique): Dans ce cas, vous pouvez spécifier
les propriétés du layout du fragment comme s'il s'agissait d'une vue.
 38

Ajout d'un fragment à une activité: statique (2)

• Lorsque le système crée le layout d'activité, il instancie chaque fragment spécifié dans le layout et appelle la
méthode onCreateView () pour chacun.

• Pour récupérer le layout de chaque fragment. Le système insère la vue renvoyée par le fragment
directement à la place de l'élément <fragment>.

• L’attribut android:name dans <fragment> spécifie la classe Fragment a instancier dans le layout

• A ce point, on peut même accéder aux objets du layout du fragment en utilisant findViewById
. 39

Ajout d'un fragment à une activité: dynamique (1)

• Ajouter le fragment par programmation dans un ViewGroup existant (Dynamique): À tout moment pendant
l'exécution d’une activité, vous pouvez ajouter des fragments. Il vous suffit de spécifier un ViewGroup dans lequel
placer le fragment.

• Pour effectuer des transactions de fragment dans votre activité (comme ajouter, supprimer ou remplacer un
fragment), vous devez utiliser les API de FragmentTransaction. Vous pouvez obtenir une instance de
FragmentTransaction de votre FragmentActivity comme ceci:

• Vous pouvez ensuite ajouter un fragment à l'aide de la méthode add (), en spécifiant le fragment à ajouter et la vue
dans laquelle l'insérer. Par exemple:
. 40

Ajout d'un fragment à une activité: dynamique (2)

• Maintenant, vous pouvez configurer toutes les modifications que vous souhaitez effectuer pour une transaction
donnée à l'aide de méthodes telles que add (), remove () et replace ().

• Pour appliquer la transaction à l'activité, vous devez appeler commit ().

• Cependant, avant d'appeler commit (), vous pourriez vouloir appeler addToBackStack (), afin d'ajouter la
transaction à la pile backstack gérée par l'activité et permet à l'utilisateur de revenir à l'état de fragment
précédent, en appuyant sur le bouton Retour.
 41

Coordination avec le cycle de vie de l'activité (1)

• Le cycle de vie de l'activité dans laquelle vit le fragment affecte directement le cycle de vie du fragment, de sorte que
chaque rappel de cycle de vie pour l'activité entraîne un rappel similaire pour chaque fragment. Par exemple, lorsque
l'activité reçoit onPause (), chaque fragment de l'activité reçoit onPause ().

• Les fragments ont cependant quelques rappels de cycle de vie supplémentaires qui gèrent une
interaction unique avec l'activité afin d'effectuer des actions telles que créer et détruire l'interface
utilisateur du fragment.

• Le s rappels supplémentaires sont aussi affectés par les rappels de cycle de vie de l’activité. Par
exemple, lorsque l'activité a reçu son rappel onCreate (), un fragment de l'activité reçoit des
rappels jusqu’a onActivityCreated ().

• Une fois que l'activité a repris, vous pouvez librement ajouter et supprimer des fragments de
l'activité. Ainsi, ce n'est que lorsque l'activité est à l'état repris que le cycle de vie d'un fragment
peut changer indépendamment.

• Cependant, lorsque l'activité quitte l'état repris, le fragment est à nouveau poussé à travers son
cycle de vie par l'activité.
 42

Coordination avec le cycle de vie de l'activité (2)

 43

Coordination avec le cycle de vie de l'activité (3)

 44

Communication Fragment - Activité

• L'objectif d'un fragment est d'être utilisé par plusieurs activités. De ce

fait, le fragment ne peut pas connaître l'activité qui le contient.

• Dans certains cas, vous pourriez avoir besoin d'un fragment pour partager
des événements ou des données avec l'activité

• Question: comment communique-t-il avec elle ?

• L'idée est simple, toute activité qui souhaite recevoir les évènements d’un
fragment implémente une interface qui sera utilisée par le fragment pour
communiquer avec son conteneur.

• De l’autre coté, une activité connait les fragments qu'elle contient, elle
peut donc pointer directement sur eux.
 45

Communication Fragment – Activité: notification de l’activité (1)

• Par exemple, si une application d'actualités contient deux fragments dans une activité - un pour afficher une liste
d'articles (fragment A) et un autre pour afficher un article (fragment B) - alors le fragment A doit indiquer
l'activité lorsqu'un élément de liste est sélectionné afin qu'il peut dire au fragment B d'afficher l'article.

• Dans ce cas, l'interface OnArticleSelectedListener est déclarée dans le

fragment A:

• L'activité qui héberge le fragment implémente ensuite l'interface OnArticleSelectedListener et overrides

onArticleSelected () pour notifier le fragment B de l'événement du fragment A.
 46

Communication Fragment – Activité: notification de l’activité (2)

• Pour garantir que l'activité hôte implémente cette interface, la méthode de rappel onAttach () du fragment A
(que le système appelle lorsque l'ajout du fragment à l'activité) instancie une instance de
OnArticleSelectedListener en transtypant l'activité transmise à onAttach ():

• Si l'activité n'a pas implémenté l'interface, le fragment lève une exception ClassCastException.
 47

Communication Fragment – Activité: notification de l’activité (3)

• En cas de succès, listener détient une référence à l'implémentation de OnArticleSelectedListener par

l'activité.
• De cette façon, le fragment A peut partager des événements avec l'activité en appelant des méthodes définies
par l'interface OnArticleSelectedListener.
• Par exemple, si le fragment A est une extension de ListFragment, chaque fois que l'utilisateur clique sur un
élément de liste, le système appelle onListItemClick () dans le fragment, qui appelle ensuite
onArticleSelected () pour partager l'événement avec l'activité:
 48

Communication Fragment – Activité: gestions des fragments

• L’activite communique et gére ses fragments en utilisant FragmentManager. Pour l'obtenir, appelez
getSupportFragmentManager () depuis votre activité.

• Avec FragmentManager, l’activite peut:

• Obtenir des fragments de l'activité, avec findFragmentById () (pour les fragments qui fournissent une
interface utilisateur dans la présentation de l'activité) ou findFragmentByTag () (pour les fragments qui
fournissent ou non une interface utilisateur).

• Pop fragments hors de la pile arrière, avec popBackStack () (simulant une commande Retour par
l'utilisateur).

• Enregistrez un écouteur pour les modifications apportées à la pile arrière, avec

addOnBackStackChangedListener ().

• Comme vu precedement, l’activite peut également utiliser FragmentManager pour ouvrir une
FragmentTransaction.
 49

Les Fragments et les changement de configurations

• Mémoriser les fragments sans en-tête pour gérer les changements de configuration.

• Un fragment mémorisé n'est pas détruit lors des changements de configuration.

• L'appel à setRetainInstance (true) à l'intérieur de Fragment protège le contre la destruction.

 50

Thank You

R e a d y f o r Yo u r
Questions