ALLER PLUS LOIN DANS LE DÉVELOPPEMENT ANDROID

Transcription

1 ALLER PLUS LOIN DANS LE DÉVELOPPEMENT ANDROID Andr0 29 octobre 2015

2

3 Table des matières 1 Introduction 5 2 Fragmenter vos projets Fragment Introduction aux fragments Utiliser des fragments fixes Utiliser des fragments dynamiques Attacher un bundle En résumé ListFragment Utilisation simple des listes Intégrer une vue personnalisée Vers des listes dynamiques En résumé Interfaces dynamiques Concevoir une interface dynamique Initialiser l activité hôte Communication entre les fragments En résumé PreferenceFragment Définir ses préférences Intégrer ses paramètres dans une activité Affiner ses paramètres avec les en-têtes Lire les préférences En résumé DialogFragment Créer un DialogFragment Créer un AlertDialog Afficher une boite de dialogue En résumé Conclusion Remerciements

4

5 1 Introduction Le développement mobile est devenu incontournable pour les entreprises. Elles se doivent d offrir des solutions mobiles pour leurs clients ou une vitrine mobile pour elles-mêmes. Le développement Android est d autant plus important puisqu il occupe une majeure partie du marché. Ce tutoriel n abordera pas de notions complexes mais les bases sont des pré-requis. Celles-ci peuvent être acquises dans ce tutoriel Android. Ce dernier aborde l utilisation des composants basiques du développement, nécessaire pour commencer. Dans le tutoriel ci-présent, un point d honneur est placé sur des notions utilisées en entreprise et couvrant une majeure partie des versions d Android. En effet, au vue de la diversité des constructeurs et des terminaux qu ils confectionnent, Google a du mal à migrer tous les smartphones vers la dernière version du système. C est pourquoi, la diversité est importante et il a fallu que Google puisse offrir une solution aux développeurs pour pouvoir maintenir et développer efficacement sur Android. Figure 1.1 Diagramme de la répartition des versions daté du 3 Juin 2013 Il sera enseigné le développement pour les nouveaux systèmes tout en restant compatible le plus possible vers les anciens systèmes (jusqu à Froyo en général). Ces notions sont, pour certaines, difficiles à acquérir tant les ouvrages sont peu nombreux sur les nouvelles fonctionnalités intégrées au système. L objectif est d aborder des notions avancées mais intéressantes sur le développement Android en restant accessible aux débutants. Tout ce qui figurera sera consciencieusement expliqué afin de vous permettre d en comprendre les concepts et de pouvoir les mettre en pratique directement, à travers des travaux pratiques sérieux. 5

6 1 Introduction Pour parvenir à atteindre cet objectif, une série de choses sont abordées : L utilisation de fragments pour confectionner des interfaces souples et avancées. Les derniers composants ajoutés dans les dernières versions d Android. La mise en place d un serveur pour effectuer des requêtes HTTP tout en gardant à l esprit le cycle de vie de l application et la batterie de l utilisateur final. [[information]] Tous les codes sources de ce tutoriel sont disponibles sur ce projet GitHub afin que vous puissiez consulter des exemples fonctionnels directement exécutables sur un terminal ou un émulateur. 6

7 2 Fragmenter vos projets Depuis Android 3.x, les fragments est apparus dans le développement d applications. Ils sont maintenant utilisés pour le développement de toutes les applications (du moins sérieuses) sur le Google Play Store. Ils permettent d isoler des portions d interfaces qui sont gérées par des classes héritant de Fragment plutôt que de Activity. Les fragments ressemblent aux activités, que cela soit dans son cycle de vie que dans les différentes sous-classes qu il peuvent créer. Ils se composent du type de base, des listes, des boites de dialogue et des écrans conçus pour paramétrer son application. Leurs utilisations seront expliquées via des exemples simples et claies pour présenter leurs fonctionnements. 2.1 Fragment Tout comme les activités, il existe un fragment «générique». Il peut inclure des listes, des écrans de préférences et toutes les vues du framework Android pour constituer des portions d interfaces. Par la suite, elles pourront être réutilisées plusieurs fois dans les écrans de l application finale. Pour expliquer en profondeur tous ces concepts, une explication détaillée des fragments est donnée dans la suite de ce chapitre Introduction aux fragments Qu est ce qu un fragment? Les fragments ne sont pas simples à comprendre. Cette notion est souvent confuse pour les débutants et pas toujours bien comprise par les développeurs expérimentés. En effet, les possibilités offertes sont nombreuses et intéressantes. Les fragments sont à mi-chemin entre les activités et les vues. Il ne s agit ni de l un, ni de l autre mais ils sont étroitement liés avec ces concepts. Les fragments permettent de définir des morceaux d interfaces, un ensemble de vues, qu il est possible de contrôler et de réutiliser sur plusieurs écrans. En temps normal, une application est destinée à être exécutée aussi bien sur les smartphones que sur les tablettes, et peu à peu sur les télévisions connectées. La taille des écrans devient de plus en plus grande. Il faut pouvoir exploiter l espace efficacement sur chacune de ces plates-formes et, si possible, à partir d un seul projet. Ce dernier point sera expliqué bien plus tard dans ce cours au vue de sa complexité. Par exemple, le propriétaire d un blog pourrait légitimement vouloir développer sa propre application pour offrir une alternative mobile à ses lecteurs. Dans un blog simpliste, il voudrait permettre une consultation de ses articles et des commentaires associés. Une version smartphone consisterait dans l affichage de trois écrans : une liste des articles du blog, l article courant que 7

8 2 Fragmenter vos projets le lecteur consulte et les commentaires associés. Sur une tablette en mode paysage, il est possible de restreindre les écrans à un seul en affichant la liste des articles à gauche et l article et ses commentaire à droite. Ce genre de chose est possible grâce aux fragments! Le cycle de vie des fragments Les activités sont régulées par un cycle de vie. Les fragments possèdent des similitudes sur ce point avec les activités. Ils définissent une interface qu ils contrôlent mais ils ne sont pas associés à un écran. Ils ne font que s y attacher. C est la raison pour laquelle leurs cycles de vie sont semblables mais pas identiques. Ils possèdent les méthodes callback d une activité, à savoir oncreate, onstart, onresume, onpause, onstop et ondestroy. Ces méthodes ont le même objectif que dans une activité. Elles ne seront pas (ou peu) expliquées. La documentation donne des informations à ce sujet en cas d oubli. Plusieurs nouvelles méthodes ont été rajoutées à travers ce cycle de vie. Elles sont liées à l activité hôte en cours d exécution. Il ne faut pas perdre à l esprit qu un fragment n est qu attaché à une activité. Les méthodes supplémentaires sont liées à cette activité. La documentation met à disposition un schéma pour donner le cycle de vie. Les méthodes rajoutées sont onattach, oncreateview, onactivitycreated, ondestroy- View et ondetach. Les noms de ces méthodes sont assez explicites. Deux sont destinées à la liaison avec l activité hôte, deux autres à la création de la vue qui compose le fragment et la dernière après la création de l activité hôte. Elles seront expliquées plus en détail dans la suite de ce chapitre ainsi que dans les suivants de cette partie La bibliothèque de compatibilité Le fragment est une nouveauté depuis Android 3.x. A partir de cette version, il est possible de les placer librement aux endroits voulus pour rendre les applications plus souples et les architecturer convenablement. Cependant, la version 2.3 d Android est encore largement utilisée, surtout dans les smartphones d entrée de gamme mais ils ne peuvent pas utiliser les fragments. Pourquoi ne pas avoir intégré les fragments dès le début? Google n a pas pu voir assez loin sur le long terme. Au début, Android était dédié uniquement aux smartphones. Les écrans avaient des tailles différentes en fonction du constructeur, voire du modèle, mais le marché des tablettes était presque inexistant. Les tailles ne dépassaient pas le 4 pouces. Une fois que les tablettes ont commencées à être commercialisées en grande quantité, Google a été contraint d offrir une alternative pour ce type d appareil. La version 3.x d Android était destinée à résoudre le problème mais ce n est qu à partir de la version 4 qu un tournant a pu être noté. Le plus grand défaut de la troisième version du système était sa philosophie. Même s il était meilleur que les versions précédentes, il n était pas prévu pour les smartphones. [[information]] Aujourd hui, de plus en plus de télévisions connectées sur Android sont commercialisées. Il est tout à fait possible de développer pour ce genre d appareil mais les bonnes pratiques d ergonomie sont encore un peu vagues. C est pourquoi, aucun exemple concret ne sera montré mais les techniques apprises dans ce tutoriel le permettront. Dans le but de ne pas devoir créer un projet pour chaque version d Android, Google a développé une bibliothèque de compatibilité qu il est possible d utiliser dans n importe quel projet. Cette 8

9 2.1 Fragment 9

10 2 Fragmenter vos projets bibliothèque donne accès à presque toutes les nouvelles notions qu apporte la version 3.x mais aussi la 4.x qui apporte son lot de nouveautés (elles seront expliquées dans la seconde partie). Grâce à cette bibliothèque, les applications développées toucheront plus de 90% du marché des appareils. Raison pour laquelle toutes les notions apprises seront basées sur son utilisation dès que possible. Il est également conseillé de développer avec ce projet même si l application finale n est pas destinée à être compatible avec les anciennes versons. Personne ne sait de quoi est fait demain Utiliser des fragments fixes!(http :// La théorie maintenant terminée, la pratique permet d en comprendre réellement le fonctionnement. Il existe deux façons d intégrer des fragments à une activité : de manière fixe en spécifiant les fragments dans le fichier XML d affichage de l écran voulu et dynamiquement avec l aide des outils mis à la disposition des développeurs dans le framework Android Création d un fragment La création d un fragment est similaire à la création d une activité. La portion d interface se déclare dans un fichier XML d affichage. Il est désérialisé dans une classe qui étend la classe Fragment et non plus Activity. Cependant, même si les fragments peuvent redéfinir la méthode public void oncreate (Bundle savedinstancestate), y appeler la méthode setcontent- View(int resource) ne fonctionnera pas pour la désérialisation. Il est possible de redéfinir la méthode suivante dans son cycle de vie, public View oncreate- View (LayoutInflater inflater, ViewGroup container, Bundle savedinstancestate). Elle donne accès en premier paramètre à un «inflater» qui permet la désérialisation du fichier XML d affichage. La bibliothèque de compatibilité a été présentée. Son utilisation sera constante dans les exemples illustrant le tutoriel. Il existe une chose importante à savoir sur son utilisation : l environnement de travail, peu importe lequel, proposera d importer deux paquetages pour avoir accès à Fragment et aux autres classes présentées dans ce tutoriel. Pour les fragments, il proposera android.app.fragment et android.support.v4.app.fragment. Toutes les classes figurant dans les paquetages android.support.v4 possèdent un équivalent limité à une certaine API (à partir de la version 3.x d Android jusqu aux versions récentes). Quant à la bibliothèque de compatibilité, elle apporte une compatibilité à partir de la version 2.x. L utilisation des classes de cette bibliothèque diffère peu de l originale mais il y a certaines subtilités à connaître. Le tutoriel enseignera son utilisation plutôt que les originaux pour deux raisons : Il est plus simple de passer de l utilisation de la librairie de compatibilité vers les originaux que l inverse ; Les originaux restreignent la portée de l application finale au minimum à la version 3.x d Android, voire plus comme les notifications avancées qui ne sont compatibles qu à partir de la version 4.1. [[attention]] Les raisons pour utiliser la bibliothèque de compatibilité sont intéressantes mais il y a une chose essentielle à savoir : il n est pas possible de mélanger les originaux avec les classes 10

11 2.1 Fragment du support. C est une erreur commune chez les développeurs. Google a tenté de rendre l utilisation de la bibliothèque la plus proche de son utilisation normale. Mise à part quelques méthodes et des noms de classes, l utilisation sera identique. Cela peut paraître pratique mais une erreur est vite arrivée. Un fragment simple serait d afficher simplement du texte. Le but de cet exemple n est pas de confectionner un fragment complexe (ce loisir sera donné plus tard). L idée est de placer un Text- View au centre de l écran via un fichier XML d affichage. Il sera désérialisé dans un fragment qui sera lui même contenu dans une activité. Voici le fichier XML d affichage fragment_fixe : <?xml version="1.0" encoding="utf-8"?> <RelativeLayout xmlns:android=" android:layout_width="match_parent" android:layout_height="match_parent" > <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_centerhorizontal="true" android:layout_centervertical="true" android:text="@string/title_fragment_fixe" /> </RelativeLayout> Pour ce premier exemple, le fragment associé est extrêmement simple. En temps normal, un fragment joue le contrôleur complet de la portion d interface qu il contient afin d alléger l activité hôte et d architecturer convenablement le projet. Ainsi, le fragment FixeFragment ressemble à ceci : package com.siteduzero.android.fragments.fixe; import android.os.bundle; import android.support.v4.app.fragment; import android.view.layoutinflater; import android.view.view; import android.view.viewgroup; import com.siteduzero.android.r; public class FixeFragment extends Fragment public View oncreateview(layoutinflater inflater, ViewGroup container, Bundle savedinstancestate) { return inflater.inflate(r.layout.fragment_fixe, container, false); [[information]] Remarquez que les importations sont délibérément affichées afin de montrer que la bibliothèque de compatibilité est bien utilisée à la place des originaux. Cela sera une habitude prise dans ce tutoriel pour que vous ne soyez jamais perdus. 11

12 2 Fragmenter vos projets La création et l utilisation d un fragment est aussi simple qu une activité. Il faut maintenant attacher ce fragment à une activité. Il n y a aucun changement de ce côté là puisqu un fragment peut être déclaré dans un fichier XML d affichage comme n importe quelle vue. Il sera chargé dans une activité à l exécution de l application et ne changera plus. Dans ce cas, il sera fixé à l activité hôte. Ses attributs sont les mêmes qu une vue normale mais, en plus, il faut rajouter le chemin d accès vers le fragment. Pour attacher notre fragment FixeFragment, il faut le déclarer ainsi : <?xml version="1.0" encoding="utf-8"?> <fragment xmlns:android=" android:id="@+id/fragment_fixe" android:name="com.siteduzero.android.fragments.fixe.fixefragment" android:layout_width="match_parent" android:layout_height="match_parent" /> Du côté de l activité, il y a une petite chose à savoir. Il n est pas possible d étendre la classe Activity si la bibliothèque de compatibilité est utilisée. Une autre classe est présente dans le support, FragmentActivity. Cette classe est l équivalente à la classe originale, Activity. Mais elle ne doit pas être utilisée si les originaux sont utilisés. package com.siteduzero.android.fragments.fixe; import com.siteduzero.android.r; import android.os.bundle; import android.support.v4.app.fragmentactivity; public class FixeActivity extends FragmentActivity protected void oncreate(bundle arg0) { super.oncreate(arg0); setcontentview(r.layout.activity_fragment_fixe); Tout comme le fragment, l activité est vide puisque le fragment est fixe et que toute l interface y a été déportée. C est l une des forces de l utilisation des fragments. Habituellement, les activités jouent le rôle des contrôleurs dans une architecture MVC (patron architectural sur lequel Android se base dans le développement d applications) mais cette partie contrôleur a été allégée pour ne plus avoir des activités énormes et pour devenir les contrôleurs des fragments plutôt que directement des interfaces. Cela permet de maintenir plus aisément le code et de séparer les responsabilités des différentes classes Réarranger les fragments en paysage Attacher un fragment de manière fixe à une activité n empêche pas d en attacher plusieurs, qu ils soient identiques ou non. Il suffit de spécifier plusieurs fragments dans le fichier XML d affichage de l activité pour voir apparaître les fragments. Une possibilité pour l illustrer est le mode paysage. Une application n est pas toujours destinée à s afficher en portrait (sauf en cas de contre indication dans le fichier Manifest) ni même toujours sur un smartphone. C est pourquoi, en mode 12

13 2.1 Fragment 13

14 2 Fragmenter vos projets paysage, il faut repenser les interfaces pour garder une expérience utilisateur optimale. Dans un dossier res/layout-land, il faut créer un nouveau fichier XML d affichage du même nom que celui dans le dossier res/layout de l activité cible, FixeActivity dans l exemple ci-présent. Tout comme n importe quelle vue, les fragments peuvent être placés dans un conteneur comme le LinearLayout afin de donner un poids équitable entre les fragments. <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android=" android:layout_width="match_parent" android:layout_height="match_parent" android:baselinealigned="false" android:orientation="horizontal" > <fragment android:id="@+id/fragment1" android:name="com.siteduzero.android.fragments.fixe.fixefragment" android:layout_width="match_parent" android:layout_height="match_parent" android:layout_weight="1" /> <fragment android:id="@+id/fragment2" android:name="com.siteduzero.android.fragments.fixe.fixefragment" android:layout_width="match_parent" android:layout_height="match_parent" android:layout_weight="1" /> </LinearLayout> Utiliser des fragments dynamiques Les fragments fixes sont simples à implémenter. A partir du moment où le fragment est codé, il suffit de l indiquer dans des fichiers XML d affichage à désérialiser dans une activité sans rien indiquer en plus. Se limiter à ce type de fragment ne permettrait pas de satisfaire ses promesses de flexibilité et de maintenance. Dans cet ordre idée, le framework Android fournit une API pour gérer les fragments pendant l exécution d une application. Ainsi, il est possible de remplacer un fragment par un autre aisément et, par la même occasion, afficher une nouvelle portion d interface Gérer ses fragments Le framework Android met à disposition des développeurs une API indispensable pour gérer les fragments, FragmentManager. Cette API offre plusieurs services. La documentation donne toutes les informations à ce sujet. Dans l immédiat, le plus intéressant est le service qui permet de gérer des transactions via une autre API, FragmentTransaction. Les transactions permettent d opérer sur les fragments de manière groupée. Les opérations sont classiques. Il 14

15 2.1 Fragment Figure 2.3 Résultat de l exécution de l activité FixeActivity en paysage est possible d ajouter, remplacer, supprimer, etc. des fragments. Elles ne seront pas toutes expliquées dans ce tutoriel. L utilisation de ces APIs est assez simple mais il faut garder à l esprit que la bibliothèque de compatibilité est utilisée dans les exemples. La documentation donnée renseigne les méthodes des classes originales du framework. Même si les signatures des méthodes sont globalement les mêmes pour chacune d elles, il arrive que quelques unes changent. Notamment avec l ajout du mot clé «Support». Par exemple, pour récupérer un FragmentManager, la méthode utilisée sera public FragmentManager getsupportfragmentmanager() plutôt que public FragmentManager getfragmentmanager(). [[attention]] Il faut rappeler que les fragments qui viennent du paquetage android.app.fragment ne peuvent pas être utilisés avec les classes de la bibliothèque de compatibilité (et inversement). Dans les exemples de ce tutoriel, Fragment et FragmentManager viennent tous les deux du projet de compatibilité. Dans le cas contraire, l application provoquera instantanément une erreur forcée Le contrôleur des fragments Jusqu à présent, le contrôleur des interfaces était les activités. Elles se chargeaient de désérialiser les fichiers XML et de récupérer les composants graphiques pour y ajouter un comportement et des évènements. Dorénavant, les fragments jouent ce rôle et les activités deviennent les contrôleurs des fragments. A savoir, les contrôleurs des contrôleurs. Il est essentiel de comprendre que les fragments ne sont pas vraiment des nouveautés dans leur rôle. Il y a qu une déportation du code d un concept à un autre. Le réel changement se situe dans les activités puisqu ils doivent gérer les fragments. Son changement de rôle est la réelle nouveauté. 15

16 2 Fragmenter vos projets Les fragments fixes n illustrent pas clairement ce principe. Même si le framework se charge d utiliser l API de gestion des fragments, il n est pas visuel pour le développeur. Pour l illustrer, deux fragments simples ont été confectionnés. Ils contiennent un TextView pour afficher le nom du fragment courant et un Button pour remplacer le fragment courant par le suivant. Ils ne sont pas compliqués à développer. Leurs réalisations sont disponibles sur le projet GitHub de ce tutoriel. Ils sont nommés Dynamic1Fragment et Dynamic2Fragment. Quant à l activité, elle a été nommée DynamicActivity. Plusieurs choses sont à savoir sur sa réalisation. Première chose, son fichier XML d affichage ne comportera aucun fragment mais un Frame- Layout avec un identifiant pour pouvoir le récupérer dans l activité et remplacer son contenu par celui d un fragment. Pour rappel, ce conteneur permet de superposer des vues à un même endroit sur l écran. Son utilisation sera plus claire par la suite. Seconde chose, pour des soucis de structuration et d apprentissage, une certaine architecture simpliste sera mise en place. Dans la méthode public void oncreate(bundle savedinstancestate), une méthode sera appelée : private void showfragment(final Fragment fragment). Elle affiche le fragment donné en paramètre. Elle sera appelée dans la méthode on- Create(...) et lorsque l utilisateur cliquera sur le bouton du fragment Initialisation des fragments L initialisation des fragments se fait par simple instanciation d un objet d un fragment confectionné précédemment. Par exemple, pour le premier fragment dynamique, il faudra procéder de la manière suivante : Dynamic1Fragment dynamic1fragment = new Dynamic1Fragment();. Cependant, comme il n existe pas de petites économies, une optimisation possible serait d instancier les deux fragments comme attribut de l activité. // We instantiate just one time fragments during the life of the activity. private final Dynamic1Fragment mdynamic1fragment = new Dynamic1Fragment(); private final Dynamic2Fragment mdynamic2fragment = new Dynamic2Fragment(); [[information]] Cette économie convient pour notre exemple mais nous verrons que cela changera bien vite lorsque l application deviendra plus complexe Remplacer les fragments Afficher le fragment à l écran est la réelle nouveauté dans le développement de fragments dynamiques. L idée est de remplacer le contenu du conteneur, FrameLayout, par un fragment donné. Pour ce faire, il est nécessaire d utiliser l API des transactions des fragments, FragmentTransaction. Sa documentation indique toutes méthodes utiles. Plusieurs sont utilisées dans showfragment(final Fragment fragment) : public abstract FragmentTransaction setcustomanimations (int enter, int exit) : Anime la transition d un fragment à un autre en donnant l animation d entrée pour le nouveau fragment et l animation de sortie pour l ancien ; public abstract FragmentTransaction replace (int containerviewid, Fragment fragment) : Remplace le contenu d un conteneur, donné en premier paramètre, par un nouveau fragment ; 16

17 2.1 Fragment public abstract FragmentTransaction addtobackstack (String name) : Indique une valeur null pour retourner au précédent fragment lorsque l utilisateur cliquera sur le bouton «Back». Au final, la méthode s implémentera de la façon suivante : private void showfragment(final Fragment fragment) { if (fragment == null) { return ; // Begin a fragment transaction. final FragmentManager fm = getsupportfragmentmanager(); final FragmentTransaction ft = fm.begintransaction(); // We can also animate the changing of fragment. ft.setcustomanimations(android.r.anim.slide_in_left, android.r.anim.slide_out_right // Replace current fragment by the new one. ft.replace(r.id.framelayoutlistview, fragment); // Null on the back stack to return on the previous fragment when user // press on back button. ft.addtobackstack(null); // Commit changes. ft.commit(); [[attention]] Chaque transaction doit appeler la méthode commit() pour voir ses opérations s effectuer. En cas contraire, aucune erreur ne sera lancée mais rien ne se passera Retenir sa position dans les fragments Une astuce intéressante est de garder en mémoire le fragment affiché à l écran après une reconstruction de l activité. Il faut toujours privilégier l expérience utilisateur. Se souvenir de lui et de ses manipulations est un bon début dans cette idée. C est pourquoi, un nouvel attribut va figurer dans la classe pour retenir le fragment courant. Il suffira alors de le sauvegarder via la méthode public void onsaveinstancestate(bundle outstate). Le changement se fera dans la méthode oncreate(...) de l activité puisqu il faut afficher le fragment courant s il existe en mémoire. La méthode sera complétée de la façon suivante : if (savedinstancestate!= null) { mfragment = savedinstancestate.getstring(key_fragment); else { mfragment = getintent().getstringextra(key_fragment); if (mfragment!= null) { if (mfragment.equals(mdynamic1fragment.getclass().getsimplename())) { showfragment(this.mdynamic1fragment); else if (mfragment.equals(mdynamic2fragment.getclass().getsimplename())) { 17

18 2 Fragmenter vos projets showfragment(this.mdynamic2fragment); else { showfragment(this.mdynamic1fragment); [[attention]] Il faut remarquer qu une touche de réfléxivité est utilisée dans l exemple ci-dessus. mdynamic1fragment.getclass().getsimplename() renvoie le nom de la classe, à savoir Dynamic1Fragment. Il faut donc sauvegarder dans mfragment une valeur similaire qui se fera dans la méthode private void showfragment(final Fragment fragment) de la même manière avec la variable fragment. Ainsi, le fragment courant est sauvegardé Résultat final Avant de montrer le résultat final, il reste une problématique a résoudre : comment capturer l évènement des boutons des fragments dans l activité hôte? En effet, les fragments n ont pas accès à FragmentManager, ou plutôt, ce n est pas leur rôle de contrôler les autres fragments. En tant normal, il faut utiliser les listeners mais cette pratique sera expliquée plus tard. La technique utilisée est plus simple pour un premier aperçu des fragments dynamiques. Il faut utiliser un nouveau attribut dans les fichiers XML d affichage des fragments sur les éléments Button : android:onclick. Cet attribut permet de définir une méthode Java qui sera appelée automatiquement lorsque l utilisateur cliquera dessus. Il n y a que deux restrictions : La signature de la méthode doit être public, renvoyer void et avoir un seul paramètre du type View ; Elle doit être déclarée dans une activité. Les méthodes ressembleront à ceci pour des attributs avec les valeurs gotofragment2 et goto- Fragment1 : public void gotofragment1(view v) { showfragment(this.mdynamic1fragment); public void gotofragment2(view v) { showfragment(this.mdynamic2fragment); L exécution de l application permet d afficher un premier fragment avec un TextView qui ne change pas et un bouton qui propose à l utilisateur d afficher le second écran. Lorsqu il cliquera dessus, une animation sera exécutée vers le nouveau fragment. Lorsqu il cliquera sur le bouton «Back», il reviendra au précédent fragment. Le résultat est le suivant : Attacher un bundle Les fragments deviennent les contrôleurs des interfaces qu ils désérialisent et ils sont indépendants les uns des autres. C est la force de ce nouveau concept mais il peut arriver, suivant les situations, qu à l initialisation d un fragment, des données soient nécessaires. Un exemple simple 18

19 2.1 Fragment 19

20 2 Fragmenter vos projets serait de donner l identifiant d un article. Sur base de cette donnée, le fragment peut récupérer toutes les informations de l article en question soit par un service web ou dans la base de données interne de l application. Les bundles ne sont pas utilisés qu avec les activités. Les fragments aussi peuvent les utiliser. Seulement, il n est pas question d Intent avec les fragments puisqu ils sont gérés par une autre API. La méthode avec les fragments est légèrement moins bien pensée que celle avec les activités. Il faut instancier un fragment, un bundle en plaçant les informations dedans et l attacher au fragment avec la méthode public void setarguments (Bundle args). MyFragment fragment = new MyFragment(); Bundle args = new Bundle(); args.putint(key_id, id); fragment.setarguments(args); Cette simple solution suffirait mais elle rencontre un problème : si l instanciation d un même fragment avec un bundle se fait plusieurs fois dans l application, il faut faire une répétition du code assez conséquente et la maintenir en cas de modification. Pour palier à cette répétition qui alourdie considérablement le code, une bonne pratique est de créer une méthode statique dans le fragment en question. Cela permet d encapsuler toutes les informations dans le fragment et de ne pas tout éparpiller dans le code. Cette méthode ressemblera à : public static MyFragment newinstance( /* informations que je veux donner à mon fragment */) { // renvoie une instance de mon fragment [[information]] Pour rappel, static signifie que la méthode n est pas directement attachée aux instances créé de la classe hôte. Par exemple, il est possible de créer des instances de la classe hôte dans cette méthode. En reprenant l exemple de l identifiant à passer au fragment pour afficher le contenu de l article sélectionné, il suffit de passer cet entier en paramètre, de reprendre le code précédemment donné et de renvoyer le fragment. Ainsi, dans le code de l application, il suffira d appeler la méthode MyFragment.newInstance(idArticle); pour automatiquement créer un fragment avec le bundle attaché et de modifier le code à un seul endroit en cas de changements. Pour récupérer les informations contenues dans le bundle du fragment, rien de plus simple. Les arguments sont accessibles par sa méthode d accès public final Bundle getarguments () qui renvoie le bundle précédemment attaché au fragment et d en récupérer les données grâce aux identifiants donnés à chacune En résumé Un fragment est une portion d interface qui peut être attaché à plusieurs activités différentes. Il possède son propre cycle de vie mais il est étroitement lié à son activité hôte. La bibliothèque de compatibilité Google permet de rendre les applications compatibles à partir des terminaux sur Android 2.1 et supérieur. 20

21 2.2 ListFragment Les fragments fixes sont attachés directement dans le fichier XML d affichage de l activité. Les fragments dynamiques sont attachés pendant l exécution de l application via une API, FragmentManager. 2.2 ListFragment Les listes sont, sans aucun doute, les composants graphiques les plus utilisés dans les applications mobiles, qu elles soient sur Android, ios ou autres. Elles permettent d afficher facilement des informations les unes à la suite des autres verticalement avec des vues personnalisées ou non pour chaque ligne. Plusieurs choses seront abordées dans ce chapitre : comment intégrer une liste mêlée à la puissance des fragments, personnaliser ses vues et la rendre dynamique en indiquant des vues spécifiques pour chaque ligne qui compose une liste Utilisation simple des listes Il existes deux possibilités pour intégrer une liste dans une application : la renseigner dans un fichier XML d affichage ou étendre la classe ListActivity. L équivalent avec les fragments est similaire à celle des activités à l exception près qu il faut tenir compte qu une liste ne peut pas être initialisée sans un contexte et qu elle n est créée qu une fois l activité hôte du fragment créée Déclarer sa liste dans des fichiers XML Une petite astuce méconnue consiste à coupler un fichier XML d affichage avec une classe qui étend ListFragment pour indiquer une vue à afficher si aucune ligne n est contenue dans la liste. Cet exemple illustrera les deux possibilités décrites précédemment. Sa mise en place est assez simple. Elle nécessite simplement l utilisation d identifiants déclarés dans le framework Android. Parmi tous les identifiants disponibles seulement list et empty sont nécessaires pour les listes. Dans le fichier XML d affichage destiné au ListFragment, il va falloir déclarer une ListView avec l et, dans le même fichier XML, au même niveau que la ListView, une autre vue dont l élément racine possèdera un Ainsi, lors de la désérialisation, le framework Android saura ce qu il devra charger lorsqu il y a des éléments dans la liste ou non. Dans un exemple où un simple texte est affiché au centre de l écran s il n y a aucun élément dans la liste, le fichier XML ressemblerait à : <?xml version="1.0" encoding="utf-8"?> <RelativeLayout xmlns:android=" android:layout_width="match_parent" android:layout_height="match_parent" > <ListView android:id="@android:id/list" android:layout_width="match_parent" android:layout_height="wrap_content" 21

22 2 Fragmenter vos projets android:layout_alignparentleft="true" android:layout_alignparenttop="true" /> <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_centerhorizontal="true" android:layout_centervertical="true" /> </RelativeLayout> Création du ListFragment Le fragment ne sera plus aussi générique que celui du chapitre précédent. Afin de profiter de la création automatique d une ListView pour le fragment, la classe étendra ListFragment, parfait équivalent de la classe ListActivity. De la même manière que les fragments basiques, un ficher XML d affichage sera désérialisé dans sa méthode public View oncreate- View(LayoutInflater inflater, ViewGroup container, Bundle savedinstancestate) (chose qui n est pas obligatoire si aucune vue ne doit être affichée s il n y a aucun élément dans la liste). Comme avec une ListActivity, un adaptateur doit être attaché à la liste (adaptateur qui ne sera pas personnalisé pour le moment). L unique subtilité dans ce cas présent est la méthode à redéfinir. En effet, comme il faut un contexte pour initialiser un adaptateur, il faudra le créer, l initialiser et l attacher uniquement lorsque l activité hôte sera créée. Cela se fera dans la méthode public void onactivitycreated(bundle savedinstancestate). Ceci donne le code et le résultat suivant : package com.siteduzero.android.lists.simple; import com.siteduzero.android.r; import android.os.bundle; import android.support.v4.app.listfragment; import android.view.layoutinflater; import android.view.view; import android.view.viewgroup; import android.widget.arrayadapter; public class SimpleListViewFragment extends ListFragment public View oncreateview(layoutinflater inflater, ViewGroup container, Bundle savedinstancestate) { return inflater.inflate(r.layout.fragment_listview, container, false); 22

23 2.2 public void onactivitycreated(bundle savedinstancestate) { super.onactivitycreated(savedinstancestate); final String[] items = getresources().getstringarray(r.array.list_examples); final ArrayAdapter<String> aa = new ArrayAdapter<String>(getActivity(), android.r.layout.simple_list_item_1, items); setlistadapter(aa); Intégrer une vue personnalisée La confection de vues personnalisées dans un ListFragment ne diffère pas de son équivalent avec une ListActivity. Cette personnalisation est complètement indépendante de son hôte. Par conséquent, certains aspects seront moins expliqués que d autres mais une piqûre de rappelle sera donnée, notamment sur l architecture à adoptée Créer une vue personnalisée Il faut créer plusieurs fichiers pour confectionner sa vue : son fichier XML d affichage et la classe qui le désérialise. Dans cet exemple, chaque ligne de la liste affichera un texte contenu dans un bloc avec un ombrage. Normalement, les ombrages dans le développement Android sont possibles uniquement grâce à la technologie 9-patch. Elle permet d étendre horizontalement ou verticalement certaines images sans les pixeliser. Cependant, le framework Android met à disposition des développeurs une série de ressources dont des ombrages. Le fichier XML d affichage pourra utiliser ces ressources pour afficher l ombrage et ressemblera alors à : <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android=" android:layout_width="match_parent" android:layout_height="wrap_content" android:background="@android:drawable/dialog_holo_light_frame" android:orientation="vertical" > <TextView android:id="@+id/textview" android:layout_width="wrap_content" android:layout_height="wrap_content" android:padding="15dp" android:text="@string/default_lorem" /> </LinearLayout> Quant à la classe qui désérialise ce fichier XML, il doit étendre un conteneur, LinearLayout, redéfinir ses constructeurs et initialiser le texte avec la valeur souhaitée. Ce dernier point est possible 23

24 2 Fragmenter vos projets 24

25 2.2 ListFragment grâce à une méthode publique qui prend en paramètre l identifiant d une chaîne de caractères présente dans les ressources du projet. package com.siteduzero.android.lists.custom; import com.siteduzero.android.r; import android.content.context; import android.util.attributeset; import android.widget.linearlayout; import android.widget.textview; public class CustomListViewView extends LinearLayout { private TextView mtextview; public CustomListViewView(Context context, AttributeSet attrs, int defstyle) { super(context, attrs, defstyle); init(); public CustomListViewView(Context context, AttributeSet attrs) { super(context, attrs); init(); public CustomListViewView(Context context) { super(context); init(); private void init() { inflate(getcontext(), R.layout.view_custom_listview, this); mtextview = (TextView) findviewbyid(r.id.textview); public void bind(int text) { mtextview.settext(getresources().getstring(text)); Créer son adaptateur La création d un adaptateur prend tout son sens à partir du moment où une ListView est constituée de vues personnalisées. Un adaptateur doit étendre la classe BaseAdapter, redéfinir les méthodes obligatoires (il existe des méthodes facultatives pour des listes dynamiques, cela fera l objet du prochain point de ce chapitre) et permettre de rajouter les données à injecter dans la liste. Ces données peuvent être aussi simples que complexes. Il en revient au développeur d injecter l «intelligence» nécessaire dans son adaptateur. 25

26 2 Fragmenter vos projets La chose à savoir dans la création d un adaptateur est la façon d implémenter la méthode public View getview(int position, View convertview, ViewGroup parent). Dans les applications mobiles, il est nécessaire d économiser la moindre zone mémoire possible. Ainsi, lorsque l utilisateur parcourt une liste, si la vue d une ligne est encore en zone mémoire, il est préférable de la réutiliser plutôt que d en créer une nouvelle. Raison pour laquelle cette méthode renvoie une vue en second paramètre. L adaptateur s implémente donc de la manière suivante : package com.siteduzero.android.lists.custom; import java.util.arraylist; import java.util.list; import android.content.context; import android.view.view; import android.view.viewgroup; import android.widget.baseadapter; public class CustomListViewAdapter extends BaseAdapter { private List<Integer> mmodel = new ArrayList<Integer>(); private Context mcontext; public CustomListViewAdapter(Context context) { mcontext = public int getcount() { return public Integer getitem(int position) { return public long getitemid(int position) { return public View getview(int position, View convertview, ViewGroup parent) { CustomListViewView v = null ; // Notre vue n'a pas encore été construite, nous le faisons if (convertview == null) { v = new CustomListViewView(mContext); // Notre vue peut être récupérée, nous le faisons 26

27 2.2 ListFragment else { v = (CustomListViewView) convertview; v.bind(getitem(position)); return v; public void bind(list<integer> model) { mmodel = model; Puisque l objectif est d utiliser les fragments, le fragment hôte s occupera d envoyer les données via la méthode public void bind(list<integer> model) de l adaptateur après son initialisation. L utilisation d un adaptateur personnalisé est toute aussi simple qu un des adaptateurs donnés à la disposition des développeurs par défaut dans le framework. Le résultat correspond à la capture suivante : Vers des listes dynamiques Une liste dynamique réside dans les différentes vues possibles à appliquer pour ses lignes. A la place de s arranger avec une ScrollView et d ajouter des vues dynamiquement à ce conteneur grâce à d autres conteneurs, le framework Android fournit une solution élégante juste en redéfinissant deux autres méthodes dans un adaptateur personnalisé Nouvelles méthodes de l adaptateur L exemple qui illustrera cette liste dynamique consistera à afficher un «header» avec une image à gauche et du texte à droite. Une seconde vue sera un «body» avec simplement du texte (comme la vue du point précédent de ce chapitre). La création de ces vues ne sera pas abordée dans la suite de ce chapitre vu sa simplicité. Concernant l adaptateur, pour indiquer qu il va devoir gérer plusieurs vues différentes dans sa liste, deux méthodes, liées au type de la vue courante à instancier, doivent être redéfinies : public int getviewtypecount() : Indique combien de vues différentes comportent la liste ; public int getitemviewtype(int position) : Indique le type de la vue à instancier pour la ligne courante. Pour implémenter ces méthodes, il faudra plusieurs constantes et une liste représentant les types. Cette manière de faire est la plus simple et pas du tout obligatoire. Il en revient au développeur de l adapter pour son propre problème. L adaptateur dynamique pourrait ressembler au code cité ci-présent : public class DynamicListViewAdapter extends BaseAdapter { private static final int TYPE_HEADER = 0 ; private static final int TYPE_BODY = 1 ; private static final int TYPE_MAX = 2 ; private List<Integer> mtypes = new ArrayList<Integer>(); 27

28 2 Fragmenter vos projets 28

29 2.2 ListFragment // Autres public int getviewtypecount() { return public int getitemviewtype(int position) { return mtypes.get(position); // Autres méthodes La mise en place est aussi simple que cela. Il faut aussi permettre de remplir la liste des types en les faisant correspondre avec les données. Comme le point précédent sur les listes personnalisées, il faut définir des méthodes pour attacher une liste de données à celle de l adaptateur et s occuper de la liste des types par la même occasion. Il en faudra deux : L une pour l en-tête et une seconde pour le corps de la liste. La première méthode prend en paramètre un modèle qui se trouve être une classe confectionnée spécialement pour cet exemple avec seulement deux attributs représentant une image et un texte ; La seconde est identique à la méthode du point précédent, elle prendra une liste d identifiants de chaînes de caractères. L implémentation de ces méthodes pourraient ressembler à : public class DynamicListViewAdapter extends BaseAdapter { // Autres attributs et méthodes public void bindheader(dynamiclistviewmodel model) { mmodelheader = model; mtypes.add(type_header); public void bindbody(list<integer> model) { mmodelbody = model; for (int i = 0 ; i < model.size(); i++) { mtypes.add(type_body); Modification de l existant Ces ajouts ont des répercussions sur l implémentation des méthodes existantes. Le nombre de lignes et la ligne courante de la liste ne correspondent plus à une seule liste de données. Tout 29

30 2 Fragmenter vos projets comme la méthode d instanciation de la vue courante qui doit se charger d instancier la bonne vue. Les deux premières méthodes s implémentent assez facilement pour cet exemple : public class DynamicListViewAdapter extends BaseAdapter { // Autres attributs et public int getcount() { if (mmodelheader == null) return mmodelbody.size(); return 1 + public Object getitem(int position) { int type = getitemviewtype(position); return type == TYPE_HEADER? mmodelheader : mmodelbody.get(position - 1); // Autres méthodes La méthode public View getview(int position, View convertview, ViewGroup parent) est un poil plus complexe mais, au final, ne fait qu utiliser les autres méthodes de l adaptateur. Il faut récupérer le type de la ligne courante au début de la méthode pour pouvoir instancier la vue adéquate. Son implémentation est très similaire à la précédente, mise à part qu elle effectue une série de condition en fonction de ce public View getview(int position, View convertview, ViewGroup parent) { View v = null ; int type = getitemviewtype(position); if (convertview == null) { switch (type) { case TYPE_HEADER: v = new DynamicHeaderListViewView(mContext); break ; case TYPE_BODY: v = new DynamicBodyListViewView(mContext); break ; else { switch (type) { case TYPE_HEADER: v = (DynamicHeaderListViewView) convertview; break ; case TYPE_BODY: v = (DynamicBodyListViewView) convertview; 30

31 2.3 Interfaces dynamiques break ; switch (type) { case TYPE_HEADER: DynamicListViewModel model1 = (DynamicListViewModel) getitem(position); ((DynamicHeaderListViewView) v).bind(model1.getimageressource(), model1.gettextressource()); break ; case TYPE_BODY: Integer model2 = (Integer) getitem(position); ((DynamicBodyListViewView) v).bind(model2); break ; return v; Il n en faut pas plus pour concevoir une liste dynamique. Tous les changements se situent au niveau de l adaptateur. Il suffit alors d intégrer ce nouvel adaptateur à l activité ou le fragment hôte en n oubliant pas d appeler les méthodes pour lier les données à la liste. Le résultat de l exemple ressemble à ceci : En résumé ListFragment est une sous classe de Fragment qui contient automatiquement une ListView ; Il est possible d afficher une vue à l écran lorsqu il n y a aucun élément dans la liste. Cela grâce à un fichier XML d affichage attaché à une ListFragment ; Il est nécessaire de développer son propre adaptateur lorsque les vues, qui composent une liste, deviennent complexes ; Une liste dynamique oblige la redéfinition de deux méthodes supplémentaires dans son adaptateur : public int getviewtypecount() et public int getitemview- Type(int position). 2.3 Interfaces dynamiques La création des fragments est maintenant chose connue mais, jusqu à présent, ils ont été assimilés à l écran complet d un smartphone. Le promesse derrière ce concept est toute autre puisque son but est de dynamiser les interfaces à travers les différents appareils (qu ils soient smartphones, tablettes, télévisions ou autres). De brefs aperçus sur les possibilités, ont été donnés mais ni les bonnes pratiques ni la communication entre les fragments n ont été expliquées. 31

32 2 Fragmenter vos projets 32

33 2.3 Interfaces dynamiques Concevoir une interface dynamique Concevoir une interface n est pas une chose aisée, surtout sur Android. Au vu de la diversité des écrans sur tous les types d appareils mobiles, il faut avant tout penser ses interfaces avant de les développer. Par exemple, un smartphone se contentera d afficher un fragment à la fois (qu il soit en paysage ou en portrait) alors qu une tablette pourrait afficher deux fragments en portrait et trois en paysage (encore faut-il savoir s il s agit d une tablette 7 ou 10 pouces). C est encore une autre histoire avec les télévisions mais le problème reste le même. En s imposant une limite aux smartphones et aux tablettes, peu importe leurs tailles, une pratique d ergonomie reconnue consiste a afficher un fragment sur smartphone et deux sur tablette en mode paysage. Cela permet de naviguer convenablement sur smartphone (comme toutes les applications) et de remplir complètement l écran d une tablette forcément plus grande. Figure 2.8 Deux fragments affichés dans différentes configurations L objectif est d ajouter un fragment à une activité pendant son exécution, dans les deux cas. Pour les smartphones, il faut changer le fragment visible à l écran. Pour les tablettes, charger les données nécessaires si une communication est à faire entre le fragment A et le fragment B. Par exemple, le fragment A pourrait être une liste de pays et le fragment B pourrait vouloir afficher son drapeau. Les deux fragments doivent communiquer et rester affichés à l écran. [[information]] Pour simplifier d avantage, l exemple d illustration ne fera aucune distinction entre les appareils. Les interfaces seront pensées en mode portrait et paysage à la place des tailles minimales. La manière de procéder est simple et requiert l utilisation de l API de gestion des fragments. Couplé à cela, la création des deux «layouts» du même nom pour déclarer l interface en mode portrait et paysage. Le but est d obtenir le résultat de l illustration précédente sans tenir compte du type d appareil Initialiser l activité hôte Pour illustrer la communication entre des fragments, il va falloir réviser quelques drapeaux européens. L idée est d afficher une liste de pays et son drapeau correspondant. Le projet nécessitera deux fragments : Un premier pour la liste des pays, un second pour le drapeau du pays sélectionné par l utilisateur. Le mode portrait affichera les fragments en plein écran en les remplaçant à la 33

34 2 Fragmenter vos projets demande de l utilisateur alors que le mode paysage affichera la liste et le drapeau l un à côté de l autre. Dans ce dernier cas, la communication prendra un sens tout autre puisque la modification devra se faire directement sans charger un nouveau fragment. [[attention]] La confection des fragments ne seront pas abordées. En cas de doute, revenez aux explications précédentes dans Fragment ou ListFragment. Intégrer les deux fragments dans une activité hôte n est pas plus difficile que l utilisation des fragments dynamiques. Pour le mode paysage, il faut renseigner les deux fragments directement dans le fichier XML d affichage du dossier des layouts correspondant, à savoir «layout-land». Dans un souci de visibilité et d ergonomie, il est préférable de privilégier le contenu à la liste. Dans cet exemple, il s agit d un drapeau mais cela aurait pu être un courrier, un site web, etc. Le fichier XML ressemblera à ceci : <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android=" android:layout_width="match_parent" android:layout_height="match_parent" android:baselinealigned="false" android:orientation="horizontal" > <fragment android:id="@+id/fragmentlist" android:name="com.siteduzero.android.dynamicui.countrylistfragment" android:layout_width="match_parent" android:layout_height="match_parent" android:layout_weight="2" /> <fragment android:id="@+id/fragmentdetails" android:name="com.siteduzero.android.dynamicui.countrydetailsfragment" android:layout_width="match_parent" android:layout_height="match_parent" android:layout_weight="1" /> </LinearLayout> Quant au mode portrait, il est légèrement plus complexe puisqu il faut rendre dynamique le fragment à afficher à l écran. Dans le fichier XML d affichage du dossier layout par défaut, il suffit de déclarer un simple conteneur FrameLayout avec un identifiant afin de pouvoir l utiliser avec les APIs de gestion des fragments. <?xml version="1.0" encoding="utf-8"?> <FrameLayout xmlns:android=" android:id="@+id/framelayoutdynamicui" android:layout_width="match_parent" android:layout_height="match_parent" /> Pour finir, dans la méthode public void oncreate(bundle savedinstancestate) de l activité, il faut rajouter le fragment contenant la liste, CountryListFragment, dans le Frame- Layout. Dans le cas contraire, les fragments s afficheront correctement en mode paysage mais 34

35 2.3 Interfaces dynamiques ils ne s afficheront pas en mode portrait. Pour y parvenir, il faut récupérer une instance d une transaction, FragmentTransaction, via le manager, FragmentManager, et utiliser la méthode public FragmentTransaction add(int containerviewid, Fragment fragment) en lui passant une instance du public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.activity_dynamic_ui); if (findviewbyid(r.id.framelayoutdynamicui)!= null) { final CountryListFragment listfragment = new CountryListFragment(); getsupportfragmentmanager().begintransaction().add(r.id.framelayoutdynamicui, listfragment).commit(); Communication entre les fragments Au ce stade, l application s exécute correctement et affiche une liste en mode portrait et les deux fragments avec une liste à gauche et un drapeau à droite mais avec aucune interaction dans les deux cas en mode paysage. Pour remédier à ce problème, il faut utiliser des listeners pour permettre une communication entre un fragment A et un fragment B en passant par une activité hôte. En effet, l activité va devoir gérer les messages entre les fragments qu elle contient. Dans le fragment CountryListFragment, il faut déclarer une interface, OnCountrySelected- Listener, et un attribut du même type. Cette interface sera implémentée par l activité afin de pouvoir transmettre le message du fragment contenant la liste vers celui contenant le drapeau pour savoir lequel il faut afficher à l écran. Pour initialiser l attribut, les fragments peuvent redéfinir la méthode public void onattach(activity activity) afin de connaitre son activité hôte et caster son instance dans le listener. Le fragment mettra en place le listener de la manière suivante : package com.siteduzero.android.dynamicui; import android.app.activity; import android.os.bundle; import android.support.v4.app.listfragment; import android.view.layoutinflater; import android.view.view; import android.view.viewgroup; import android.widget.adapterview; import android.widget.adapterview.onitemclicklistener; import android.widget.arrayadapter; import com.siteduzero.android.r; public class CountryListFragment extends ListFragment implements OnItemClickListener { 35

36 2 Fragmenter vos projets private OnCountrySelectedListener mlistener = null ; // Autres public void onattach(activity activity) { super.onattach(activity); try { mlistener = (OnCountrySelectedListener) activity; catch (ClassCastException e) { // Unchecked exception. throw new ClassCastException(activity.toString() + " must implement OnCountrySelectedListener"); public interface OnCountrySelectedListener { void oncountryselected(int public void onitemclick(adapterview<?> arg0, View arg1, int position, long arg3) { if (mlistener!= null) { mlistener.oncountryselected(position); Lorsque l utilisateur clique sur un élément de la liste, il faut tester si le listener a été initialisé pour éviter tout crash de l application. Il vaut mieux une application qui ne répond pas qu une application qui quitte de manière imprévue (dans l éventualité où il n a pas été initialisé). Cette pratique est une bonne habitude à prendre et évite tous les risques liés à une refactorisation du code ou autres manipulations du même genre. Dans l activité hôte, il faut prévoir les différents cas : Soit l utilisateur est en mode portrait et il faut remplacer les fragments en passant le fragment à afficher ; Soit l utilisateur est en mode paysage et il faut mettre à jour le drapeau à afficher. Détecter la configuration de l appareil est identique à la solution implémentée lors de la création de l activité. Si le conteneur FrameLayout est différent de null, l utilisateur est en mode portrait sinon il est en mode paysage. Dans le premier cas, il suffit d utiliser une transaction pour remplacer le fragment dans le conteneur. Dans le second, il faut déclarer une méthode dans le fragment CountryDetailsFragment pour mettre à jour le drapeau selon la position donnée à partir de la méthode public void oncountryselected(int position). Elle s implémente de la façon suivante public void oncountryselected(int position) { 36

37 2.3 Interfaces dynamiques if (findviewbyid(r.id.framelayoutdynamicui) == null) { // If we are in landscape mode, we show article in the second // fragment. final CountryDetailsFragment detailsfragment = (CountryDetailsFragment) getsupp detailsfragment.updatecountry(position); else { // Else, we show the other fragment in portrait mode. final CountryDetailsFragment detailsfragment = CountryDetailsFragment.newInstan final FragmentTransaction ft = getsupportfragmentmanager().begintransaction(); ft.replace(r.id.framelayoutdynamicui, detailsfragment); ft.addtobackstack(null); ft.commit(); Maintenant, à l exécution de l application, la communication est opérationnelle et elle met bien à jour le drapeau à afficher en mode paysage ou elle crée le fragment avec le bon drapeau à afficher dans le mode portrait. Cet exemple est assez simple mais les interfaces peuvent être plus complexes. Il en revient au développeur d y ajouter l intelligence nécessaire pour convenir aux besoins de ses applications. Figure 2.9 Résultat de l exécution d une interface dynamique en mode paysage En résumé Il faut penser ses interfaces pour les différentes tailles d écran et dans les différentes configurations ; 37

38 2 Fragmenter vos projets Une activité reste indépendante des fragments qu elle contient ; Une transaction permet de gérer des fragments dans une activité hôte ; Un listener permettent de communiquer d un fragment A à un fragment B en passant par une activité hôte. 2.4 PreferenceFragment Les paramètres ont une place à part dans une application Android. Une bonne pratique de design est de les intégrer à l apparence du système. Même si ceci peut constraster avec une application au design élaboré, l utilisateur Android est habitué à ce pattern et en sera moins déstabilisé. Le framework Android fournit une solution pour faciliter la vie du développeur en lui permettant de confectionner rapidement ce type d écran. Mais il persiste une restriction non négligeable. La bibliothèque de compatibilité, développée par Google, est constamment utilisée à travers ce tutoriel mais elle ne compte pas parmi ses classes les préférences. Le framework Android propose deux solutions pour implémenter cette fonctionnalité. Elles seront toutes les deux expliquées mais la rétro-compatibilité sera plus complexe que les concepts vus précédemment Définir ses préférences Paramétriser une application n est pas une obligation. Certaines applications n ont pas forcément besoin de sauvegarder quelque chose. De plus, utiliser l affichage des paramètres du système n est pas toujours souhaité même si c est vivement recommandé par les guidelines Android. Un utilisateur Android a l habitude de se rendre dans les paramètres de son téléphone pour activer le Wi-Fi, le Bluetooth, le NFC, gérer le son, la luminosité, etc. Toutes ces choses sont «standardisées» (dans le sens où c est l affichage voulu par Google). L utilisateur est familier avec ce type d écran. Il sait instinctivement comment l utiliser. Il n est alors pas nécessaire d entamer une phase d apprentissage qui pourrait en rebuter certains Créer des groupes de préférences La définition des préférences se fait simplement grâce à un fichier XML. Ce fichier doit se trouver dans le dossier xml des ressources du projet et son contenu doit avoir comme racine l élément PreferenceScreen. A partir de là, il existe trois possibilités pour confectionner les préférences : La première est de catégoriser plusieurs préférences en les regroupant. Il rajoute un titre souligné sur toute la largeur de l écran et liste les préférences de la catégorie en dessous. L élément parent est PreferenceCategory et les préférences doivent se placer comme ses fils. <PreferenceScreen xmlns:android=" > <PreferenceCategory android:key="pref_key_category_1" android:title="@string/title_category_1" > <CheckBoxPreference android:defaultvalue="false" 38

39 2.4 PreferenceFragment android:key="pref_key_pref_1" /> <Preference android:dependency="pref_key_pref_1" android:key="pref_key_pref_2" /> <SwitchPreference android:key="pref_key_pref_3" /> </PreferenceCategory> </PreferenceScreen> La seconde est de placer les préférences dans un nouvel écran. Une préférence sera créée sur le premier écran et lorsque l utilisateur cliquera dessus, un second écran affichera les nouvelles préférences. L élément parent est PreferenceScreen et les préférences doivent se placer comme ses fils. <PreferenceScreen android:key="pref_key_screen" android:persistent="false" android:title="@string/title_screen" > <Preference android:summary="@string/summary_pref_simple" android:title="@string/title_pref_simple" /> </PreferenceScreen> La dernière consiste à déclarer les préférences directement, sans catégorisation ou sous écran. L inconvénient est le risque d avoir son seul et unique écran assez brouillon s il y a trop de préférences Les différentes préférences Il existe plusieurs types de préférence. Elles sont disponibles dans des classes java mais elles peuvent être utilisées directement dans le fichier XML destiné aux préférences en spécifiant un nom identique à l une de ces classes. Les préférences disponibles sont les suivantes : CheckBoxPreference peut retenir un booléen en cochant une case ; SwitchPreference peut retenir un booléen avec un switcher On/Off ; EditTextPreference peut sauvegarder une chaîne de caractères ; RingtonePreference peut saisir une sonnerie à partir du système ou d une application proposant de la musique ; 39

40 2 Fragmenter vos projets Preference affiche une valeur non éditable. Elle est souvent couplée avec une autre préférence pour mettre à jour sa valeur. Raison pour laquelle elle possède un attribut supplémentaire, android:dependency, pour référencer la préférence dont elle est dépendante ; ListPreference est la plus complexe des préférences. Elle définie une liste de valeurs que l utilisateur peut sélectionner. Pour l initialiser, il faut renseigner plusieurs nouveaux attributs : android:entries pour donner le tableau des valeurs qui seront affichés à l utilisateur et android:entryvalues pour afficher les identifiants de chaque valeur des lignes du tableau ; MultiSelectListPreference est identique à ListPreference mais permet de sélectionner plusieurs lignes dans la liste. Parmi les attributs, plusieurs sont communs à toutes les préférences, voire certains essentiels pour pouvoir afficher quelque chose sur la ligne de la préférence ou pour récupérer sa valeur par après dans l application : android:key permet de spécifier un identifiant pour la préférence et permettre de récupérer sa valeur dans le projet ; android:title permet de donner un nom à afficher pour la préférence ou la catégorie ; android:summary pour donner des précisions supplémentaires sur la préférence ; android:defaultvalue pour donner une valeur par défaut à la préférence ; android:persistent pour indiquer si la préférence devra être sauvegardée ou non Intégrer ses paramètres dans une activité L intégration dans une activité dépendra de la version d Android. Le framework fournit un fragment, PreferenceFragment, utilisable comme tous les fragments rencontrés jusqu à présent mais son utilisation est limité à l API 11. Il existe deux méthodes pour intégrer les préférences. L une pour les versions antérieures à la version 3 et l autre pour les versions supérieures. Sachant que ces deux méthodes peuvent cohabiter pour être compatibles pour toutes les versions Antérieur à la version 3 [[attention]] Malgré le fait que toutes les méthodes, qui seront présentées dans ce point, soient marquées «dépréciées» par l environnement de travail Eclipse, il n en reste pas moins le seul moyen actuel pour intégrer un panneau de préférences pour les versions antérieures à 3.0. Sans la bibliothèque de compatibilité, les versions 2.x ne peuvent pas utiliser les fragments. C est pourquoi le framework fournit une activité supplémentaire uniquement destinée aux préférences, PreferenceActivity. Cette activité étend ListActivity pour fournir une liste qu il suffit de remplir par les préférences définies dans le fichier XML. Pour peupler cette liste, il n est pas question de désérialiser le fichier XML mais d appeler la méthode, public void addpreferencesfromresource(int preferencesresid), en renseignant le fichier XML par son identifiant. Elle sera appelée dans la méthode public void oncreate(bundle savedinstancestate) de l activité. Son implémentation se rapprochera donc de l exemple suivant : package com.siteduzero.android.settings; import android.preference.preferenceactivity; 40

41 2.4 PreferenceFragment import com.siteduzero.android.r; public class SettingsActivity extends PreferenceActivity public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); addpreferencesfromresource(r.xml.preferences); Postérieur à la version 3 En revanche, pour les versions plus récentes, la solution est bien plus élégante puisqu elle utilise pleinement la puissance des fragments. La classe PreferenceFragment est conçu pour accueillir les préférences d une application. La méthode est exactement la même qu avec une activité. Il suffit d appeler la méthode public void addpreferencesfromresource(int preferencesresid) dans la méthode public void oncreate(bundle savedinstancestate) du fragment. Quant à l activité hôte, comme il n est pas question d utiliser la bibliothèque de compatibilité, une simple activité suffit pour le gérer. A noter que le framework supporte aussi l intégration du fragment dans la même activité que pour les versions antérieures à la 3, PreferenceActivity. Malgré le fait qu il soit possible de gérer les préférences dans la classe java, le fragment est rarement plus complexe que l exemple ci-présent. package com.siteduzero.android.settings; import android.os.bundle; import android.preference.preferencefragment; import com.siteduzero.android.r; public class SettingsFragment extends PreferenceFragment public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); addpreferencesfromresource(r.xml.preferences); Affiner ses paramètres avec les en-têtes Tout comme les catégories ou les sous écrans, les en-têtes ont pour objectif de rassembler des préférences et de les structurer mais à un niveau supérieur. Contrairement aux catégories (qui 41

42 2 Fragmenter vos projets 42

43 2.4 PreferenceFragment sont recommandées), une petite application aura rarement besoin d utiliser ce nouveau concept. Cela reste tout de même une bonne chose à connaître. D autant plus qu ils sont largement utilisés, notamment dans l application des préférences du système à partir d Android 3.0. Structurer une telle application est nécessaire au vu de la quantité des préférences. Elle utilise à la fois les en-têtes, les catégories, les sous écrans et les préférences. A noter qu autant de préférences pourraient décourager certains utilisateurs. Il faut tenter de rester le plus simple possible tout en restant complet Supérieur à la version 3 Comme la définition des préférences, les en-têtes se définissent dans un fichier XML contenu dans le même dossier ressource, res/xml. L élément racine est preference-headers. Ses fils seront obligatoirement des éléments header qui comportent une série d attributs obligatoires pour référencer le fragment des préférences et ses informations personnelles. android:fragment renseigne le chemin vers le fragment représentant l écran des préférences ; android:title renseigne le titre de l en-tête ; android:summary renseigne les précisions sur l en-tête ; android:icon renseigne l icône à ajouter à gauche de l en-tête. La définition des en-têtes n est pas bien complexe. L exemple ci-dessous illustre les attributs présentés en déclarant deux en-têtes qui pointent vers deux fragments différents. <?xml version="1.0" encoding="utf-8"?> <preference-headers xmlns:android=" > <header android:fragment="com.siteduzero.android.settings.editfragment" android:icon="@android:drawable/ic_menu_edit" android:summary="@string/summary_header_edit" android:title="@string/title_header_edit" > </header> <header android:fragment="com.siteduzero.android.settings.agendafragment" android:icon="@android:drawable/ic_menu_agenda" android:summary="@string/summary_header_agenda" android:title="@string/title_header_agenda" > </header> </preference-headers> En ce qui concerne l activité hôte, il n est plus question de gérer son fragment avec l API de gestion des fragments. L activité PreferenceActivity permet de redéfinir la méthode public void onbuildheaders(list<header> target) qui sera appelée uniquement si l application est exécutée sur un terminal dont la version d Android est supérieure à 3.0. Dans cette méthode, il faut charger les en-têtes grâce à public void loadheadersfromresource (int resid, List<PreferenceActivity.Header> target) : 43

44 2 Fragmenter vos projets package com.siteduzero.android.settings; import java.util.list; import android.preference.preferenceactivity; import com.siteduzero.android.r; public class SettingsActivity extends PreferenceActivity { // This methods is called with Android 3.0 and public void onbuildheaders(list<header> target) { loadheadersfromresource(r.xml.settings_headers, target); [[information]] L utilisation des en-têtes avec une PreferenceActivity propose automatique un affichage multi-fragment en mode paysage sur les tablettes. Les en-têtes s affichent sur une colonne à gauche et les préférences, de l en-tête sélectionné sur une colonne plus grande à droite. Cela peut simplifier la vie du développeur. L exécution sur un terminal avec une version récente d Android donne le résultat suivant pour l affichage des en-têtes Antérieur à la version 3 La cohabitation reste possible avec les en-têtes mais demande une légère duplication dans les ressources en créant un nouveau fichier XML et d ajouter des informations dans l activité hôte. Du côté de la ressource, les vieilles versions ne connaissent pas les en-têtes. Il faut donc ruser en utilisant les éléments existants pour émuler des en-têtes. En regardant de plus près, les en-têtes ressemblent étrangement à de simples préférences qui ouvrent un sous écran. Bien que cela soit une solution envisageable, ce n est pas la meilleure. S il est possible de réutiliser les fichiers XML existants, définissant les écrans, cela rendrait le fichier des en-têtes moins lourd. Raison pour laquelle, il va falloir déclarer des Preference avec comme fils un élément Intent qui va indiquer l écran à charger. Ce nouvel élément déclare trois attributs nécessaires pour indiquer la bonne préférence : android:action indique l action assignée ; android:targetclass indique la classe qui va recevoir l Intent ; android:targetpackage indique le paquetage de la classe cible. L exemple démontre l utilisation de préférences avec les Intent pour émuler les en-têtes pour être parfaitement compatible avec les vieilles versions. <?xml version="1.0" encoding="utf-8"?> <PreferenceScreen xmlns:android=" > <Preference android:icon="@android:drawable/ic_menu_edit" android:summary="@string/summary_header_edit" 44

45 2.4 PreferenceFragment 45

46 2 Fragmenter vos projets > <intent android:action="com.siteduzero.android.settings.edit" android:targetclass="com.siteduzero.android.settings.settingsactivity" android:targetpackage="com.siteduzero.android.settings" /> </Preference> <Preference > <intent android:action="com.siteduzero.android.settings.agenda" android:targetclass="com.siteduzero.android.settings.settingsactivity" android:targetpackage="com.siteduzero.android.settings" /> </Preference> </PreferenceScreen> Du côté de l activité hôte, c est un petit plus complexe. Il faut pouvoir ajouter les en-têtes des deux versions et, dans le cas des vieilles versions, traité l Intent en affichant le bon écran de préférences. La solution pour les versions récentes reste indépendante. Elle ne gène pas la cohabitation. En revanche, l inverse n est pas aussi simple. L ajout des en-têtes doit se faire uniquement si la version d Android est plus petite qu Honeycomb et l écran adéquat doit être affiché en fonction de l action de l Intent. Dans la méthode public void oncreate(bundle savedinstancestate) de l activité, il faut récupérer l action de l Intent et tester sa valeur avec les différentes actions des en-têtes. Si aucune action n est disponible dans l Intent, cela veut dire qu il faut afficher les en-têtes. package com.siteduzero.android.settings; import java.util.list; import android.os.build; import android.os.bundle; import android.preference.preferenceactivity; import com.siteduzero.android.r; public class SettingsActivity extends PreferenceActivity { private static final String ACTION_PREF_EDIT = "com.siteduzero.android.settings.edi private static final String ACTION_PREF_AGENDA public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); // Preferences for Android 2.3 and lower. final String settings = getintent().getaction(); 46

47 2.4 PreferenceFragment // Show screen if a preference if header send an if (ACTION_PREF_EDIT.equals(settings)) { addpreferencesfromresource(r.xml.settings_edit); else if (ACTION_PREF_AGENDA.equals(settings)) { addpreferencesfromresource(r.xml.settings_agenda); else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) { // Show header if there aren't intent. addpreferencesfromresource(r.xml.settings_headers_legacy); // This methods is called with Android 3.0 and public void onbuildheaders(list<header> target) { loadheadersfromresource(r.xml.settings_headers, target); Passer un bundle Avec l utilisation des PreferenceFragment, cela peut paraître lourd de devoir créer un fragment par fichier XML. Les en-têtes peuvent palier à ce problème en prenant un Extra comme fils. Cet élément se place dans les arguments du fragment cible en rajoutant la valeur donnée dans son attribut android:value à la clé donnée par l attribut android:name. Le fragment cible reste identique pour chaque en-tête mais la valeur, pour la même clé, dans les extras est différente pour savoir quel écran des paramètres afficher. <?xml version="1.0" encoding="utf-8"?> <preference-headers xmlns:android=" > <header android:fragment="com.siteduzero.android.settings.settingsfragment" android:icon="@android:drawable/ic_menu_edit" android:summary="@string/summary_header_edit" android:title="@string/title_header_edit" > <extra android:name="settings" android:value="header_edit" /> </header> <header android:fragment="com.siteduzero.android.settings.settingsfragment" android:icon="@android:drawable/ic_menu_agenda" android:summary="@string/summary_header_agenda" android:title="@string/title_header_agenda" > <extra android:name="settings" android:value="header_agenda" /> </header> 47

48 2 Fragmenter vos projets </preference-headers> L unique fragment doit simplement gérer l argument et ajouter les préférences à partir de sa ressource suivant la valeur donnée. package com.siteduzero.android.settings; import android.os.bundle; import android.preference.preferencefragment; import com.siteduzero.android.r; public class SettingsFragment extends PreferenceFragment { private static final String KEY_SETTINGS = "settings" ; private static final String HEADER_EDIT = "header_edit" ; private static final String HEADER_AGENDA = "header_agenda" public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); // Show right preference due to arguments in the fragment. final String settings = getarguments().getstring(key_settings); if (HEADER_EDIT.equals(settings)) { addpreferencesfromresource(r.xml.settings_edit); else if (HEADER_AGENDA.equals(settings)) { addpreferencesfromresource(r.xml.settings_agenda); Lire les préférences La lecture des préférences se fait par l intermédiaire des SharedPreference, utilisables en dehors des préférences. Il suffit de récupérer les préférences partagées par défaut via la méthode statique public static SharedPreferences getdefaultsharedpreferences(context context) de la classe PreferenceManager. Une fois l instance des préférences partagées, il faut récupérer les valeurs des différentes préférences via l identifiant renseigné dans le fichier XML. Le code de cet exemple pourrait être intégré dans la méthode onresume de l activité ou du fragment pour recharger les données des préférences après une mise en pause de l activité hôte. SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this); boolean pref1 = prefs.getboolean("pref_key_pref_1", false); mtextviewpref1.settext("" + pref1); String pref2 = prefs.getstring("pref_key_pref_2", "Nothing"); mtextviewpref2.settext("" + pref2); boolean pref3 = prefs.getboolean("pref_key_pref_3", false); 48

49 2.5 DialogFragment mtextviewpref3.settext("" + pref3); String pref4 = prefs.getstring("pref_key_pref_4", "Nothing"); mtextviewpref4.settext("" + pref4); String pref5 = prefs.getstring("pref_key_pref_5", "Nothing"); mtextviewpref5.settext("" + pref5); String pref6 = prefs.getstring("pref_key_pref_6", "Nothing"); mtextviewpref6.settext("" + pref6); En affichant simplement ses préférences et en éditant quelques valeurs parmi elles, cela donne l exécution suivante En résumé PreferenceFragment n est pas disponible dans le projet de compatibilité mais une cohabitation est possible avec les plus vieilles versions d Android ; Les préférences et les en-têtes se définissent dans un fichier XML et sont ajoutés dans une activité ou un fragment à la place d être désérialisé ; PrefrenceActivity est destiné à la compatibilité avec les vieilles versions mais elle peut être utilisée avec les plus récentes ; Toutes les préférences possèdent un identifiant unique pour pouvoir en récupérer sa valeur à partir de la mémoire partagée par défaut ; Il est possible de rajouter des valeurs dans un bundle pour les préférences et dans les arguments d un fragment pour les en-têtes. 2.5 DialogFragment Les boites de dialogue sont présentes depuis les toutes premières versions d Android. Avec la version 3.0, les DialogFragment amènent les fragments dans ce composant. Ils permettent d afficher une boite de dialogue à l utilisateur de manière beaucoup plus souple et plus complète que l API utilisée dans les versions antérieures Créer un DialogFragment Les API AlertDialog et Dialog sont des concepts régulièrement utilisés depuis toujours dans le développement d applications Android. L idée derrière cette mise à niveau est de ré-utiliser ce type de composant mais en lui attachant des fragments. C est une pratique qui permettra de concevoir des boites de dialogue infiniment plus puissantes et réutilisables que les anciennes. DialogFragment servira de conteneur pour un fragment simple. Il le transformera en boite de dialogue et fournira le style et la structure de la boite. Cette classe fournit tous les contrôles nécessaires pour créer la boite et gérer son apparence. Pour spécifier qu un fragment est destiné à être affiché dans une boite de dialogue, le futur fragment doit étendre la classe DialogFragment et redéfinir certaines méthodes. Ces méthodes sont utiles pour sa gestion et pour son intégration dans la boite. Sans surprise, deux méthodes sont définies et redéfinies : 49

50 2 Fragmenter vos projets 50

51 2.5 DialogFragment public View oncreateview(layoutinflater inflater, ViewGroup container, Bundle savedinstancestate) : Pour désérialiser le fichier XML représentant le fragment voulu et pour donner un titre à la boite de dialogue (ce dernier étant optionnel). public static MyDialogFragment newinstance() : Pour encapsuler la création du fragment et en connaitre les données potentielles. La classe suivante donne un exemple d implémentation : package com.siteduzero.android.dialog; import android.os.bundle; import android.support.v4.app.dialogfragment; import android.view.layoutinflater; import android.view.view; import android.view.view.onclicklistener; import android.view.viewgroup; import android.widget.button; import com.siteduzero.android.r; public class MyDialogFragment extends DialogFragment { public static MyDialogFragment newinstance(int title) { MyDialogFragment dialog = new MyDialogFragment(); Bundle args = new Bundle(); args.putint("title", title); dialog.setarguments(args); return public View oncreateview(layoutinflater inflater, ViewGroup container, Bundle savedinstancestate) { View v = inflater.inflate(r.layout.fragment_dialog, container, false); Button button = (Button) v.findviewbyid(r.id.buttonshow); button.setonclicklistener(new OnClickListener() { public void onclick(view v) { ((DialogActivity) getactivity()).showdialogtype(dialogactivity.type_alert_dialog); ); getdialog().settitle(getarguments().getint("title")); return v; Pour afficher la boite de dialogue, il suffit d appeler la méthode public int show (Fragment- Transaction transaction, String tag) sur une instance d un DialogFragment comme 51

52 2 Fragmenter vos projets expliqué dans la documentation officielle Créer un AlertDialog Le fonctionnement d une AlertDialog reste inchangé dans les grandes lignes et les nouveautés ressemblent au fonctionnement des DialogFragment. Il est toujours nécessaire d étendre la classe DialogFragment mais il faut redéfinir une nouvelle méthode, public Dialog oncreatedialog(bundle savedinstancestate). C est dans cette méthode qui va falloir utiliser le builder, AlertDialog.Builder. Vous êtes censé savoir comment créer un AlertDialog. Je ne rentrerai donc pas dans les détails en ce qui concerne sa création mais beaucoup plus en ce qui concerne son intégration dans un fragment. En fait, c est vraiment très semblable au DialogFragment et vous devez avoir une petite idée de la manière de s y prendre avec les connaissances que je viens de vous apporter et ainsi que celles portant sur sa création dans une Activity. Bien entendu, ce n est pas exactement la même chose. Nous n allons pas devoir redéfinir la méthode public View oncreateview(layoutinflater inflater, ViewGroup container, Bundle savedinstancestate) mais public Dialog oncreatedialog(bundle savedinstancestate). A partir de là, il nous suffit de retourner une AlertDialog avec l aide d un builder. La redéfinition de la méthode donnera quelque chose comme public Dialog oncreatedialog(bundle savedinstancestate) { int title = getarguments().getint("title"); return new AlertDialog.Builder(getActivity()).setIcon(android.R.drawable.ic_dialog_alert).setTitle(title).setNegativeButton(R.string.alert_dialog_cancel, new DialogInterface.OnClickListener() { public void onclick(dialoginterface dialog, int whichbutton) { ((DialogActivity) getactivity()).donegativeclick(); ).setpositivebutton(r.string.alert_dialog_ok, new DialogInterface.OnClickListener() { public void onclick(dialoginterface dialog, int whichbutton) { ((DialogActivity) getactivity()).dopositiveclick(); ).create(); [[attention]] N oubliez pas d implémenter la méthode static pour créer une instance comme nous l avons fait avec DialogFragment. 52

53 2.5 DialogFragment 53

54 2 Fragmenter vos projets Ainsi, le résultat est le suivant : Afficher une boite de dialogue Dernière petite chose avant de terminer ce chapitre. Nous allons rapidement voir comment intégrer nos boites de dialogue dans une activité. Vous comprendrez que ce n est vraiment pas compliqué puisqu il s agit d un fragment comme un autre. C est la raison pour laquelle je vais vous laisser réfléchir à la question. Si vous avez bien compris la matière que je vous ai enseigné dans les chapitres précédents, cela ne devrait pas vous prendre trop longtemps. Sachez simplement que vous devez implémenter un certain nombre de méthode : public void donegativeclick() : Appelée lorsqu on clique sur le bouton négatif de l AlertDialog. public void dopositiveclick() : Appelée lorsqu on clique sur le bouton positif de l AlertDialog. public void showalertdialog(view v) : Appelée au clique de l utilisateur sur le bouton de notre activité destiné à l affichage de l AlertDialog. public void showdialogfragment(view v) : Appelée au clique de l utilisateur sur le bouton de notre activité destinée à l affichage de DialogFragment. protected void showdialogtype(int type) : Pour basculer dynamiquement entre les différentes boîtes de dialogue. Je vous laisse à vos lignes de codes. Vous trouverez ma solution et son résultat à la suite de ce chapitre Correction package com.siteduzero.android.dialog; import android.os.bundle; import android.support.v4.app.dialogfragment; import android.support.v4.app.fragment; import android.support.v4.app.fragmentactivity; import android.support.v4.app.fragmenttransaction; import android.view.view; import com.siteduzero.android.r; import com.siteduzero.android.dialog.alert.myalertdialog; public class DialogActivity extends FragmentActivity { public static final int TYPE_DIALOG_FRAGMENT = 1 ; public static final int TYPE_ALERT_DIALOG = 2 protected void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.activity_dialog); 54

55 2.5 DialogFragment 55

56 2 Fragmenter vos projets protected void showdialogtype(int type) { FragmentTransaction ft = getsupportfragmentmanager().begintransaction(); Fragment prev = getsupportfragmentmanager().findfragmentbytag("dialog"); if (prev!= null) { ft.remove(prev); ft.addtobackstack(null); DialogFragment newfragment = null ; switch (type) { case TYPE_DIALOG_FRAGMENT: newfragment = MyDialogFragment.newInstance(R.string.title_fragment_dialog); break ; case TYPE_ALERT_DIALOG: newfragment = MyAlertDialog.newInstance(R.string.title_fragment_dialog_alert); break ; newfragment.show(ft, "dialog"); public void showdialogfragment(view v) { showdialogtype(type_dialog_fragment); public void showalertdialog(view v) { showdialogtype(type_alert_dialog); public void dopositiveclick() { // TODO Do something public void donegativeclick() { // TODO Do something En résumé DialogFragment est une sous classe de Fragment qui permet de contenir des fragments dans des boites de dialogue. Il existe 2 types de boites de dialogue : DialogFragment qui est générique que vous contrôlez de A à Z ; AlertDialog qui est moins générique car rajoutant des boutons en bas de la 56

57 2.5 DialogFragment 57

58 2 Fragmenter vos projets boite. Ces boites de dialogue se lancent à peu de chose près comme un fragment normal. 58

59 3 Conclusion [[attention]] Bien entendu, ce tutoriel est très loin d être terminé. N hésitez pas à me donner votre avis pour le faire évoluer. Il a pour but d être le plus communautaire possible. Je suis donc ouvert à toutes vos critiques, questions et remarques constructives! 3.1 Remerciements Aux lecteurs et bêta-testeurs qui me font des critiques constructives sur le contenu de mon tutoriel. Fumble pour la validation de mon tutoriel. Bluekicks pour l icône de mon tutoriel. 59