Vous êtes sur la page 1sur 78

Aller plus loin dans le développement Android

Par AndroWiiid

www.siteduzero.com

Licence Creative Commons 6 2.0 Dernière mise à jour le 4/01/2013

2/79

Sommaire
Sommaire ........................................................................................................................................... 2 Lire aussi ............................................................................................................................................ 1 Aller plus loin dans le développement Android ................................................................................... 3
Bonjour amis Zéros, .......................................................................................................................................................... 3

Partie 1 : Fragmenter vos projets ........................................................................................................ 4
Fragment ........................................................................................................................................................................... 4
Introduction aux fragments .......................................................................................................................................................................................... 4 Les fragments, kézako ? ............................................................................................................................................................................................. 4 Le cycle de vie des fragments ..................................................................................................................................................................................... 4 La bibliothèque de compatibilité .................................................................................................................................................................................. 5 Utiliser des fragments fixes ......................................................................................................................................................................................... 6 Création d'un fragment ................................................................................................................................................................................................ 6 Réarranger les fragments en paysage ........................................................................................................................................................................ 8 Utiliser des fragments dynamiques ........................................................................................................................................................................... 10 Gérer ses fragments .................................................................................................................................................................................................. 10 Le contrôleur des fragments ..................................................................................................................................................................................... 10 Retenir sa position dans les fragments ..................................................................................................................................................................... 13

ListFragment ................................................................................................................................................................... 16
Utilisation simple des listes ....................................................................................................................................................................................... Déclarer sa liste dans des fichiers XML .................................................................................................................................................................... Création de la ListFragment ...................................................................................................................................................................................... Intégrer une vue personnalisée ................................................................................................................................................................................. Créer une vue personnalisée .................................................................................................................................................................................... Créer son adaptateur ................................................................................................................................................................................................ Vers des listes dynamiques ....................................................................................................................................................................................... Modification de l'adaptateur ...................................................................................................................................................................................... Paramétriser son application ..................................................................................................................................................................................... Définir ses préférences ............................................................................................................................................................................................. Créer son fragment avec son activité ........................................................................................................................................................................ Affiner ses paramètres avec les en-têtes .................................................................................................................................................................. Définir les en-têtes .................................................................................................................................................................................................... Attacher à une activité ............................................................................................................................................................................................... Lire les préférences ................................................................................................................................................................................................... 16 16 17 18 18 20 22 22 28 28 30 31 32 33 34

PreferenceFragment ....................................................................................................................................................... 28

DialogFragment ............................................................................................................................................................... 36
Créer un DIalogFragment .......................................................................................................................................................................................... 36 Créer un AlertDialog .................................................................................................................................................................................................. 37 Afficher une boite de dialogue ................................................................................................................................................................................... 39 Correction .................................................................................................................................................................................................................. 40

Partie 2 : Des nouveaux composants ............................................................................................... 41
La barre d'action des applications ................................................................................................................................... 42
Intégrer un menu ....................................................................................................................................................................................................... 42 Possibilités avancées ................................................................................................................................................................................................ 44 Barre de recherche .................................................................................................................................................................................................... 44 Partage à travers le système ..................................................................................................................................................................................... 46 « Spliter » le menu .................................................................................................................................................................................................... 48 Bouton home ............................................................................................................................................................................................................. 49 Menu contextuel ........................................................................................................................................................................................................ 50

Slider à travers des écrans ............................................................................................................................................. 52
Passer des informations à la création d'un fragment ................................................................................................................................................ Utilisation du widget ViewPager ................................................................................................................................................................................ L'adaptateur du ViewPager ....................................................................................................................................................................................... Activité du ViewPager ............................................................................................................................................................................................... Ajout d'un indicateur de la page ................................................................................................................................................................................ Navigation en tab ...................................................................................................................................................................................................... Modifier l'indicateur ................................................................................................................................................................................................... Modifier la page ......................................................................................................................................................................................................... 53 54 54 55 56 57 57 58

Notifier l'utilisateur ........................................................................................................................................................... 62
Basique ..................................................................................................................................................................................................................... 62 Les différents styles ................................................................................................................................................................................................... 63 Grand texte ................................................................................................................................................................................................................ 64 Grande image ............................................................................................................................................................................................................ 65 Liste de chaînes de caractères ................................................................................................................................................................................. 67 Ajouter des boutons d'action ..................................................................................................................................................................................... 69

Le partage par NFC ......................................................................................................................................................... 70
Les différents tags existants ...................................................................................................................................................................................... Identification des différents tags ................................................................................................................................................................................ Structure d'un message NDEF .................................................................................................................................................................................. Implémentation dans notre application ..................................................................................................................................................................... Lecture d'un tag ......................................................................................................................................................................................................... Activité destiné à gérer la lecture du tag ................................................................................................................................................................... Un émulateur de tag NDEF ....................................................................................................................................................................................... Echange par Beam ................................................................................................................................................................................................... 71 71 71 72 72 72 74 76

www.siteduzero.com

Sommaire

3/79

Aller plus loin dans le développement Android
Le tutoriel que vous êtes en train de lire est en bêta-test. Son auteur souhaite que vous lui fassiez part de vos commentaires pour l'aider à l'améliorer avant sa publication officielle. Notez que le contenu n'a pas été validé par l'équipe éditoriale du Site du Zéro.

Par

AndroWiiid

Mise à jour : 04/01/2013 Difficulté : Difficile 245 visites depuis 7 jours, classé 323/798

Bonjour amis Zéros,
Si créer des applications Android est devenue une passion pour vous grâce à l'excellent tutoriel de Apollidore qui aborde les bases du développement Android, vous êtes au bon endroit. La valeur ajoutée de ce tutoriel est de vous permettre d'apprendre des notions sont parfois difficiles à acquérir tant les ouvrages sont peu nombreux sur les nouvelles technologies intégrées au système. L'objectif de ce tutoriel est d'aborder des notions avancées sur le développement Android en restant accessible pour les 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. Pour parvenir à atteindre cet objectif, nous aborderons : L'utilisation de fragments pour confectionner des interfaces souples et avancées. Les derniers composants ajoutées dans les dernières versions d'Android. La mise en place d'un serveur pour nous permettre d'alimenter nos applications par après. La gestion de données partagées avec, entre autre, la récupération des données sur une base de données distantes. L'intégration d'une Google Map de la génération de la clé API aux marqueurs à placer sur la map. L'utilisation de librairies communautaires pour vous aider dans le développement Android. Si ce menu vous parait intéressant à suivre, attendez de lire le tutoriel et d'en apprendre plus. V ous pouvez retrouver tous les codes sources de ce tutoriel sur ce projet GitHub.

www.siteduzero.com

à savoir onCreate. Quant à la version tablette. il en rajoute quand même qui sont appelés par l'activité hôte du fragment. Cela nous permettra d'isoler des portions d'interface que nous allons gérer dans des classes fragments plutôt que dans une Activity. L'idée consiste de définir des fragments que vous afficherez un à un sur un smartphone et à plusieurs sur tablette. une nouvelle notion est apparue dans le développement d'application. Les fragments sont maintenant utilisés pour le développement de toutes les applications (du moins sérieuses) sur le Play Store. vous n'aurez pas spécialement envie avoir la même interface. Les fragments sont à mi-chemin entre l'activité et la vue . V otre fragment consiste à définir un morceau d'interface que vous pourrez attacher à plusieurs endroits. nous aurons le type de base. Ce genre de chose est possible grâce aux fragments ! Le cycle de vie des fragments V ous connaissez certainement les activités (j'espère en tout cas sinon il y a du souci à se faire ) et leurs cycles de vie. sans changer d'écran. kézako ? La notion de fragment est souvent confuse pour les débutants et pas toujours bien comprise par ceux qui commencent à programmer assez régulièrement sur la plateforme Android. Fragment Introduction aux fragments Les fragments. Celui des fragments est très similaire et en même temps étroitement lié avec l'activité à laquelle est attaché. Si vous avez une liste de news (par hasard ? ). vous lancerez un autre écran avec les détails de la news sélectionnée. les boites de dialogue et ceux conçus pour paramétriser ses applications. Cependant. onResume. vous afficherez la liste des news à gauche et directement à droite les détails de la news sélectionnée. c'est-à-dire qu'il ne s'agit ni de l'un.siteduzero. ni de l'autre mais qu'ils sont étroitement liés. Sur votre smartphone. Nous verrons l'utilité de ces nouvelles méthodes dans la suite de ce chapitre. sur des activités.Aller plus loin dans le développement Android 4/79 Partie 1 : Fragmenter vos projets Depuis Android 3. dans le cas où vous désirez rendre compatible votre application sur smartphone et sur tablette. V ous retrouvez toutes les méthodes callback d'une activité. onStop et onDestroy. vous afficherez cette liste et une fois que l'utilisateur aura effectué une pression sur l'un des items de la liste. les listes. Ces méthodes ont exactement le même but dans les fragments que dans les activités. onStart. que cela soit dans son cycle de vie ou dans les différentes types de classe qu'il peut créer. La taille d'écran des tablettes étant largement plus grande que celles des smartphones. Nous verrons l'utilisation de chacun d'eux via des exemples simples mais précis pour expliquez comment ces classes fonctionnent. il serait dommage de ne pas en profiter. V ous pouvez voir l'ensemble des méthodes via le schéma ci-dessous disponible sur le portail des développeurs Android . Nous verrons aussi qu'ils ressemblent beaucoup aux activités. Par exemple.com . Ainsi. www. onPause. Fragment.

Android était dédié uniquement aux smartphones .Partie 1 : Fragmenter vos projets 5/79 Cycle de vie des fragments disponible à partir du site des développeurs Android La bibliothèque de compatibilité C'est bien beau n'est-ce pas ? Un monde où vous pouvez librement placer des fragments aux endroits que vous désirez pour optimiser vos applications sur le plus d'appareil possible.siteduzero.com . ce n'est pas si simple. c'est-à-dire à des écrans de moins de 4 pouces (les smartphones de plus de 4 pouces ne sont www. Malheureusement. Au début.

Google a tenté de rendre l'utilisation de la bibliothèque le plus proche de son utilisation normal. HoneyComb. il va falloir savoir comment nous pouvons en créer. et dans la suite de ce chapitre.siteduzero. Avec un peu de réflexion. Soit regrouper environ 95% du marché des appareils tournant avec Android. Quel est la différence entre ces 2 fragments ? Le premier redirige vers le Fragment de la version d'Android que vous avez délimité dans le manifest de votre projet .app. Il existe deux manières d'intégrer des fragments dans une activité : de manière fixe en spécifiant vos fragments directement dans un fichier XML d'affichage ou dynamiquement avec l'aide d'outils mis à disposition aux développeurs par Android. Bundle savedInstanceState) dont le premier paramètre vous permettra de le faire. C'est pourquoi nous ne verrons pas d'exemple concret pour les TV mais les techniques que vous apprendrez dans ce tutoriel vous permettront d'en développer. Création d'un fragment Avant de pouvoir utiliser des fragments. Nous allons nommer notre fichier XML d'affichage fragment_fixe et nous placerons dedans : Code : XML <?xml version="1. elles auront globalement les mêmes signatures. Il est tout à fait possible de développer pour ce genre d'appareil mais les bonnes pratiques d'ergonomie sont encore un peu vague. on commence de plus en plus à voir des TV avec Android comme système.app. Eclipse vous proposera d'importer deux paquetages pour avoir accès à Fragment (android. ce composant (et les autres que nous verrons dans la suite de cette première partie) n'est pas disponible en dessous de cette version. De plus. Le deuxième redirige vers le Fragment du projet de compatibilité Google (bibliothèque inclut automatiquement lors de la création d'un nouveau projet dans les récents ADT). c'est-àdire que vous n'aurez pas accès à cet import si vous n'êtes pas à une version 3 et plus puisque Android 2 ne connait normalement pas les fragments.com . C'est une erreur commune chez les développeurs débutants mais aussi expérimentés. la manière dynamique. vous pourriez parvenir à le faire vous même parce que c'est quasiment identique aux activités. Google est une boite formidable ! Ils ont développé une librairie de compatibilité qui vous permettra d'utiliser une très grande partie des fonctionnalités disponibles à partir de la version 3 d'Android dès la version 2. Aujourd'hui. Nous aborderons d'abord le plus simple. à quelques différences près.v4. Nous allons simplement placer un TextView au centre du fichier XML d'affichage que nous attacherons à un Fragment qui sera lui même attaché à une Activity. qu'est apparu les fragments. Pour ce faire. C'est avec cette version 3.Fragment). je vous le dis. nous allons faire quelque chose de simple. les fragments fixes. Comment pouvons-nous donc développer notre application sans devoir créer deux projets (un pour les versions 2 et antérieur et un autre pour la version 3 et supérieur) ? Je vous ai déjà dit que Google était une boite formidable ? Maintenant.support. A savoir que nous ne désérialisons pas notre fichier XML dans la méthode public void onCreate (Bundle savedInstanceState) mais à partir de la méthode public View onCreateView (LayoutInflater inflater. Mise à part quelques méthodes.android.1. Il vous suffit de définir une portion d'interface dans un fichier XML d'affichage et de l'attacher à un Fragment. nous utiliserons à chaque fois les imports de la bibliothèque de compatibilité. Sauf si vous ne désirez pas rendre vos futurs programmes compatibles avec les anciens terminaux. c'est très simple.com/apk/res/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" www. Utiliser des fragments fixes V ous savez maintenant ce que sont des fragments. Par après. Google a étendu son système aux tablettes avec la version 3 (les versions 2 et moins étaient donc destinés aux smartphones) et la version 4 qui unifie les 2 types.0" encoding="utf-8"?> <RelativeLayout xmlns:android="http://schemas. Nous apprendrons à l'utiliser et à aller plus loin grâce à un projet communautaire de compatibilité que nous verrons plus loin dans ce tutoriel.Fragment et android. V ous n'avez peut-être pas saisi complètement son utilité mais vous comprendrez vite.Partie 1 : Fragmenter vos projets 6/79 arrivés que très récemment à l'heure où j'écris ces lignes). Techniquement. ViewGroup container. Il faudra constamment faire attention aux imports dans vos projets. Pour notre exemple. et chose importante.

Code : XML <?xml version="1.R. android. android.R.v4.android.Bundle.com . et dans lequel nous allons déclarer un widget Fragment qui spécifie dans son attribut android:name notre FixeFragment. import com. android.inflate(R. cela sera une habitude prise dans ce tutoriel pour que vous ne soyez jamais perdu.layout. il nous suffit simplement de désérialiser le fichier XML d'affichage que nous venons de créer pour attacher notre Fragment et d'étendre la classe FragmentActivity à la place de Activity pour notifier Android que nous utilisons des Fragment.android.0" encoding="utf-8"?> <fragment xmlns:android="http://schemas.view. container.view.android. import android.siteduzero. que nous nommerons activity_fragment_fixe.Partie 1 : Fragmenter vos projets android:layout_centerVertical="true" android:text="@string/title_fragment_fixe" /> </RelativeLayout> 7/79 Nous désérialisons ce fichier XML d'affichage dans un fragment que nous nommerons FixeFragment : Code : Java package com. Bundle savedInstanceState) { return inflater. } } V ous remarquerez que je spécifie exprès la définition du paquetage et les imports.com/apk/res/android" android:name="com.View. import import import import import android. setContentView(R.fragments. Dans chaque activité. public class FixeActivity extends FragmentActivity { @Override protected void onCreate(Bundle arg0) { super.siteduzero. android. Code : Java package com.fixe. V ous pouvez vous rendre compte de la simplicité déconcertante de la création d'un fragment.fragments.activity_fragment_fixe). false).siteduzero.fragment_fixe.siteduzero.android.support. Son utilisation est tout aussi simple lorsque vous l'attachez fixement à une activité. C'est une chose importante dans les fragments.v4. import com. ViewGroup container.fixe.onCreate(arg0).app.FixeFragment" android:layout_width="match_parent" android:layout_height="match_parent" /> Dans le code de l'activité.os.support.os.fixe.android.android.fragments.app.ViewGroup.Bundle. nous allons créer un autre fichier XML d'affichage. www.siteduzero.view.layout. public class FixeFragment extends Fragment { @Override public View onCreateView(LayoutInflater inflater.siteduzero.LayoutInflater.Fragment. import android.FragmentActivity. FixeActivity .

Dans notre cas. peu importe ce que vous placez dans un fragment. C'est l'une des forces de l'utilisation des fragments. Habituellement. les fragments joueront le rôle de contrôleurs pour les vues qu'ils instancient. Cela permet de maintenir plus aisément le code et de séparer les responsabilités entre différentes classes.Partie 1 : Fragmenter vos projets } } 8/79 Qu'est ce que nous pouvons en dire ? V ous pouvez vous rendre compte que l'activité est vide.siteduzero. Résultat de l'exécution de l'activité FixeActivity www. 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'application).com .

V ous êtes censé avoir une petite idée de la marche à suivre si vous avez déjà développé sur Android ou si vous avez suivi le tutoriel officiel d'Android pour débutant du Site du Zéro. C'est pourquoi je vais vous laisser réfléchir sur le problème pour parvenir à ce résultat : Résultat de l'exécution de l'activité FixeActivity en paysage Correction V ous avez réussi à trouver quelque chose ? Si vous êtes parvenu à un résultat similaire au mien.fixe.android.com . Si vous avez la même solution que moi.fragments. C'est pourquoi je vais vous expliquer comment réarranger vos fragments lorsque vous basculez votre appareil en mode paysage. c'est déjà pas mal. ce n'est pas parce que nous définissons des diagrammes fixes que nous ne pouvons pas faire des choses intéressantes.siteduzero.android.Partie 1 : Fragmenter vos projets 9/79 Réarranger les fragments en paysage Cependant.FixeFragment" android:layout_width="match_parent" android:layout_height="match_parent" android:layout_weight="1" /> <fragment android:name="com.fixe. Nous voulons afficher FixeFragment lorsque nous sommes en mode portrait et deux fois l'un à côté de l'autre en mode paysage.siteduzero.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas. c'est encore mieux.FixeFragment" www. Pourquoi ? Simplement parce que la solution la plus simple pour parvenir à mon résultat est de créer un nouveau fichier XML d'affichage du même nom que celui de l'activité qui se trouve dans le dossier layout mais dans le layout-land et en définissant les deux Fragment dans ce fichier.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="horizontal" > <fragment android:name="com.siteduzero. L'idée est la suivante.android.fragments. Le système se rendra automatiquement dans ce dossier pour récupérer le bon fichier XML et tout sera fait automatiquement ! Code : XML <?xml version="1.

Ce mot clé n'est pas un hasard et se retrouvera un peu partout dans l'utilisation des classes venant de la bibliothèque. FragmentManager. Sachez simplement que vous devrez lui donner un identifiant afin de pouvoir remplacer son contenu par un autre. Cliquez sur un bouton ouvre une nouvelle activité qui affiche les widgets déclarés dans son fichier XML d'affichage. V ous aurez sans doute remarqué le mot clé "support" dans l'importation de la classe Fragment. Ainsi. je sais ce que vous feriez.com .siteduzero. Utiliser ces services est très simple mais il ne faut pas oublier que nous utilisons la bibliothèque de compatibilité de Google. Comment ça fonctionne ? Chaque opération sur les fragments doivent être regroupée dans une transaction accessible à partir du FragmentManager. le plus simple est d'utiliser les tags. vous définissez des écrans fixes. lorsque vous développez vos applications. cela serait bien de pouvoir les récupérer. Pour utiliser ces tags. Seconde chose. Le réel changement sera dans notre activité. Qu'allonsnous faire ? Nous allons créer deux fragments qui afficheront. elles deviennent contrôleurs des fragments qu'elles contiennent. vous aurez une erreur.. nous récupérerons le FragmentManager pour appeler dessus la méthode public abstract Fragment findFragmentByTag (String tag). Si vous utilisez des fragments qui viennent du paquetage android.app. L'initialisation du manager est donc un peu différente. par identifiant ou par tag. V ous êtes obligé de faire un choix ! Le contrôleur des fragments V ous vous souvenez ce que je vous ai dit au sous-chapitre précédent ? Les activités ne servent plus de contrôleurs des vues qu'elles contiennent. Elle pourra être appelé à partir des boutons. Il suffit de rajouter une constante publique dans nos fragments pour leur donné un nom unique. nous appelerons deux méthodes : private void setupFragments() et private void showFragment(final Fragment fragment). Première chose. Je vous laisse à votre bon soin de créer les fragments Dynamic1Fragment et Dynamic2Fragment. Il existe deux manières d'y parvenir. La seconde méthode se chargera d'afficher le fragment qu'on passe en paramètre à l'écran. Comme nous avons des classes fragments. Habituellement. V ous comprendrez bien assez vite. Sans doute quelque chose qui ressemble à this. Cependant. Gérer ses fragments Android met à disposition des développeurs une interface indispensable pour gérer ses fragments dynamiquement. pour initialiser.Fragment mais que vous utilisez FragmentManager de la bibliothèque de compatibilité (ou inversement).Partie 1 : Fragmenter vos projets android:layout_width="match_parent" android:layout_height="match_parent" android:layout_weight="1" /> </LinearLayout> 10/79 Utiliser des fragments dynamiques On va faire quelque chose d'encore plus intéressant. Cette interface offre plusieurs services dont un qui nous intéresse tout particulièrement : gérer des transactions. pour les deux. C'est la responsabilité de l'activité de gérer l'affichage du fragment qu'on désire. nous allons devoir structurer notre code. son fichier XML d'affichage ne comportera aucun fragment mais un FrameLayout. Il est bien possible de masquer des portions d'interface mais ce n'est jamais très performant (voire joli). nous essayerons de les récupérer par le biais de cette méthode afin d'économiser de la mémoire ! V oici à quoi ressemble notre méthode avec nos deux fragments : www. V ous n'avez pas tout à fait tord mais il ne faut jamais perdre à l'esprit que nous développons sur des appareils mobiles et il n'y a pas de petites économies. Si Android parvient à sauvegarder en cache nos fragments. encore plus lorsqu'elles doivent les gérer dynamiquement.mDynamic1Fragment = new Dynamic1Fragment(). vous utiliserez non pas la méthode public FragmentManager getFragmentManager() mais la méthode public FragmentManager getSupportFragmentManager(). Initialisation des fragments Si je vous demandais d'initialiser les fragments. Il servira de conteneur pour nos fragments. un TextView et un Button. Cela nous permettra de switcher d'un fragment à l'autre en appuyant sur le bouton. La première méthode initialisera les différents fragments et ne sera appelé qu'à partir de la méthode onCreate. Les fragments apportent une solution simple et performant pour modifier dynamiquement l'interface de nos écrans. DynamicActivity. A partir de la méthode public void onCreate(Bundle savedInstanceState). J'entends par là que rien ne change pendant son exécution. Je pars du principe que la création d'un fragment est quelque chose d'acquis maintenant. Avant d'initialiser nos fragments.

Chaque transaction doit appeler la méthode commit() pour voir ses opérations s'effectuer.id. La valeur que vous donnez à cet attribut vous oblige à implémenter une méthode du même nom dans l'activité dans laquelle il est désérialisé.mDynamic2Fragment = new Dynamic2Fragment().anim.findFragmentByTag(Dynamic2Fragment. donner l'identifiant du layout conteneur et le fragment à remplacer. Résultat final Mais attends une seconde. C'est bien beau tout ça mais je fais comment pour appeler la méthode private void showFragment(final Fragment fragment) lorsque je clique sur mes boutons ? Mes fragments ne connaissent pas forcément l'activité précise dans lequel il se trouve.commit().replace(R.anim. dans le fichier XML d'affichage de fragment 1 et 2. Par conséquent.com .slide_in_left.mDynamic2Fragment == null) { this.setCustomAnimations(android. nous avons donné les valeurs respective goToFragment2 et goToFragment1. Son utilisation est simple.Partie 1 : Fragmenter vos projets Code : Java private void setupFragments() { final FragmentManager fm = getSupportFragmentManager(). L'un des attributs que vous pouvez donner à vos boutons est le suivant : android:onClick. // We can also animate the changing of fragment ft.TAG). On implémentera la méthode de la manière suivante : Code : Java private void showFragment(final Fragment fragment) { if (fragment == null) return. Pour ce faire. android. if (this. } this. nous implémentons notre activité de la manière suivante : Code : Java public class DynamicActivity extends FragmentActivity { www.slide_out_right). En cas contraire.R.mDynamic1Fragment == null) { this. Du coup.findFragmentByTag(Dynamic1Fragment.TAG).R.mDynamic2Fragment = (Dynamic2Fragment) fm .mDynamic1Fragment = (Dynamic1Fragment) fm .beginTransaction(). V ous n'avez pas tord mais Google a apporté une réponse à ce léger problème. if (this. this.mDynamic1Fragment = new Dynamic1Fragment(). final FragmentTransaction ft = fm. Fragment fragment). } ft.siteduzero. ft. final FragmentManager fm = getSupportFragmentManager().frameLayoutListView. } 11/79 } Remplacer les fragments La seconde méthode consistera simplement à afficher le fragment passé en paramètre sur l'écran en remplaçant le contenu du FrameLayout. aucune erreur ne sera lancée mais rien ne se passera. nous avons besoin d'une transaction sur laquelle nous allons devoir appeler la méthode public abstract FragmentTransaction replace (int containerViewId. fragment).

private Dynamic2Fragment mDynamic2Fragment. android. } } Si vous exécutez notre application. // We can also animate the changing of fragment ft.mDynamic2Fragment).slide_out_right).getStringExtra("fragment"). } public void goToFragment2(View v) { showFragment(this.mDynamic1Fragment = (Dynamic1Fragment) fm . www.mDynamic1Fragment).activity_fragment_dynamic).setCustomAnimations(android. ft. @Override protected void onCreate(Bundle savedInstanceState) { super.siteduzero.equals("Dynamic2Fragment")) { showFragment(this.equals("Dynamic1Fragment")) { showFragment(this. } this. final FragmentTransaction ft = fm. } ft.onCreate(savedInstanceState). final FragmentManager fm = getSupportFragmentManager(). setContentView(R. V ous constatez qu'en plus de pouvoir facilement de fragment. } 12/79 } private void setupFragments() { final FragmentManager fm = getSupportFragmentManager().anim. } } private void showFragment(final Fragment fragment) { if (fragment == null) return. if (this. this. lorsque vous cliquez sur l'un des boutons des fragments.mDynamic1Fragment). if (this.findFragmentByTag(Dynamic1Fragment.mDynamic1Fragment == null) { this.R.mDynamic2Fragment).findFragmentByTag(Dynamic2Fragment.mDynamic2Fragment = new Dynamic2Fragment().mDynamic2Fragment == null) { this. setupFragments().layout.frameLayoutListView. private Dynamic1Fragment mDynamic1Fragment. il est simple d'effectuer quelques animations sur le changement. fragment).beginTransaction(). public void goToFragment1(View v) { showFragment(this.Partie 1 : Fragmenter vos projets private String mFragment.mDynamic2Fragment = (Dynamic2Fragment) fm . if (mFragment.slide_in_left. le fragment courant s'animera en se déplaçant vers la droite pour laisser place à notre second fragment.TAG).TAG).commit().replace(R. } else if (mFragment.id.mDynamic1Fragment = new Dynamic1Fragment().anim.com .R. mFragment = getIntent().

Correction Code : Java www.siteduzero. c'est pourquoi je vais vous laisser réfléchir sur la question. si vous changez l'orientation de votre smartphone. je ne sais pas si vous l'avez remarqué mais. vous retournez au point initial. N'y aurait-il pas moyen de sauvegarder cette information ? V ous êtes censé savoir comment faire ce genre de chose.Partie 1 : Fragmenter vos projets 13/79 Résultat de l'exécution de l'activité DynamicActivity Retenir sa position dans les fragments Tiens. par exemple. V ous trouverez ma correction juste après.com .

mDynamic1Fragment = new Dynamic1Fragment().dynamic.Bundle. this. android. 14/79 import com.v4.app. } else if (mFragment.slide_out_right).support.onSaveInstanceState(outState).beginTransaction().onCreate(savedInstanceState).layout.setCustomAnimations(android. @Override protected void onCreate(Bundle savedInstanceState) { super. if (this.android. mFragment != null ? mFragment : ""). } } } @Override protected void onSaveInstanceState(Bundle outState) { outState.os.android.v4.TAG).R. if (savedInstanceState != null) mFragment = savedInstanceState.app.FragmentTransaction.siteduzero. } private void setupFragments() { final FragmentManager fm = getSupportFragmentManager(). else mFragment = getIntent().mDynamic2Fragment == null) { this. android. public class DynamicActivity extends FragmentActivity { private String mFragment.Fragment.mDynamic2Fragment).support. private Dynamic2Fragment mDynamic2Fragment.app. android.v4.mDynamic2Fragment = new Dynamic2Fragment().siteduzero. android.equals("Dynamic1Fragment")) { showFragment(this. } } private void showFragment(final Fragment fragment) { if (fragment == null) return.findFragmentByTag(Dynamic2Fragment. android.findFragmentByTag(Dynamic1Fragment. www.Partie 1 : Fragmenter vos projets package com.mDynamic1Fragment = (Dynamic1Fragment) fm .View.FragmentActivity. private Dynamic1Fragment mDynamic1Fragment.FragmentManager.R.getString("fragment").support.mDynamic1Fragment == null) { this.fragments. final FragmentTransaction ft = fm.app. import import import import import import android. final FragmentManager fm = getSupportFragmentManager().view.R.putString("fragment".mDynamic2Fragment = (Dynamic2Fragment) fm .slide_in_left.com . setupFragments().equals("Dynamic2Fragment")) { showFragment(this.anim.mDynamic1Fragment).v4.siteduzero. // We can also animate the changing of fragment ft. android. super.activity_fragment_dynamic).TAG).anim. setContentView(R. } this. if (this.getStringExtra("fragment").support. if (mFragment != null) { if (mFragment.

id.replace(R. } } www.commit().com .mDynamic1Fragment). fragment).siteduzero. } public void goToFragment2(View v) { showFragment(this.mDynamic2Fragment).frameLayoutListView.Partie 1 : Fragmenter vos projets ft. } ft. 15/79 public void goToFragment1(View v) { showFragment(this.

Partie 1 : Fragmenter vos projets 16/79 ListFragment Le widget ListView est sans aucun doute l'un des composants graphiques les plus utilisés dans les applications Android.com/apk/res/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" android:layout_alignParentLeft="true" android:layout_alignParentTop="true" /> <TextView android:id="@android:id/empty" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_centerHorizontal="true" android:layout_centerVertical="true" android:text="@string/text_empty" /> </RelativeLayout> www. nous allons partir du principe que les listes avec les Activity n'ont pas de secret pour vous. Si nous nous penchons sur le problème 30 secondes. Il permettra d'indiquer à Android le composant à afficher lorsqu'il y a une raison d'afficher une liste ou lorsqu'il n'y a rien dedans. V ous êtes censé savoir que vous pouvez en définir directement dans vos fichiers XML d'affichage ou via la classe ListActivity. il existe deux identifiants un peu spéciaux contenu dans @android:id. Dans ce cas là. Dans un premier temps. il vous faudra mettre votre image et votre texte dans un layout que vous identifierez par la valeur empty. Déclarer sa liste dans des fichiers XML Nous sommes partis du principe que vous saviez comment déclarer une liste à partir d'un fichier XML d'affichage. Cependant. Nous compliquerons rapidement les choses en intégrant des vues personnalisées à chaque item de nos listes. cela pourrait vous semblez curieux.android. Si nous restons simple. Il donne accès soit à list soit à empty. nous avons choisi d'afficher que du texte mais cela peut être infiniment plus complet. Utilisation simple des listes Puisque les listes sont largement utilisées dans les applications Android. Ce que vous ne savez peut-être pas. Pour nous permettre d'arriver à ce résultat. le fichier XML ressemblera à quelque chose comme ceci : Code : XML <?xml version="1.siteduzero.com . Par exemple. nous reviendrons plus en détail sur les adaptateurs que vous devez créer lorsque vous en créez un vous même. Il permet d'afficher facilement des informations l'un à la suite de l'autre verticalement avec des vues personnalisées ou non. Ce que nous allons faire consiste à déclarer une liste lorsqu'il y aura des éléments à afficher ou du texte pour indiquer à l'utilisateur que la liste est vide. c'est qu'il est possible de définir un fichier XML d'affichage avec des ListFragment. Il existe une manière simple et efficace de gérer le cycle de vie des vues qu'ils gèrent mais trop peu connue de certains développeurs. au même titre que le ViewPager ou le GridView. Bien entendu. de certaines choses pour rendre vos applications plus agréable. V ous pourriez vouloir afficher une image et du texte en dessous. Pourquoi attacher un fichier XML à une classe qui va créer automatiquement notre liste ? C'est très simple. En effet. nous allons voir comment utiliser ce composant mêlé à la puissance des fragments. nous allons nous servir des « id » que le framework Android met à disposition des développeurs. parfois méconnue. nous rendrons l'affichage de cette liste dynamique avec l'apparition de vues différentes. l'adaptation aux fragments sera un point important de ce chapitre et l'utilisation. Pour finir.0" encoding="utf-8"?> <RelativeLayout xmlns:android="http://schemas. Dans notre exemple. pour lui demander d'afficher quelque chose lorsque nous n'avons rien dans la liste.

inflate(R.ViewGroup. nous aurons accès à notre liste qu'une fois l'activité dans laquelle le fragment est hébergé sera construite. import import import import import import android.view. String[] items = getResources().LayoutInflater.android.simple_list_item_1. De la même manière que les fragments basiques. setListAdapter(aa).ArrayAdapter.com .app. public class SimpleListViewFragment extends ListFragment { public static final String TAG = "ListViewFragment".widget. notre fragment ne va pas étendre la classe Fragment mais ListFragment qui est le parfait équivalent de la classe ListActivity.fragment_listview. android. import com.android.View.layout. De la même manière qu'une ListActivity. false).layout. android. nous allons désérialiser notre fichier XML d'affichage dans sa méthode public View onCreateView(LayoutInflater inflater. android. Dans ce cas. Bundle savedInstanceState) (chose qui n'est pas obligatoire. Nous faisons toutes les manipulations destinées à la gestion de la liste dans la méthode public void onActivityCreated(Bundle savedInstanceState). Ce qui nous donne le code et le résultat suivant : Code : Java package com. il vous suffit de ne créer aucun fichier XML et de ne pas redéfinir la méthode précédemment citée). ViewGroup container.onActivityCreated(savedInstanceState).os. L'unique subtilité dans ce cas présent est la méthode à redéfinir. items).Partie 1 : Fragmenter vos projets 17/79 Création de la ListFragment A la différence du chapitre précédent. } @Override public void onActivityCreated(Bundle savedInstanceState) { super. android.siteduzero. En effet.ListFragment. ViewGroup container.getStringArray(R.R. @Override public View onCreateView(LayoutInflater inflater. container. Bundle savedInstanceState) { return inflater.siteduzero. ArrayAdapter<String> aa = new ArrayAdapter<String>(getActivity(). nous devons récupérer notre liste pour lui attacher un adaptateur (que nous ne créerons pas pour le moment).array.Bundle.R.v4.siteduzero.support. V ous pouvez ne pas vouloir afficher quelque chose lorsque la liste est vide.lists.view.list_examples). android. } } www.view. android.

Android vous fournit déjà quelques ombrages que vous www. En général. Je vous rassure.Partie 1 : Fragmenter vos projets 18/79 Résultat de l'exécution d'une liste simple Intégrer une vue personnalisée Une liste remplie de texte est plutôt rare dans les applications Android. chaque item est une vue que vous avez vous même confectionnée pour afficher de l'information.siteduzero. je vous redirige vers le tutoriel de Apollidore !). Je vais vous expliquer ma façon de faire pour que vous puissiez mettre en place une jolie architecture à la fois souple et puissante. vous n'allez pas devoir jouer avec 9-patch. nous allons faire quelque chose de très simple : un petit bloc avec un ombrage qui contient du texte.com . Créer une vue personnalisée J'ose quand même espérer que vous savez comment vous y prendre pour créer une vue (sinon. Nous partons toujours du principe que vous savez faire ce genre de chose mais cela sera un peu différent cette fois. Pour notre exemple.

Ainsi.Context.widget. } public CustomListViewView(Context context) { super(context).AttributeSet. } private void init() { inflate(getContext(). } public void bind(int text) { www. Notre fichier XML destiné à devenir notre vue ressemblera donc à quelque chose comme ceci : Code : XML <?xml version="1.util.Partie 1 : Fragmenter vos projets pouvez utiliser comme bon vous semble.android.content. defStyle). qui va désérialiser notre fichier XML d'affichage.textView). R.siteduzero. AttributeSet attrs) { super(context. redéfiniera simplement les constructeurs nécessaires pour appeler la super classe (LinearLayout) et offrira une méthode à notre adaptateur pour attacher du texte à notre TextView.LinearLayout.widget.com . android. notre classe Java.lists. } public CustomListViewView(Context context. int defStyle) { super(context. public CustomListViewView(Context context.android.view_custom_listview.siteduzero.siteduzero. AttributeSet attrs.TextView.android. this). init(). nous obtenons le code suivant : Code : Java package com.id. mTextView = (TextView) findViewById(R. init(). public class CustomListViewView extends LinearLayout { private TextView mTextView. import import import import android. import com. android.layout.R. init(). android. attrs). attrs.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.com/apk/res/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> 19/79 Pour rester simple.

view. Il récupèrera au plus possible les vues déjà construites et attachera le texte correspondant à la ligne en cours le bon texte présent dans notre liste. public CustomListViewAdapter(Context context) { mContext = context.BaseAdapter. nous le faisons if (convertView == null) { v = new CustomListViewView(mContext). en plus de ça. nous le faisons else { www. Jusque là. ViewGroup parent) ne se contentera pas de construire les vues. private Context mContext.siteduzero. } @Override public Integer getItem(int position) { return mModel. Il héritera de la classe BaseAdapter et offrira une méthode pour attacher les textes à nos vues (vous l'aurez compris.size().lists. } @Override public View getView(int position.com . la création d'un adaptateur prend tout son sens. 20/79 } Créer son adaptateur Maintenant que nous avons une vue personnalisée.ArrayList. } // Notre vue peut être récupérée.util. import import import import android. android.List.ViewGroup. je vous invite à consulter ma solution (que vous retrouverez cacher ci-dessous) pour vous corrigez. View convertView. ViewGroup parent) { CustomListViewView v = null.content.util. Nous retiendrons donc une liste qui sera utilisé par les méthodes que nous avons été forcé de redéfinir. C'est pourquoi je vous laisse y réfléchir (et je vous conseil de le faire pour bien progresser). rien de bien nouveau.Partie 1 : Fragmenter vos projets } mTextView. notre méthode public View getView(int position.siteduzero. Secret (cliquez pour afficher) Code : Java package com. Après quoi. android. Mais nous allons faire ça proprement. } @Override public long getItemId(int position) { return position.get(position).view.View.setText(getResources(). Cependant. android. // Notre vue n'a pas encore été construite. } @Override public int getCount() { return mModel. View convertView. public class CustomListViewAdapter extends BaseAdapter { private List<Integer> mModel = new ArrayList<Integer>(). V ous devriez être capable de concevoir cet adaptateur seul.widget. c'est notre fragment qui se chargera de fournir tous les textes qui s'afficheront sur nos vues). import java.Context.android. import java.getString(text)).

} v. V ous devriez alors avoir le même résultat que moi avec une belle fluidité puisque notre adaptateur est optimisé au niveau de la gestion de la mémoire.siteduzero. } Notre fragment sera exactement identique au précédent sous-chapitre à l'exception près que nous n'utilisons plus ArrayAdapter mais notre propre adaptateur (CustomListViewAdapter dans mon cas).Partie 1 : Fragmenter vos projets v = (CustomListViewView) convertView.com .bind(getItem(position)). return v. www. 21/79 } } public void bind(List<Integer> model) { mModel = model.

com . nous allons voir une dernière chose encore plus importante qui clôturera ce chapitre : rajouter du dynamisme dans sa liste. Pour cet exemple. Android a pensé à ce cas et nous permet facilement d'afficher plusieurs vues personnalisées en fonction de nos désirs. Modification de l'adaptateur Le but de notre nouveau adaptateur est de construire plusieurs types de vues avec une seule méthode (je vous laisse deviner laquelle ).siteduzero.Partie 1 : Fragmenter vos projets 22/79 Résultat de l'exécution d'une liste avec une vue personnalisée Vers des listes dynamiques Maintenant que nous avons appris l'intégration de vues personnalisées dans nos listes. V ous vous rendrez vite compte que nous avons rarement envie d'afficher toujours la même chose sous la même forme. nous construisons deux vues que je nommerai DynamicHeaderListViewView et www.

La seconde méthode est identique à la méthode vue au souschapitre précédent. Cela se fait naturellement dans les méthodes d'attachement. elle prendra une liste de chaînes de caractères.size().siteduzero. private List<Integer> mTypes = new ArrayList<Integer>(). Je vous laisse le bon soin de créer ses vues comme nous l'avons fait précédemment. Nous étendrons toujours BaseAdapter mais nous allons redéfinir deux méthodes supplémentaires qui sont facultatives (j'entends par là qu'il n'est pas nécessaire de toujours les redéfinir.add(TYPE_BODY). nous ajouterons au fur et à mesure les types dans la liste des types. Cela ne devrait pas vous posez de problème. Le véritable changement se situe au niveau de notre adaptateur. } @Override public int getItemViewType(int position) { return mTypes.get(position). i++) { mTypes. private static final int TYPE_MAX = 2. nous aurons besoin de constantes représentants les types de vues et une liste faisant correspondre chaque ligne de la liste avec son type associé. } public void bindBody(List<Integer> model) { mModelBody = model. La première affiche une image à gauche et du texte à droite. } } } www. Si nous continuons notre exemple.add(TYPE_HEADER).Partie 1 : Fragmenter vos projets 23/79 DynamicBodyListViewView. for (int i = 0.com . mTypes. private static final int TYPE_BODY = 1. A quoi servent ces méthodes ? La première nous demande combien de vues différentes seront présentes dans notre liste. } } // Autres méthodes La mise en place est aussi simple que cela. Nous en aurons deux : l'une pour l'en-tête de la liste et une seconde pour le corps de la liste. Pour chacune de ces méthodes. la seconde affiche simplement du texte (comme la vue pour le sous-chapitre précédent). Il va maintenant falloir remplir la liste des types avec les lignes de la liste. Cela nous dera quelque chose comme ceci : Code : Java public class DynamicListViewAdapter extends BaseAdapter { // Autres attributs et méthodes public void bindHeader(DynamicListViewModel model) { mModelHeader = model. nous aurons quelque chose qui ressemble à ceci : Code : Java public class DynamicListViewAdapter extends BaseAdapter { private static final int TYPE_HEADER = 0. Pour pouvoir compléter ces méthodes. La seconde nous demande le type de vues pour la position courante dans la liste. i < model. La première méthode prend en paramètre un modèle qui se trouve être une classe confectionné par mes soins avec seulement 2 attributs représentant une image et un texte. avec le « header » et le « body ». // Autres attributs @Override public int getViewTypeCount() { return TYPE_MAX. seulement quand cela est nécessaire) : public int getViewTypeCount() et public int getItemViewType(int position).

siteduzero. ViewGroup parent) sur laquelle je vais vous laisser cogiter. import java.size().BaseAdapter.view.content. } } // Autres méthodes Pour finir. nous modifions nos méthodes de la manière suivante : Code : Java public class DynamicListViewAdapter extends BaseAdapter { // Autres attributs et méthodes @Override public int getCount() { if (mModelHeader == null) return mModelBody. import java. View convertView. import import import import android.view.get(position .util.size(). return 1 + mModelBody. ma solution se trouve cachée ci-dessous. Ainsi. Il faut donc prévoir qu'un en-tête (ou pas) soit placé quelque part dans notre liste.Partie 1 : Fragmenter vos projets 24/79 Nous avons aussi besoin de retoucher un peu nos anciennes méthodes.1).siteduzero. Si vous avez bien compris l'exemple précédent avec une seule vue personnalisée pour toute la liste. android. } @Override public Object getItem(int position) { int type = getItemViewType(position). La taille de notre liste ne correspond plus à la taille de notre liste de données. Bien sûr.List.util. android. android. } @Override www.ArrayList. } @Override public int getViewTypeCount() { return TYPE_MAX. private DynamicListViewModel mModelHeader = null.ViewGroup. public DynamicListViewAdapter(Context context) { mContext = context. private List<Integer> mModelBody = new ArrayList<Integer>().View. return type == TYPE_HEADER ? mModelHeader : mModelBody . V ous disposez de toutes les méthodes nécessaires pour mener à bien sa confection.widget. public class DynamicListViewAdapter extends BaseAdapter { private static final int TYPE_HEADER = 0.android.Context.com . nous avons notre méthode public View getView(int position. Secret (cliquez pour afficher) Code : Java package com. private static final int TYPE_MAX = 2. vous ne devriez pas avoir de mal à en faire de même pour plusieurs vues personnalisées. private Context mContext. private List<Integer> mTypes = new ArrayList<Integer>(). Pensez simplement que les méthodes que nous avons redéfinies ne sont sans doute pas là pour rien.lists. private static final int TYPE_BODY = 1.

int type = getItemViewType(position).bind(model1. break. ViewGroup parent) { View v = null. } } switch (type) { case TYPE_HEADER: DynamicListViewModel model1 = (DynamicListViewModel) getItem(position). return 1 + mModelBody.size().get(position . ((DynamicHeaderListViewView) v). } @Override public long getItemId(int position) { return position.siteduzero. break. break.Partie 1 : Fragmenter vos projets public int getItemViewType(int position) { return mTypes. } } else { switch (type) { case TYPE_HEADER: v = (DynamicHeaderListViewView) convertView. } www. break.get(position). model1. mTypes. } @Override public Object getItem(int position) { int type = getItemViewType(position).1).com . return type == TYPE_HEADER ? mModelHeader : mModelBody . case TYPE_BODY: Integer model2 = (Integer) getItem(position). case TYPE_BODY: v = new DynamicBodyListViewView(mContext). } } return v.getTextRessource()).size(). View convertView. 25/79 public void bindHeader(DynamicListViewModel model) { mModelHeader = model.bind(model2). break. break. } @Override public View getView(int position. } @Override public int getCount() { if (mModelHeader == null) return mModelBody. case TYPE_BODY: v = (DynamicBodyListViewView) convertView. if (convertView == null) { switch (type) { case TYPE_HEADER: v = new DynamicHeaderListViewView(mContext).add(TYPE_HEADER).getImageRessource(). ((DynamicBodyListViewView) v).

com . i++) { mTypes.add(TYPE_BODY).size().siteduzero. } } 26/79 } Il n'en faut pas plus pour concevoir une liste dynamique.Partie 1 : Fragmenter vos projets public void bindBody(List<Integer> model) { mModelBody = model. i < model. en n'oubliant pas d'appeler les méthodes d'attachement pour remplir votre liste et vous devriez obtenir un résultat similaire au mien : www. for (int i = 0. Il vous suffit ensuite d'intégrer ce nouvel adaptateur à votre activité.

com .siteduzero.Partie 1 : Fragmenter vos projets 27/79 Résultat de l'exécution d'une liste avec plusieurs vues personnalisées www.

Pour ce faire. les paramètres auront toujours le même design. Paramétriser son application Paramétriser son application par les préférences du système n'est pas obligatoire. Android met à disposition des développeurs des outils permettant de paramétriser facilement son application.android. android:summary pour donner des précisions supplémentaires sur la préférence et android:defaultValue pour donner une valeur par défaut à la préférence. android:title pour donner un nom à la préférence. V ous devez définir une liste de valeur dans lequel l'utilisateur pourra faire son choix. le Bluetooth. Cette préférence change par une autre préférence. etc. la luminosité. ListPreference est un peu spécial. Pour vous aidez à mieux comprendre. Peu importe le lanceur d'application. Raison pour laquelle vous devez déclarer l'attribut android:dependency qui contiendra. Explications. le NFC. En quoi consiste cette paramétrisation ? C'est simple.siteduzero. c'est quelque chose de très efficace et surtout qui ne déstabilisera pas l'utilisateur Android. c'est juste l'affichage normal sur les terminaux Android). deux choix s'offrent à vous. gérer le son. nous ne l'utiliserons pas pour ce chapitre. Soit vous déclarez des PreferenceCategory. Cela va vous facilitez la vie mais je vous met en garde sur une petite chose. Les préférences ont également été intégrées dans cette bibliothèque mais n'est pas très performante (ou du moins. L'utilisera saura directement comment l'utiliser et pour vous. c'est simple. Code : XML <?xml version="1. Il faudra juste se renseigner un peu sur la façon de s'y prendre. dans ce cas. ci-dessous se trouve un exemple complet pour définir ses préférences reprenant toutes les notions que nous avons vu juste avant. EditTextPreference pour sauvegarder une chaîne de caractères. A partir de là. cela sera du temps de développement en moins. Mais sachez qu'il est possible de l'utiliser. la clé d'une autre préférence. Avant tout. Soit vous déclarez directement des préférences au risque d'être brouillon si vous en avez beaucoup. PreferenceCategory doit contenir les attributs android:key et android:title pour pouvoir l'identifier et lui donner un titre. On retrouvera : CheckBoxPreference et SwitchPreference pour retenir un boolean en cochant la case créée ou non. Parce que le code est quand même assez différent et pour ne pas être limité. Preference qui est une valeur non éditable par l'utilisateur.com/apk/res/android" > www. Toutes ces choses sont « standardisées » (je mets cela entre guillemet parce que ce n'est pas vraiment le cas. Nous utilisons depuis le début de ce tutoriel la bibliothèque de compatibilité développé par Google. Il peut également RingtonePreference pour saisir une sonnerie à partir de votre terminal ou d'une application qui vous permet d'en télécharger.0" encoding="utf-8"?> <PreferenceScreen xmlns:android="http://schemas. Il s'agit ni plus ni moins que des données partagées dans toute l'application (que vous avez déjà certainement utilisé) mais intégrer dans une conception toute fait.com . Définir ses préférences La déclaration des composants d'un écran de préférences est très simple et se fait en grande partie à partir d'un fichier XML. comme valeur. pas à une grande échelle). Toutes ces choses sont vraies et en même temps. le fond d'écran ou les widgets que vous placerez sur vos bureaux. vous pourrez regrouper des préférences. notez que vous devrez toujours donner une valeur aux attributs suivants : android:key pour pouvoir identifier les préférences et en récupérer sa valeur par la mémoire partagée. Il faut donner une valeur pour deux nouveaux attributs : android:entries pour donner un tableau de valeur qui sera affiché à l'utilisateur et android:entryValues pour afficher le code des valeurs de chaque ligne de ce tableau. V otre application n'a peut-être pas besoin de sauvegarder quelque chose ou l'affichage des préférences d'Android ne vous conviendra pas dans le design de votre application. Nous confectionnerons des fragments (ou des activités) qui auront comme seul objectif l'affichage des paramètres de la même manière que ceux de votre smartphone. Un utilisateur Android a l'habitude de se rendre dans les paramètres de son téléphone pour activer le Wi-Fi. Il pourra en être de même pour votre application.Partie 1 : Fragmenter vos projets 28/79 PreferenceFragment Depuis la version 3. Ce fichier doit se trouver dans le dossier xml des ressources du projet et doit avoir comme racine un noeud de type PreferenceScreen. Il existe plusieurs types de préférence.

com .Partie 1 : Fragmenter vos projets <PreferenceCategory android:key="pref_key_category_1" android:title="@string/title_category_1" > <CheckBoxPreference android:defaultValue="false" android:key="pref_key_pref_1" android:summary="@string/summary_pref_1" android:title="@string/title_pref_1" /> <Preference android:dependency="pref_key_pref_1" android:key="pref_key_pref_2" android:summary="@string/summary_pref_2" android:title="@string/title_pref_2" /> <SwitchPreference android:key="pref_key_pref_3" android:summary="@string/summary_pref_3" android:switchTextOff="@string/switch_off_pref_3" android:switchTextOn="@string/switch_on_pref_3" android:title="@string/title_pref_3" /> </PreferenceCategory> <PreferenceCategory android:key="pref_key_category_2" android:title="@string/title_category_2" > <EditTextPreference android:key="pref_key_pref_4" android:summary="@string/summary_pref_4" android:title="@string/title_pref_4" /> <ListPreference android:entries="@array/list_pref_5" android:entryValues="@array/list_pref_5" android:key="pref_key_pref_5" android:summary="@string/summary_pref_5" android:title="@string/title_pref_5" /> <RingtonePreference android:key="pref_key_pref_6" android:ringtoneType="ringtone" android:summary="@string/summary_pref_6" android:title="@string/title_pref_6" /> </PreferenceCategory> </PreferenceScreen> 29/79 www.siteduzero.

Cette méthode prends une ressource en paramètre correspondant aux préférences que vous voulez liées. En toute simplicité.com . PreferenceFragment.Partie 1 : Fragmenter vos projets 30/79 Affichage des paramètres Créer son fragment avec son activité Il existe un fragment spécialement prévu pour accueillir les préférences de votre application. Il est alors enfantin de lui attacher notre fichier xml par un simple appel de méthode dans la méthode public void onCreate(Bundle savedInstanceState) : public void addPreferencesFromResource (int preferencesResId). notre fragment ressemblera à : Code : Java www.siteduzero.

En fait.preference.android.settings.onCreate(savedInstanceState). www. Une petite application aura rarement besoin d'utiliser le concept que je vais vous enseigner maintenant mais c'est une bonne chose à connaitre parce que vous n'aurez peut-être pas toujours des petites applications à développer.os. public class MyPreferenceFragment extends PreferenceFragment { public static final String TAG = "MyPreferenceFragment". import com.siteduzero.Bundle. L'écran des paramètres de votre smartphone utilise les en-têtes simplement pour structurer la très grande quantité de chose à pouvoir paramétrer. } addPreferencesFromResource(R.android.R. 31/79 } Affiner ses paramètres avec les en-têtes Tout comme les catégories.PreferenceFragment.siteduzero.siteduzero. @Override public void onCreate(Bundle savedInstanceState) { super. les en-têtes ont pour objectif de rassembler des préférences et de les structurer mais à plus grande échelle.xml.preferences).com . vous avez déjà vu plusieurs fois des en-têtes. import android.Partie 1 : Fragmenter vos projets package com. import android.

l'essentiel se passe dans un fichier XML qui se trouve toujours dans le dossier xml des ressources du projet et qui possède comme racine preference-headers. Je vous répondrai à cela que c'est quelque chose de rapide. c'est tout aussi simple que de vouloir les rajouter dès le début du développement de votre application.Partie 1 : Fragmenter vos projets 32/79 Affichage des paramètres du smartphone Définir les en-têtes Je vous soupçonne de penser que définir tous ces en-têtes est quelque chose de long. Après cela.com .siteduzero. il suffit de déclarer autant d'élèment header que vous voulez d'en-tête. Si vous avez déjà des écrans de préférence et que vous voulez rajouter des en-têtes en cours de développement. compliqué et fastidieux. Tout comme la définition des préférences. simple et enfantin. Celui-ci peut et doit déclarer remplir certains www.

com .Partie 1 : Fragmenter vos projets attributs : android:fragment pour donner le chemin vers le fragment représentant l'écran de préférence. android:title pour donner un titre à l'en-tête. android:icon pour ajouter une icone à gauche de la préférence (facultatif). 33/79 Résultat de l'exécution des en-têtes Attacher à une activité Les en-têtes sont attachés à des activités qui héritent de PreferenceActivity mais elle ne redéfinit pas la méthode www.siteduzero. Un exemple simple exemple concret se trouve ci-dessous avec son résultat à l'exécution de l'application. android:summary pour ajouter des précisions sur l'en-tête.

"Nothing").setText("" + pref5). String pref2 = prefs.getDefaultSharedPreferences(this). false). V ous vous souvenez de ces managers dans le tutoriel de Apollidore où vous devez appeler la méthode public abstract Object getSystemService(String name) pour récupérer le manager dont vous avez besoin pour faire des manipulations sur une certaine fonctionnalité ? Et bien.header_preferences.com .setText("" + pref2). mTextViewPref6. nous arrivons au code suivant : Code : Java package com. mTextViewPref1. String pref5 = prefs.settings.preference. String pref6 = prefs. vous aurez besoin d'appeler la méthode static public static SharedPreferences getDefaultSharedPreferences(Context context) qui renvoi un SharedPreferences (chose que vous devrez connaître). boolean pref3 = prefs. List<PreferenceActivity. Un exemple très simple ci-dessous avec son résultat : Code : Java SharedPreferences prefs = PreferenceManager. A la place.util. import com. public class SettingsActivity extends PreferenceActivity { @Override public void onBuildHeaders(List<Header> target) { loadHeadersFromResource(R. target). import android.xml. ce n'est pas la même chose cette fois-ci ! En fait.siteduzero.getBoolean("pref_key_pref_3". "Nothing"). Android nous fournit un manager. tout cela perdrait de son intérêt. false). c'est encore plus simple.getString("pref_key_pref_2". vous pourrez appeler des getters pour récupérer les valeurs de vos préférences à partir des clés que vous avez donné.siteduzero. mTextViewPref3.setText("" + pref6).getString("pref_key_pref_6".siteduzero. mTextViewPref4.getBoolean("pref_key_pref_1".getString("pref_key_pref_4".Partie 1 : Fragmenter vos projets 34/79 public void onCreate(Bundle savedInstanceState) comme le ferait toutes les autres activités. "Nothing"). malheureusement pour vous. String pref4 = prefs.getString("pref_key_pref_5".setText("" + pref4). } } Lire les préférences Nous avons mis en place nos préférences mais si nous n'utilisons pas les valeurs que nous paramétrisons.R. mTextViewPref2. Cette méthode s'attend à recevoir l'identifiant de la ressource des déclarations de vos en-têtes et la cible donné en paramètre à votre méthode.PreferenceActivity. mTextViewPref5. "Nothing").setText("" + pref1).android. nous devrons redéfinir la méthode public void onBuildHeaders(List<Header> target) pour y appeler la méthode suivante : public void loadHeadersFromResource (int resid. Le manager est PreferenceManager et pour l'initialiser. En toute simplicité.android. www.setText("" + pref3). import java.List.Header> target). A partir de là. boolean pref1 = prefs.

siteduzero.Partie 1 : Fragmenter vos projets 35/79 Affichage des valeurs des paramètres www.com .

dialog.DialogFragment.layout. Pour ce faire. C'est une pratique qui vous permettra de concevoir des boites de dialogue infiniment plus complexe et plus puissante que vos anciennes boites de dialogue.R. title). Cette classe fournit tous les contrôles nécessaires pour créer la boite et gérer son apparence.siteduzero.v4. Bundle savedInstanceState) : Pour désérialiser le fichier XML représentant notre fragment et pour donner un titre à notre boite de dialogue (ce dernier étant optionnel).com . Ce composant nous permettra d'afficher une boite de dialogue à l'utilisateur de manière beaucoup plus souple et plus complet que vous auriez pu le faire avec les anciens composants des versions inférieurs à la 3.siteduzero.LayoutInflater. nous allons procéder comme à chaque création d'un type de fragment . nous allons redéfinir et définir les 2 méthodes suivantes : public View onCreateView(LayoutInflater inflater.view. Pour commencer. Bundle args = new Bundle(). android.View. Bundle savedInstanceState) { View v = inflater. Button button = (Button) v.view.view.Partie 1 : Fragmenter vos projets 36/79 DialogFragment Nous allons aborder la dernière notion utilisant les fragments à partir de la version 3 d'Android. android.android.ViewGroup. ViewGroup container.fragment_dialog.showDialogType(DialogActivity.Button.view. } }).os. args. dialog.siteduzero. return dialog.app.setOnClickListener(new OnClickListener() { public void onClick(View v) { ((DialogActivity) getActivity()) . les DialogFragment. android.android.buttonShow). www. public static MyDialogFragment newInstance() : Je reviendrais dans la seconde partie de ce tutoriel sur ce type de méthode mais sachez qu'elle nous permet d'encapsuler la création de notre fragment et d'en connaitre des potentielles données.id. c'est-à-dire que nous allons étendre notre classe à DialogFragment et redéfinir un certains nombre de méthodes utiles à l'intégration de notre fragment dans la boite et à sa gestion.widget.inflate(R. container.support.setArguments(args). import com. Ne vous tracassez pas la tête avec ça maintenant. Nous obtenons donc le résultat suivant : Code : Java package com. } @Override public View onCreateView(LayoutInflater inflater. android.getInt("title")). android.putInt("title". getDialog().Bundle. ViewGroup container. android. false). public class MyDialogFragment extends DialogFragment { public static MyDialogFragment newInstance(int title) { MyDialogFragment dialog = new MyDialogFragment(). button. Créer un DIalogFragment V ous avez sans doute déjà utiliser des AlertDialog ou des Dialog (surtout si vous avez lu le tutoriel d'Applidore).OnClickListener.setTitle(getArguments().View. Chose que nous apprendrons à faire tout au long de ce chapitre ainsi que l'intégration de builder pour un autre type de boite. import import import import import import import android. L'idée est de ré-utiliser ce type de composant mais en lui attachant des fragments.findViewById(R. vous comprendrez bien assez tôt son utilité. DialogFragment servira de conteneur à notre fragment pour le transformer en boite de dialogue et ainsi fournir le style et la structure de la boite.TYPE_ALERT_DIALOG).

le résultat final intégré dans une FragmentActivity donnera le résultat suivant : Résultat de l'exécution des boîtes de dialogue DialogFragment Créer un AlertDialog V ous êtes censé savoir comment créer un AlertDialog.com . c'est vraiment très semblable au www.siteduzero. 37/79 } Chez moi (vous n'aurez pas le même résultat si le fichier XML est différent). En fait.Partie 1 : Fragmenter vos projets } return v. Je ne rentrerais 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.

siteduzero.setNegativeButton(R.create(). Bien entendu.R. ViewGroup container. Ainsi.OnClickListener() { public void onClick(DialogInterface dialog.setPositiveButton(R. int whichButton) { ((DialogActivity) getActivity()) .com . Bundle savedInstanceState) mais public Dialog onCreateDialog(Bundle savedInstanceState). La redéfinition de la méthode donnera quelque chose comme : Code : Java @Override public Dialog onCreateDialog(Bundle savedInstanceState) { int title = getArguments().string. return new AlertDialog.doPositiveClick(). new DialogInterface. ce n'est pas exactement la même chose.ic_dialog_alert) . int whichButton) { ((DialogActivity) getActivity()) . Nous n'allons pas devoir redéfinir la méthode public View onCreateView(LayoutInflater inflater.doNegativeClick().setTitle(title) . } }) .alert_dialog_cancel.setIcon(android. new DialogInterface.getInt("title").Partie 1 : Fragmenter vos projets 38/79 DialogFragment et vous devrez avoir une petite idée de la manière de s'y prendre avec les connaissances que je viens de vous enseigner et vos connaissances précédentes sur sa simple création dans une Activity.drawable.Builder(getActivity()) .string. nous obtenons le résultat suivant : www. A partir de là.alert_dialog_ok. } }). il nous suffit de retourner une AlertDialog avec l'aide d'un builder.OnClickListener() { public void onClick(DialogInterface dialog. } N'oubliez pas d'implémenter la méthode static pour créer une instance comme nous l'avons fait avec DialogFragment.

V ous comprendrez que ce n'est vraiment pas compliqué puisqu'il s'agit d'un fragment comme un autre. nous allons rapidement voir comment intégrer nos boites de dialogue dans une activité. Sachez simplement que vous devez implémenter un certain nombre de méthode : public void doNegativeClick() : Appelé lorsqu'on clique sur le bouton négatif de l' AlertDialog. cela ne devrait pas vous prendre trop longtemps.Partie 1 : Fragmenter vos projets 39/79 Résultat de l'exécution des boîtes de dialogue AlertDialog Afficher une boite de dialogue Dernière petite chose avant de terminer notre chapitre. C'est la raison pour laquelle je vais vous laisser réfléchir à la question. public void doPositiveClick() : Appelé lorsqu'on clique sur le bouton positif de l'AlertDialog. Si vous avez bien compris la matière que je vous ai enseigné dans les chapitres précédents.siteduzero.com . public void showAlertDialog(View v) : Appelé au clique de l'utilisateur sur le bouton de notre activité www.

dialog.support. android. switch (type) { case TYPE_DIALOG_FRAGMENT: newFragment = MyDialogFragment . } protected void showDialogType(int type) { FragmentTransaction ft = getSupportFragmentManager().string.support.alert. DialogFragment newFragment = null.siteduzero.dialog. android. } public void doPositiveClick() { // TODO Do something www.findFragmentByTag("dialog").support.v4.siteduzero.layout.FragmentActivity. android.siteduzero.title_fragment_dialog). } newFragment.newInstance(R.v4. protected void showDialogType(int type) : Pour switcher dynamiquement entre les différentes boîtes de dialogue. "dialog"). Correction Code : Java package com.Bundle.title_fragment_dialog_alert). android.siteduzero. } public void showDialogFragment(View v) { showDialogType(TYPE_DIALOG_FRAGMENT).R. case TYPE_ALERT_DIALOG: newFragment = MyAlertDialog .activity_dialog). import com. import import import import import import android.v4.remove(prev). Je vous laisse à vos lignes de codes.app.os. } public void showAlertDialog(View v) { showDialogType(TYPE_ALERT_DIALOG).android.string. public class DialogActivity extends FragmentActivity { public static final int TYPE_DIALOG_FRAGMENT = 1. setContentView(R.onCreate(savedInstanceState).app. import com.MyAlertDialog. break.app.newInstance(R.support. Fragment prev = getSupportFragmentManager().app.view.android.android.Fragment.show(ft.Partie 1 : Fragmenter vos projets 40/79 destiné à l'affichage de l'AlertDialog. public void showDialogFragment(View v) : Appelé au clique de l'utilisateur sur le bouton de notre activité destiné à l'affichage de DialogFragment. } ft. V ous trouverez ma solution et son résultat à la suite de ce chapitre.com .View. @Override protected void onCreate(Bundle savedInstanceState) { super. android. break.beginTransaction().DialogFragment.FragmentTransaction. if (prev != null) { ft.v4.addToBackStack(null). public static final int TYPE_ALERT_DIALOG = 2.

siteduzero.Partie 1 : Fragmenter vos projets } public void doNegativeClick() { // TODO Do something } 41/79 } Résultat de l'exécution de l'activité pour afficher nos boîtes de dialogue www.com .

collapseActionView : Nous reviendrons sur cet attribut un peu plus tard dans ce chapitre. ne lui demander pas l'impossible. par exemple : never|always. le système détectera automatiquement que vous lancez votre application sur un système avec une version 3 ou supérieur d'Android et l'intègrera par défaut.widget.com . il nous faudra que quelques modifications à faire dans le fichier XML. ils sont remplacés par des boutons tactiles en bas de l'écran et le menu est directement intégré dans le haut de l'écran dans les applications. comme le NFC. Avec la venue de cette nouvelle version.android. Suite à cela. une première ébauche pour quelque chose d'encore plus gros. Google a développé la version 4 qui a pris le meilleur des deux mondes et qui en a fait un seul système à la fois compatible tablette et smartphone. Bien entendu. c'est tout ! En effet. Cependant.x coexistait comme alternative pour smartphone. A la place. vous aurez compris que la version 3 est un réel tournant dans le développement d'application Android. nous pouvons presque affirmer cette généralité : les terminaux bas de prix possèdent des touches physiques parce qu'ils tournent sur Android 2. nous allons rajouter une notion très importante dans ces nouveaux menus. intégrer un menu dans une barre d'action est extrêmement simple.0" encoding="utf-8"?> <menu xmlns:android="http://schemas. je préfère cette méthode. En effet.SearchView" android:icon="@android:drawable/ic_menu_search" android:showAsAction="always" android:title="@string/menu_search"/> <item android:id="@+id/menu_add" android:icon="@android:drawable/ic_menu_add" android:showAsAction="ifRoom|withText" android:title="@string/menu_add"/> <item android:id="@+id/menu_save" android:icon="@android:drawable/ic_menu_save" android:showAsAction="ifRoom|withText" android:title="@string/menu_save"/> www. Cet attribut peut prendre une ou plusieurs valeurs parmi cette liste : ifRoom : Affichera l'item dans la barre d'action uniquement s'il y a encore de la place.siteduzero. tout ce que je vous ai enseigné jusqu'à présent n'aura pas servis à rien) mais elle a ajoutée une tonne de nouvelles choses. La barre d'action des applications La barre d'action d'une application est accessible qu'à partir de la version 3 d'Android.com/apk/res/android" > <item android:id="@+id/menu_search" android:actionViewClass="android. V ous devez savoir qu'il est possible de sélectionner plusieurs des valeurs grâce au pipeline « | ». un nouvel attribut est utilisable dans ces menus android:showAsAction.3 et inférieur et les terminaux haut de gamme tournant sur Android 3 et plus ne possèdent plus aucun bouton physique sur la face avant (ou très peu). C'est vrai que cette version a apporté énormément au système mais ce n'était qu'un début. Google tente de diminuer les boutons physiques sur les terminaux le plus possible. que cela soit en terme d'architecture logicielle ou d'ergonomie. Comme vous êtes censé savoir comment créer des menus (sinon. Cette version était destinée uniquement aux tablettes et la version 2. son affichage. withText : Affichera le texte du menu si le téléphone se trouve en mode paysage. Sur le marché actuel. Certaines seront déjà disponibles à partir de la version 3 mais d'autres.Partie 2 : Des nouveaux composants 42/79 Partie 2 : Des nouveaux composants Après ce premier chapitre sur les fragments. never : N'affichera jamais l'item dans la barre d'action. always : Affichera l'item dans la barre d'action dans tous les cas. un titre et une icone. Elle se caractérise par l'affichage d'un bandeau en haut de l'écran regroupant un certain nombre d'informations et pour y intégrer les menus. C'est plutôt pratique ! V oici ce que nous allons faire : Nous allons créer un menu avec 4 items qui auront un identifiant. je vous renvoie sur le tutoriel d'Apollidore sur les gestion des menus). C'est un choix auquel on adhère ou non. l'utilisation des fragments est resté inchangé (ouf. Un exemple d'utilisation tout simple de nos 4 items se trouve à la suite : Code : XML <?xml version="1. Personnellement. En fait. sont des exclusivités sur les terminaux Android 4 et plus. Intégrer un menu J'ai une bonne nouvelle pour vous.

Ceci nous donnera alors le résultat suivant : www.siteduzero. s'il y a de la place et avec son texte le menu d'ajout et de sauvegarde et nous n'afficherons jamais le redimensionnement dans la barre d'action mais dans un menu à part qui s'affichera à l'extrème droite de la barre. rien ne change ! V ous continuez à redéfinir la méthode public boolean onCreateOptionsMenu(Menu menu) pour désérialiser votre menu et public boolean onOptionsItemSelected(MenuItem item) pour réagir au clique sur l'un ou l'autre item du menu. Du côté Java.com .Partie 2 : Des nouveaux composants <item android:id="@+id/menu_crop" android:icon="@android:drawable/ic_menu_crop" android:showAsAction="never" android:title="@string/menu_crop"/> </menu> 43/79 Nous afficherons donc dans tous les cas le menu de recherche.

V ous devriez avoir les compétences pour le faire tout seul. si vous êtes curieux à ce sujet. Google a mis en place un site accessible via ce lien qui vous permettra de générer des styles tout faits. Barre de recherche www.Partie 2 : Des nouveaux composants 44/79 Affichage des items du menu Comme vous pouvez le constater.siteduzero. Possibilités avancées La barre d'action. Cela prendrait un nouveau chapitre entier à ce sujet et le design n'est pas le but de ce tutoriel. Android affiche notre item de recherche et d'ajout mais comme il n'y a plus de place pour la sauvegarde. il le place dans le sous menu accesible à l'extrème droite de la barre.com . Il suffit alors de les intégrer à vos projets. c'est sympa mais il est possible d'aller encore plus loin dans son utilisation. Cependant. Nous ne verrons pas comment customiser cette barre.

Du côté XML.id. il est fort utile de connaitre un listener qui s'attache à ce type de vue OnQueryTextListener. nous devons récupérer notre item lors de la désérialisation de notre menu et lui attacher notre listener via sa méthode public void setOnQueryTextListener (SearchView. return true.Partie 2 : Des nouveaux composants 45/79 Dans un premier temps. Il nous permet de spécifier un layout ou un widget à utiliser. destiné à effectuer une recherche. nous allons voir comment rendre notre item.widget. nous obtenons : Code : XML <item android:id="@+id/menu_search" android:actionViewClass="android.OnQueryTextListener listener). mSearchView. nous aurons besoin d'effectuer des changements à la fois du côté de l'XML et du côté Java.siteduzero. mSearchView = (SearchView) itemSearch.setOnQueryTextListener(new OnQueryTextListener() { @Override public boolean onQueryTextSubmit(String query) { Toast. } return true.makeText(getApplicationContext().menu. nous allons rajouter un nouvel attribut android:actionViewClass.com .show(). R. // SearchView MenuItem itemSearch = menu. un champ de recherche prendra toute la place de la barre d'action (cachant les autres items du menu au passage) et affichant le clavier pour permettre à l'utilisateur d'effectuer sa recherche dans votre application.LENGTH_SHORT) . Toast. Ainsi. mieux intégré à notre barre d'action (et ainsi comprendre à quoi servira la dernière valeur du nouvel attribut sur les items du menu). } }). V ous obtiendrez un résultat similaire à celui-ci : Code : Java @Override public boolean onCreateOptionsMenu(Menu menu) { MenuInflater inflater = getMenuInflater(). } @Override public boolean onQueryTextChange(String newText) { return false.toast_search_submit. public boolean onQueryTextChange(String newText) pour récupérer la chaîne de caractère en cours lorsque l'utilisateur rentre un nouveau caractère ou en supprime. inflater. Ce listener vous demandera d'implémenter deux méthodes : public boolean onQueryTextSubmit(String query) pour récupérer la chaîne de caractère que l'utilisateur aura rentré lorsqu'il aura envoyé la requête.findItem(R. www.SearchView" android:icon="@android:drawable/ic_menu_search" android:showAsAction="ifRoom|collapseActionView" android:title="@string/menu_search"/> La modification du côté Java n'est pas nécessaire puisque si vous testez l'application comme ça. Nous modifions aussi android:showAsAction en rajoutant la valeur collapseActionView pour rendre notre vue « pliable » dans l'item du menu et ainsi la dépliée tout le long de notre barre lorsque nous cliquons dessus.menu_search). vous aurez l'effet escompté. Cependant. L'idée est la suivante : Lorsque nous cliquerons sur la loupe. Dans notre cas. nous allons utiliser un widget déjà integré au système que nous ré-utilisons.menu_actionbar. Pour ce faire. Ainsi. menu).getActionView().inflate(R.string.

widget. la majeur partie se ferra du côté Java. l'une des forces d'Android est la possibilité aux applications de dialoguer un minimum entre elles. il est normal pour les applications de vouloir partager du contenu avec toutes les applications du système susceptibles de pouvoir faire l'affaire. de rajouter un item destiné au partage avec un attribut android:actionProviderClass qui renseigne la valeur android. Nous avons simplement besoin. Cette fois-ci.siteduzero.ShareActionProvider. Du coup. www. le ShareActionProvider. Google a pensé à cela en intégrant une solution toute faite qui convient parfaitement à se retrouver dans la barre d'action.com . du côté XML.Partie 2 : Des nouveaux composants 46/79 Affichage de la barre de recherche dans la barre d'action Partage à travers le système Une autre astuce avec la barre d'action est le partage à travers le système. V ous le savez maintenant.

EXTRA_TEXT. inflater. intent.findItem(R. nous avons decider de partager simplement du texte mais cela aurait pu être n'importe quoi d'autres qu'un Intent supporte (image.com . intent. "Message").setType("text/plain"). Intent intent = new Intent(Intent. menu). mShareActionProvider.getActionProvider().menu_actionbar. // ShareActionProvider MenuItem itemProvider = menu.inflate(R. 47/79 Ce que nous voulons est très simple.menu. Récupérer l'item et lui demander quoi partager avec l'aide de la méthode public void setShareIntent (Intent shareIntent).menu_share).ACTION_SEND).setShareIntent(shareIntent). fichier.). nous pouvons récupérer l'item dans la méthode qui désérialise notre menu pour lui dire quoi faire.siteduzero. etc. } return true.putExtra(Intent. Nous obtenons alors la méthode suivante : Code : Java @Override public boolean onCreateOptionsMenu(Menu menu) { MenuInflater inflater = getMenuInflater().Partie 2 : Des nouveaux composants Après quoi.id. mShareActionProvider = (ShareActionProvider) itemProvider. www. Dans l'exemple qui suit.

com . www. Cela nous permettra de mettre plus d'item visible à l'utilisateur et de dissocier la barre d'action du menu. L'idée est de séparer le menu de la barre d'action dans une nouvelle barre situé en bas de l'écran. Sa mise en place est extrêmement simple puisqu'il suffit de rajouter l'attribut et la valeur android:uiOptions="splitActionBarWhenNarrow" dans l'activité contenant le menu que vous voulez diviser dans le fichier Manifest.siteduzero. En contre partie.Partie 2 : Des nouveaux composants 48/79 Affichage des fournisseurs de partage « Spliter » le menu V ous savez sans doute de quoi je parle. l'application de messagerie du système Android l'utilise dans son application. nous perdons de la place sur l'écran.

vous devez récupérer la barre d'action grâce à la méthode public ActionBar getActionBar() et apperler la méthode public abstract void setDisplayHomeAsUpEnabled (boolean showHomeAsUp) www. Pour ce faire.com . Il est généralement utilisé pour revenir en arrière (comme un bouton back) ou à l'écran d'accueil de votre application (justement pour ne pas être redondant au bouton back) mais vous pouvez l'utiliser comme bon vous semble.Partie 2 : Des nouveaux composants 49/79 Affichage de la division du menu à la barre d'action Bouton home Dernière petite chose. l'icone en haut à gauche de votre écran peut également servir comme un bouton.siteduzero. Je vous conseil quand même de l'utiliser à cet usage afin que les utilisateurs Android ne soient pas débousollés lorsqu'ils utilisent votre application.

Sinon.siteduzero. V ous êtes maintenant censé savoir comment déclarer ce genre de choses.setDisplayHomeAsUpEnabled(true). public boolean onCreateActionMode(ActionMode mode. Nous le déclarons comme un menu normal.com . votre application plantera. ActionBar actionBar = getActionBar(). Menu contextuel V ous vous rappelez des anciens menus contextuels ? Malheureusement.os.app. import android. Cette méthode lancera l'affichage du menu grâce au paramètre que vous lui donnez en paramètre. je vous laisse donc ce plaisir.id. dans notre exemple. www. Dans notre fichier XML d'affichage. V otre icone aura alors une petite flèche à gauche de l'icone qui vous indiquera que vous pouvez cliquer dessus (voire les captures d'écran ci-dessus). actionBar.Callback callback) sur l'activité. Google a réfléchi à cette problématique et a trouvé une solution plutôt élégante. } Un identifiant lui est automatiquement assigné par le système que vous pourrez tester dans la méthode public boolean onOptionsItemSelected(MenuItem item) et qui es R. nous allons simplement donner une implémentation aux deux premières méthodes qui fonctionnent exactement comme les menus normaux ! Nous obtenons alors une Activity semble au code ci-dessous et au résultat suivant : Code : Java package com. nous l'afficherons lorsque l'utilisateur cliquera sur un bouton pour bien différencier ce type de menu avec l'ancien mais sachez qu'il est toujours possible de le faire avec l'ancienne méthode. nous déclarons un bouton avec un attribut android:onClick qui prendra la valeur changeContextual.view. Pour rester simple. public boolean onPrepareActionMode(ActionMode mode. nous n'avons rien à faire en plus de ce côté.Activity. Nous voulons simplement afficher le menu contextuel. D'ailleurs. nous allons donc appeler la méthode public ActionMode startActionMode (ActionMode.onCreate(savedInstanceState). MenuItem item) pour récupérer l'item sur lequel l'utilisateur a cliqué.siteduzero. import android. Menu menu) pour désérialiser votre fichier XML contenant votre menu. V ous êtes obligé de presser un certain temps sur un élément avec votre doigt pour voir apparaitre votre menu.Partie 2 : Des nouveaux composants 50/79 dessus en lui donnant la valeur true. il vous permet d'assigner une méthode de votre Activity à votre bouton que vous avez spécifié. Ce paramètre prend une implémentation d'une interface Callback appartenant à ActionMode. public void onDestroyActionMode(ActionMode mode) appelé lorsque votre menu est détruit (lorsqu'il n'est plus affiché à l'écran). Si vous ne connaissez pas cet attribut. La méthode désignée par cet attribut doit être sous la sous la forme public void nomDeLaMethode(View view). Son implémentation exige 4 méthodes à redéfinir : public boolean onActionItemClicked(ActionMode mode.actionbar.ActionMode.android. Menu menu) appelé lorsqu'on tente de rafraichir le menu avec une méthode invalidate. Tout se jouera dans la partie Java. Nous déclarons un nouveau fichier XML destiné à être notre menu intermédiaire. Code : Java @Override protected void onCreate(Bundle savedInstanceState) { super. c'est une pratique qui peut encore être utilisée dans les applications actuelles mais qui ne sont pas du tout ergonomiques.Bundle. Nous allons profiter de la barre d'action pour afficher un menu intermédiaire qui apparaitra quand bon vous semble (j'entends par là qu'il n'est pas nécessaire de rester appuyé sur un élément pour faire apparaitre le menu).home. import android.

widget. 51/79 import com.android. android.view. } @Override public void onDestroyActionMode(ActionMode mode) { } @Override public boolean onPrepareActionMode(ActionMode mode. } }). android.activity_contextual).Menu.View.string. } public void changeContextual(View view) { startActionMode(new ActionMode.layout. inflater. Menu menu) { MenuInflater inflater = mode.makeText(getApplicationContext().toast_trash. android.getMenuInflater().MenuInflater.Callback() { @Override public boolean onActionItemClicked(ActionMode mode. Menu menu) { return false.siteduzero. R.Partie 2 : Des nouveaux composants import import import import import android. } return false. public class ActionBarContextualActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super. android.onCreate(savedInstanceState).siteduzero.getItemId()) { case R.menu_contextual. return true.show().Toast. } @Override public boolean onCreateActionMode(ActionMode mode.MenuItem .menu_trash: Toast.menu.R.inflate(R.view.LENGTH_SHORT).view. MenuItem item) { switch (item. Toast. } } www. menu). setContentView(R.com .id. return true.view.

cela voudrait dire que nous pouvons créer plusieurs menus contextuels pour une seule classe ? V ous avez tout compris. V ous pourriez créer plusieurs menus contextuels en fonction de la situation.siteduzero. C'est l'une des forces de ce type de menu et une excellente alternative à l'ancienne manière de faire ! www.Partie 2 : Des nouveaux composants 52/79 Affichage du menu contextuel Mais alors.com .

V ous savez comment confectionner des fragments et jusqu'à présent. Si vous ne savez plus comment confectionner des fragments. Cela se fait très simplement avec la méthode public void setArguments(Bundle args) : Code : Java public static DummyFragment newInstance(String chaine) { DummyFragment fragment = new DummyFragment(). chaine). Mais qu'arriverait-il si vous deviez à chaque fois passez un Bundle à la création d'un Fragment. Android nous simplifie grandement la tâche grâce au widget ViewPager. Nous créer une instance de notre Fragment. Tant que cela reste un petit projet. Même si vous êtes censé savoir comment on manipule des Bundle grâce aux Intent. C'était pas mal mais nous allons maintenant voir le slide à travers vos écrans grâce à un swipe. Par exemple. return fragment. Bundle args = new Bundle(). Pour récupérer ce Bundle. Le swipe est une gesture. args. fragment. ViewGroup container. C'est quelque chose de nécessaire pour ce chapitre. Nous pouvons donc très simplement récupérer www. vous devriez changer à chaque endroit où vous créez vos instances. nous allons pouvoir nous amuser un peu ! Confectionner des interfaces ergonomiques et originales.setArguments(args). Si vous vous rappelez de notre première utilisation des fragments dynamiques. Cette méthode sera donc sous la forme du code ci-dessous pour un Fragment portant le nom DummyFragment.putString("KEY_STRING". c'est-à-dire dans sa méthode public View onCreateView(LayoutInflater inflater.com . on crée un bundle dans lequel nous placons notre chaîne de caractères. C'est l'action de passer votre doigt de gauche à droite et inversement sur l'écran de votre terminal. Est-ce qu'il n'y aurait pas moyen d'encapsuler cette pratique quelque part pour une meilleur maintenance de votre code et pouvoir le modifier de manière plus efficace (sinon. L'idée est de créer un Bundle qui va contenir une chaîne de caractères avec une clé que nous définirons pour le récupérer par la suite dans la création de l'interface du fragment .Partie 2 : Des nouveaux composants 53/79 Slider à travers des écrans Maintenant que nous savons comment utiliser les fragments. Cette dernière nous permettra de créer une instance de notre fragment et d'encapsuler toutes les informations que nous aurons besoin dans notre fragment. } C'est aussi simple que cela. Dans un premier temps. c'est tout aussi simple. son utilisation est légèrement différente avec les fragments. Code : Java public static DummyFragment newInstance(/* informations que je veux donner à mon fragment */) { // renvoie une instance de mon fragment } Je vous rappelle que static signifie que la méthode n'est pas directement attachée aux instances que vous créez de la classe dans laquelle la méthode est retenue. il vous a fallu les déclarer soit dans un fichier XML d'affichage que vous désérialisez dans une classe Fragment soit créer des instances de vos fragments que vous affichez dynamiquement via l'API destiné à la gestion des fragments. nous allons remplir notre méthode static pour attacher un Bundle à notre fragment. nous allons voir comment passer des informations à la création d'un fragment via un Bundle. Maintenant. V ous devriez répéter constamment la manipulation partout dans votre code. nous l'attachons à notre Fragment et nous le renvoyons. Passer des informations à la création d'un fragment Avant de commencer à utiliser le widget ViewPager. je vous renvoie au premier chapitre de la partie 1 où les fragments sont abordés de manière détaillés. Qu'allons-nous faire ? Nous allons rajouter une méthode static dans notre Fragment. ça va mais cela pourrait vite grimper). nous avons simulé le slide d'un écran à l'autre lancé par un bouton. V ous verrez. Bundle savedInstanceState).siteduzero. vous pouvez donc y créer des instances de la classe dans laquelle vous êtes. imaginons que nous voulons donner une chaîne de caractères à notre Fragment pour l'afficher dans un TextView qu'il contient. Le setter des arguments de notre fragment possède également un getter.

getString("KEY_STRING")). import android. Cette classe nous imposera d'implémenter 1 constructeur et 2 méthodes : public ViewPagerAdapter(FragmentManager fm) est le constructeur imposé puisque votre adaptateur devra renvoyer à la super classe une instance d'un FragmentManager. Correction Code : Java package com. notre méthode public View onCreateView(LayoutInflater inflater.FragmentManager. son adaptateur ne possède pas une méthode View getView(. Je vais maintenant vous laissez réfléchir à la réalisation de notre adaptateur.android. vous créez vos fragments grâce à la méthode static et à l'affichage de ce dernier. Bundle savedInstanceState) ressemblera à : Code : Java @Override public View onCreateView(LayoutInflater inflater. pour rester simple.CENTER).. vous verrez la chaîne de caractères (ou n'importe quelle information que vous lui avez donné) à l'écran. Utilisation du widget ViewPager L'adaptateur du ViewPager Bien. Bundle args = getArguments().support.v4.. nous allons pouvoir commencer les choses sérieuses ! ViewPager est en fait un conteneur comme ListView. V ous affichez 3 fois le même fragment.support.app. vous retrouverez ma correction ci-dessous. ViewGroup container. textView.viewpager. import android.siteduzero. ViewGroup container. import android. Si vous avez bien compris le sous-chapitre précédent. j'ai préféré créer dynamiquement un TextView pour afficher notre chaîne de caractères. public Fragment getItem(int pos) pour récupérer une instance du fragment en cours.setGravity(Gravity. textView. Ainsi. etc. V ous attachez 3 chaînes de caractères différentes en fonction de la position. } V ous l'avez sans doute remarqué mais je n'ai pas utilisé de fichier XML d'affichage pour mon Fragment.Partie 2 : Des nouveaux composants 54/79 le Bundle grâce à la méthode public final Bundle getArguments(). Bundle savedInstanceState) { TextView textView = new TextView(getActivity()). Ainsi.v4. public int getCount() pour connaître le nombre de fragments que devra contenir notre ViewPager. return textView. L'XML est une pratique que j'encourage mais dans le cadre de cet exemple.app.Fragment.support. sauf qu'il ne s'utilise pas avec le même type d'adaptateur. GridView. import com.app.com . public class ViewPagerAdapter extends FragmentPagerAdapter { public ViewPagerAdapter(FragmentManager fm) { www. C'est tout ! Grâce à cette méthode.R. C'est lui qui est chargé de renvoyer les instances des fragments contenus dans notre conteneur. Je veux que : V ous utilisez le fragment que nous avons utilisé dans le sous-chapitre précédent.android. Le ViewPager est conçu pour fonctionner seulement avec des Fragment et rien d'autres. C'est beaucoup plus simple que cela ! Notre adaptateur devra étendre FragmentPagerAdapter. Comme d'habitude.FragmentPagerAdapter.siteduzero.v4.siteduzero.setText(args. vous aurez compris que nous appellerons les méthodes static de nos fragments dans la méthode public Fragment getItem(int pos).) qui renvoie une View avec votre conteneur.

com/apk/res/android" xmlns:tools="http://schemas.android.viewpager. } getItem(int pos) { DummyFragment.v4. case 3: return écran !").Partie 2 : Des nouveaux composants } super(fm).Bundle. private ViewPager mViewPager.FragmentActivity. Cela nous donnera donc le code et le résultat suivant : Code : Java package com. import import import import android. @Override public void onCreate(Bundle savedInstanceState) { super.android. A la différence que nous n'étendrons pas Activity mais FragmentActivity.ViewPager.siteduzero.siteduzero. import com. c'est exactement pareil qu'avec les autres conteneurs.app.ViewPager xmlns:android="http://schemas. setContentView(R. android. il nous manque plus que notre activité. le nom de l'élement sera accessible par le chemin android. Pour une fois. mSectionsPagerAdapter = new ViewPagerAdapter(getSupportFragmentManager()).os.support. android.android.v4.onCreate(savedInstanceState). notre adaptateur. } return null. android.com/tools" android:id="@+id/viewPager" android:layout_width="match_parent" android:layout_height="match_parent" /> Du côté de notre Activity.view et nous donnera donc la déclaration suivante : Code : XML <android. // Set up the adapter.activity_viewpager).support.newInstance("Je suis le troisième } @Override public int getCount() { return 3.layout. 55/79 @Override public Fragment switch(pos) { case 1: return !"). notre fichier XML d'affichage aura une petite particularité.app. notre conteneur est également redéfini dans le projet v4 que nous utilisons depuis le début de ce tutoriel.R.siteduzero. www.v4. Nous allons déclarer simplement un ViewPager à sa racine mais pour des soucis de compatibilité.newInstance("Je suis le premier écran DummyFragment. case 2: return !").android.view.support.support.v4. public class ViewPagerActivity extends FragmentActivity { private ViewPagerAdapter mSectionsPagerAdapter.FragmentTransaction.newInstance("Je suis le second écran DummyFragment. } Activité du ViewPager Nous avons notre Fragment.com . Pour ce faire.view.

viewPager).setAdapter(mSectionsPagerAdapter).Partie 2 : Des nouveaux composants // Set up the ViewPager with the sections adapter.com .id. mViewPager = (ViewPager) findViewById(R. mViewPager.siteduzero. 56/79 } } Affichage du premier écran de notre ViewPager Ajout d'un indicateur de la page Nous savons maintenant comment mettre en place un ViewPager mais il arrive que nous voulons savoir à quelle page nous www.

Pour ce faire.OnPageChangeListener listener).siteduzero. Android a prévu une solution très élégante integré directement dans la barre d'action de votre application. A chaque changement de page.setNavigationMode(ActionBar. final ActionBar actionBar = getActionBar(). V oici comment procéder : 57/79 Navigation en tab Pour indique que nous comptons utiliser les tabs de la barre d'action.onCreate(savedInstanceState). Ainsi.onCreate(savedInstanceState). float positionOffset. nous pouvons appeler la méthode public abstract void setSelectedNavigationItem(int position) sur la barre d'action et obtenir le résultat suivant : Code : Java @Override public void onCreate(Bundle savedInstanceState) { super. } // Set up others things Modifier l'indicateur Pour modifier l'indicateur en fonction de la page courante de l'utilisateur sur le ViewPager. à notre adaptateur ni à notre fichier XML d'affichage. Cette méthode prend en paramètre un mode qui se retrouve comme constante dans la classe ActionBar : NAVIGATION_MODE_STANDARD : Valeur par défaut de votre barre d'action. NAVIGATION_MODE_LIST : Change le titre présent dans la barre d'action en une liste déroulante que vous pouvez dérouler lorsque vous cliquez dessus. il faut indiquer à notre indicateur de changer le focus. dans notre méthode public void onCreate(Bundle savedInstanceState) de notre Activity.com . Consiste à afficher votre logo ou icone et le texte avec un sous titre optionnel dans la barre d'action. nous devons récupérer notre barre d'action et appeler dessus la méthode public abstract void setNavigationMode(int mode). nous faisons la manipulation suivante : Code : Java @Override public void onCreate(Bundle savedInstanceState) { super. www. public abstract void onPageScrolled(int position. // Set up others things // Set up the action bar.NAVIGATION_MODE_TABS).Partie 2 : Des nouveaux composants nous trouvons. Pour cela. public abstract void onPageSelected(int position) : Appelé lorsqu'une nouvelle page est sélectionnée. nous ne devrons pas toucher du tout à nos fragment. Tout se passe uniquement dans l'activité qui désérialise votre ViewPager. Ainsi. Le lisener OnPageChangeListener impose d'implémenter 3 méthodes : public abstract void onPageScrollStateChanged(int state): Appelé lorsque l'état du défilement change. NAVIGATION_MODE_TABS : V ous permettra d'utiliser des tabs dans votre barre d'action. L'idée est la suivante : Nous allons indiquer à notre barre d'action qu'il navigera via des « Tabs ». Lorsqu'on sélectionne une tab. int positionOffsetPixels) : Appelé lorsque la page courante est en train d'être modifié. nous devons changer la page du ViewPager. actionBar. nous allons devoir attacher un listener à notre conteneur via la méthode public void setOnPageChangeListener(ViewPager. La dernière méthode est celle qui nous intéresse puisqu'elle nous indique la position dans laquelle nous nous trouvons dans le conteneur.

layout. FragmentTransaction fragmentTransaction) : Appelé lorsqu'un tab est sélectionné. public abstract ActionBar.Tab newTab() : Méthode pour créer un tab.Tab tab. nous devons faire plusieurs choses : A la déclaration de nos tabs. On implémentera donc la seconde méthode de la manière suivante : Code : Java @Override public void onTabSelected(ActionBar. C'est bien pratique mais il est nécessaire d'avoir une petite idée des méthodes accessibles. Modifier la page Pour finir. FragmentTransaction fragmentTransaction) : Appelé lorsqu'un tab est resélectionné.onCreate(savedInstanceState).activity_viewpager).Tab tab) : Méthode pour ajouter un tab à l'activité. } Nous pouvons maintenant créer nos tabs grâce à trois méthodes que nous appellerons sur une instance de notre barre d'action : public abstract void addTab(ActionBar. } }).SimpleOnPageChangeListener() { @Override public void onPageSelected(int position) { actionBar. C'est simplement grâce à ViewPager.TabListener. FragmentTransaction fragmentTransaction) { mViewPager. nous allons attacher à chaque tab le même listener qui va s'occuper de changer la page courante de notre ViewPager.Tab tab.Tab setTabListener (ActionBar. mViewPager. FragmentTransaction fragmentTransaction) : Appelé lorsqu'un tab n'est plus sélectionné. public void onTabSelected(ActionBar. Pour ce faire. Nous utiliserons donc ces méthodes de la manière suivante : Code : Java @Override public void onCreate(Bundle savedInstanceState) { super. Elle nous oblige alors à implémenter 3 méthodes : public void onTabUnselected(ActionBar. add a tab to the action bar. www.SimpleOnPageChangeListener qui est un listener alternatif qui me permet de redéfinir uniquement les méthodes que je veux redéfinir.setCurrentItem(tab.activity_viewpager). nous voulons faire l'inverse.siteduzero. public abstract ActionBar.Partie 2 : Des nouveaux composants setContentView(R.Tab tab. Pour ce faire.setSelectedNavigationItem(position). la classe ActionBar.layout. } // Set up others things 58/79 V ous remarquez sans doute que je n'implémente pas les 3 méthodes. // Set up other things // For each of the sections in the app.setOnPageChangeListener(new ViewPager. nous allons implémenter au niveau de l'activité.Tab tab. setContentView(R. public void onTabReselected(ActionBar. nous voulons modifier la page courante du conteneur lorsque nous cliquons sur l'un des tabs de notre activité.com .TabListener listener) : Méthode pour attacher un listener à notre tab. // Set up others things // Set up the gesture to swipe between tab.getPosition()).

getPageTitle(i)).com . i < mSectionsPagerAdapter.newTab(). i++) { 59/79 actionBar.siteduzero. } } V ous avez sans doute remarqué la méthode public CharSequence getPageTitle(int position) appelé sur notre adaptateur. V ous n'êtes pas obligé de recourir à cette méthode.setText(mSectionsPagerAdapter. Cette méthode est en fait une méthode optionnel à implémenter qui nous permettra de contenir l' « intelligence » pour le choix du titre de nos pages.addTab(actionBar. c'est juste un plus que je vous offre. Ceci nous donnera alors le résultat suivant en mode portrait et paysage : www.getCount().Partie 2 : Des nouveaux composants for (int i = 0.

Partie 2 : Des nouveaux composants 60/79 Affichage du ViewPager avec une barre d'indicateur en portrait www.com .siteduzero.

siteduzero.com .Partie 2 : Des nouveaux composants 61/79 Affichage du ViewPager avec une barre d'indicateur en paysage www.

les nouveaux concepts de la version 4. Ce dernier prenant en paramètre l'identifiant de la notification et l'object comportant votre notification. cela ne devrait pas être un nouveau concept. public NotificationCompat. V ous en avez déjà développé et cela vous à certainement bien servi dans vos applications. Ce type de notification est la seule pouvant être lancée sur les terminaux Android 3 et plus.Builder(this). Maintenant que vous savez cela. Après cela. Notification notification) sur notre service système. c'est-à-dire que vous pouvez construire des notifications complexes qui s'afficheront correctement sur la version 4.getText(R.1 et supérieur mais qui paraitront comme de simples notifications sur les autres versions.Builder notification. elles sont trop nombreuses et ce tutoriel n'est pas destiné à devenir une documentation. grâce au projet de compatibilité v4 que nous utilisons constamment dans ce tutoriel. public NotificationCompat. Notification notification = builder . tous les autres types plus complexes seront apparus avec la version 4.string. Basique La création de notifications se fait maintenant par l'intermédiaire d'un service système.setContentTitle(getResources(). ce procédé est accessible aux versions plus anciennes que la version 3. Il est accessible par la classe Notification et s'initialise avec son constructeur en lui passant un contexte en paramètre : Code : Java Builder builder = new NotificationCompat.1.1 d'Android. nous allons construire et récupérer une instance de la classe Notification. Par contre. Cependant. setContentTitle(CharSequence title) : Donne un titre setContentText(CharSequence text) : Donne un texte à setSmallIcon(int icon) : Donne une icône à votre setWhen(long when) : Donne un timestamp pour l'affichage de Ce n'est pas toutes les méthodes possibles disponibles à partir d'Android 3. Après quoi.basic_title)) www. nous initialiserons les flags comme vous le faisiez avec les précédentes notifications et nous la lançons grâce à la méthode public void notify(int id.Builder votre notification. nous aurons besoin d'un Builder spécifique aux notifications. Si vous voulez en savoir plus.1 seront ignorés si vous construisez ces types de notifications . la construction des notifications a changé depuis Android 3 et de nouvelles notifications sont apparus avec Android 4. Ce chapitre est donc destiné uniquement à vous enseignez comment construire ces nouvelles notifications sans parler de services et autres endroits où vous êtes censé lancer vos notifications. je vous renvoie sur la documentation Android. Pour la construire.Partie 2 : Des nouveaux composants 62/79 Notifier l'utilisateur Les notifications.siteduzero. nous avons accès à une petite série de méthodes : public NotificationCompat. nous pouvons commencer l'apprentissage de notre première notification basique. chose que vous devriez bien connaître puisqu'une grande partie des services du système sont gérés de cette manière.Builder votre notification.Builder(this). C'est un bon compromis pour rester compatible avec les anciennes versions mais il faut garder cet aspect à l'esprit. Nous obtenons donc le code source et le résultat suivant : Code : Java Builder builder = new NotificationCompat. Ces choses ont été abordées dans le tutoriel de Apollidore.com . public NotificationCompat. Il vous faudra donc en récupérer une instance grâce à l'instruction suivante : Code : Java mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE). Cependant.Builder à votre notification. Dans un premier temps. A partir de cette instance.

Partie 2 : Des nouveaux composants .drawable.com .setSmallIcon(R. mNotificationManager. Au nombre de 3.siteduzero.ic_launcher) .currentTimeMillis()). Afficher une grande image dans votre notification.build(). 63/79 Exécution de la notification basique Les différents styles Les nouvelles notifications sont vues comme des nouveaux styles.string.notify(0.setContentText(getResources().setWhen(System. vous aurez la possibilité de : Afficher un grand texte dans votre notification. notification).getText(R.basic_text)) . www. notification.FLAG_AUTO_CANCEL.flags |= Notification.

string. nous obtenons le code source et le résultat suivant en utilisant simplement la première des 3 méthodes disponibles pour NotificationCompat. public NotificationCompat. vous pouvez appelez 3 méthodes différentes : public NotificationCompat. bigTextStyle.getText(R.setSmallIcon(R. en omettant la méthode public NotificationCompat. vous appelez la méthode public Notification build () qui vous construira la notification que vous pourrez lancer. 64/79 Grand texte Abordons les nouvelles notifications avec un grand texte.setContentTitle(getResources(). BigTextStyle bigTextStyle = new NotificationCompat.notify(0. NotificationCompat.getText(R. vous désirez écrire plus.string. Elle s'affichera toujours sur une seule ligne uniquement.Builder setContentText(CharSequence text).big_text)). Ce n'est donc pas du tout optimisé si.siteduzero. Sachez que dans les 3 styles.BigTextStyle setSummaryText(CharSequence cs) : Afficher un petit texte à la fin de votre notification destiné à la résumé. A partir de cet objet. Notification notification = bigTextStyle. builder.Builder en paramètre.Builder(this). que vous devrez initialiser en passant un NotificationCompat. Ainsi. mNotificationManager. notification).BigTextStyle setBigContentTitle(CharSequence title) : Afficher un grand titre pour votre notification.com .drawable. les deux dernières méthodes seront toujours disponibles. pour une raison X ou Y .Partie 2 : Des nouveaux composants Afficher une liste de chaînes de caractères dans votre notification.BigTextStyle bigText(CharSequence cs) : Afficher un grand texte pour votre notification.BigTextStyle : Code : Java Builder builder = new NotificationCompat. Cette nouvelle notification règle le problème très facilement et par l'intermédiaire d'une nouvelle classe. et vous récupérez un objet NotificationCompat. notification.bigText(getResources().BigTextStyle en lui passant ce builder en paramètre de son constructeur.big_text_title)) . www.Builder setContentText(CharSequence text) naturellement. public NotificationCompat.FLAG_AUTO_CANCEL. Une fois terminé.ic_launcher).BigTextStyle. V ous construisez donc votre builder de la même manière que la notification basique.build().flags |= Notification.BigTextStyle(builder). Il faut savoir que vous êtes limité en caractères si vous utilisez la méthode public NotificationCompat.

Tentez de la respecter le plus possible.siteduzero. C'est une bonne pratique lorsque vous concevez des applications Android. c'est pourquoi je vais vous laisser réfléchir à la façon de faire pour lancer ce type de notifications. Grande image La grande image est très similaire à la notification avec un grand texte.Partie 2 : Des nouveaux composants 65/79 Exécution de la notification affichant un grand texte Remarquez que j'ai utilisé le même indice pour cette notification et celle de la sous-partie précédente.com . Cela permettra à Android de récupérer une notification (si elle est construite) plutôt que d'en créer une nouvelle. Sachez simplement que vous allez devoir utiliser la classe www.

Partie 2 : Des nouveaux composants NotificationCompat.siteduzero.BigPictureStyle.com . je pense que vous êtes arrivé aisément au même résultat que moi : Code : Java Builder builder = new NotificationCompat. 66/79 Exécution de la notification affichant une grande image Correction Sans surprise. www. V ous devriez avoir un résultat similaire au mien (sachant que je vous demande pas de trouver l'image exacte que j'utilise ).Builder(this).

InboxStyle.setContentTitle(getResources(). notification).bigPicture( BitmapFactory. R. Nous aurons donc le résultat suivant : www.string. mNotificationManager.notify(0. Notification notification = bigPic.setSmallIcon(R. BigPictureStyle bigPic = new NotificationCompat.flags |= Notification.drawable.siteduzero.decodeResource(getResources().big_pic_title)) .notif_big_pic)).com .FLAG_AUTO_CANCEL.build(). 67/79 Liste de chaînes de caractères Continuons sur notre lancée puisque le dernier style est aussi très similaire aux deux autres.BigPictureStyle(builder). Sachez simplement que vous allez devoir utiliser la classe NotificationCompat.ic_launcher).drawable.getText(R. notification.Partie 2 : Des nouveaux composants builder. Nous allons confectionner une notification qui va afficher deux lignes et un message en fin de notification qui va récapituler le nombre de lignes dans la notification.

getText(R.Partie 2 : Des nouveaux composants 68/79 Exécution de la notification affichant une liste Correction Code : Java Builder builder = new NotificationCompat.build(). www.siteduzero. builder. InboxStyle inbox = new NotificationCompat.InboxStyle(builder).setSmallIcon(R.setSummaryText("You have 2 messages").drawable.inbox_title)) .ic_launcher).addLine("Line 2") .com .setContentTitle(getResources().Builder(this).string. Notification notification = inbox.addLine("Line 1").

getText(R.R. getResources().setSmallIcon(R. CharSequence title.drawable.ic_menu_send. le seul bouton que vous pouvez contrôler est la notification elle-même.notification_action_2).notify(0.flags |= Notification. 69/79 Ajouter des boutons d'action Une chose qui n'est pas integrée dans les exemples précédents est la possibilité de rajouter des boutons d'action à vos notifications.string. getResources(). Avec les anciennes notifications.Builder. Même si c'est une pratique maintenant bien integré chez les utilisateurs. lorsque l'utilisateur clique dessus. cela n'aurait pas été possible.drawable.addAction(android. ce n'est pas le plus ergonomique. C'est-à-dire qu'il est possible d'ajouter des boutons sous votre notification qui vous permettra de les rendre encore plus complètes.ic_launcher) .getText(R. vous pourrez retrouver son implémentation sur le projet GitHub du tutoriel. c'est bien entendu un PendingIntent. getPendingIntent()) .notification_action_1). V ous pourriez donner la possibilité à l'utilisateur de le lire ou de l'archiver directement. mNotificationManager.siteduzero.setContentTitle(getResources().FLAG_AUTO_CANCEL.big_pic_title)) . V ous êtes censé savoir comment créer des PendingIntent.addAction(android.Builder addAction(int icon. notification). il existe la méthode public NotificationCompat. Cependant.string. Imaginez que vous recevez un e-mail.string.getText(R. Actuellement. title est le texte qui s'affichera à droite de votre bouton. getPendingIntent()).currentTimeMillis()). Cela nous donnera le beau résultat suivant : www. nous aurons quelque chose semblable à ceci en rajoutant deux boutons d'action : Code : Java builder. Si nous devons compléter le builder du style de la grande image de notre exemple précedent.com .setWhen(System. intent est l'intent qui sera lancé lorsque vous cliquerez sur le bouton. je passerai donc par l'intermédiaire d'une méthode private PendingIntent getPendingIntent() qui s'occupera de lancer un intent sur l'activité courante dans laquelle je me trouve.Partie 2 : Des nouveaux composants notification. PendingIntent intent) que vous appelez sur votre NotificationCompat.R. Les paramètres correspondent : icon est l'icône qui s'affichera à gauche de votre bouton.ic_menu_camera. Dorénavant.drawable.

Partie 2 : Des nouveaux composants 70/79 Exécution de la notification affichant une grande image et deux boutons www.com .siteduzero.

votre smartphone sera constamment à la recherche d'un tag NFC. ou en français Communication en Champ Proche) n'est pas neuve. Pour ce faire. Les différents tags existants Identification des différents tags Avant de vous lancez dans l'apprentissage du NFC. vous devrez le vérifier dans la catégorie « Sans fil et réseaux » des paramètres de votre smartphone. Ce dernier sera également vu en dernière partie de ce chapitre. Chose pour laquelle Android possède 3 types différents de tag NFC pour couvrir un large nombre de tag. il passera au type suivant. Il sera lancé si le message du tag n'est pas formatté par le standard NDEF. Il encapsulera le tag dans un intent regroupant toutes les informations nécessaires et l'enverra au système qui cherchera une activité parmi l'une de vos applications qui filtre le type de tag qui a été identifié. Le système d'identification des tags tentera de lancer une activité avec cet intent plutôt que d'autres intents en attente dans votre système. vous pouvez activer votre NFC et Android Beam. ACTION_TAG_DISCOVERED est l'intent qui sera lancé si aucune autre activité n'a été trouvé dans le système pour gérer le tag découvert. Si le système ne trouve aucune activité qui gère cet intent. il est utile de savoir comment est structurer un message NDEF. Android a prévu une API pour nous permettre de rester. on en entend parler de plus en plus. Le problème c'est que cette standardisation n'est pas suivie par tout le monde. A partir de là. Elle vous permettra d'échanger des données à une fréquence faible et à courte distance (moins de 10cm). Depuis quelques années seulement. A partir de maintenant. à un haut niveau d'abstraction. il tentera de le traiter le mieux possible. V ous pouvez dès maintenant l'activer en prévision de la suite. la technologie NFC (Nier Field Communication.siteduzero. il vous faudra peut-être relire à deux fois certaines explications puisque nous allons devoir directement jouer avec des bits sur certains points. il serait sans doute utile de savoir si votre appareil dans votre poche le possède. Les messages NDEF sont la tentative de standardisations des forums NFC qui est un consortium international créé pour promouvoir la technologie NFC. Une fois que votre appareil captera un tag NFC. V ous devez donc savoir qu'il existe plusieurs sortes de tag étant donné que cette technologie n'a pas été standardisée dès sa sortie (et qu'elle ne l'est pas encore tout à fait). Nous pouvons donc filtrer sur 3 niveaux de priorités : ACTION_NDEF_DISCOVERED est le plus grand niveau de propriété dans tout le système. Système d'identification du tag Structure d'un message NDEF Avant d'aller plus loin.com .Partie 2 : Des nouveaux composants 71/79 Le partage par NFC Malgré ce qu'un grand nombre d'utilisateurs penseraient. V oici un petit schéma qui l'explique assez www. plus ou moins. Nous n'allons pas rentrer dans les détails techniques de cette technologie dans ce chapitre. Cependant. Notamment grâce aux smartphones qui démocratisent à grande vitesse cette technologie. ACTION_TECH_DISCOVERED est un niveau de propriété juste en dessous du précédent. même lorsque vous serez sur l'écran de verrouillage.

Nous allons spécifier plusieurs petite chose dans le noeud <manifest>: La version minimum du SDK que doit spécifier votre application pour accéder à l'entièreté de l'API NFC.nfc.nfc" android:required="boolean" /> Maintenant.hardware. nous devrons ajouter un noeud <intent-filter> avec un élément <action> qui indiquera le type de tag que nous traitons et la catégorie du filtre avec un élément <category>. Lecture d'un tag Activité destiné à gérer la lecture du tag Bien. Il faut donc penser à les répartir sur plusieurs records si nous implémentons une application qui écrit des NDEF messages sur des tags ou à bien récupérer chaque record si nous implémentons un lecteur. Chose que nous allons faire dans la suite de ce chapitre. De plus. d'enregistrement. Pour ce faire. nous allons nous limiter aux messages NDEF pour tenter de supporter cette standardisation que Google et d'autres acteurs comme SONY ou Philips tentent de répandre. il est bien plus simple d'utiliser les messages NDEF pour apprendre puisque Android offre une API spécialement prévue pour ce type de messages. Au niveau du noeud racine . nous rajouterons : Code : XML <uses-sdk android:minSdkVersion="10"/> <uses-permission android:name="android. avec un header (comportant des informations comme son identifiant et autres et un payload qui est la donnée en elle-même). Implémentation dans notre application Comment concrétiser ce filtre dans notre application ? C'est très simple.Partie 2 : Des nouveaux composants simplement : 72/79 Structure d'un message NDEF Qu'avons-nous là ? Tout simplement un message qui comporte un tableau de record.intent.NDEF_DISCOVERED" /> <category android:name="android.action. nous lui attacherons un fichier XML www.DEFAULT" /> </intent-filter> Avec ce filtre.siteduzero. Chaque record possède un espace mémoire assez réduit. on va enfin commencer à s'amuser ! Cependant. le système sera que nous traitons les tags NDEF et pourra proposer notre activité lorsqu'il captera un tag de ce type. tout se passe dans notre fichier manifest.NFC" /> <uses-feature android:name="android. Si le NFC doit être activé ou non lors de l'exécution de notre application. Dans une activité quelconque. nous n'aurons pas besoin de grand chose.permission.com . La permission du NFC pour signaler à l'utilisateur que nous utiliserons cette fonctionnalité et pour permettre au Play Store de filtrer les terminaux compatibles. pour les activités qui seront destinées à gérer le NFC.category. Nous aurons donc quelque chose comme ceci : Code : XML <intent-filter> <action android:name="android.

Partie 2 : Des nouveaux composants

73/79

d'affichage pour afficher simplement un texte qui sera modifier par le texte que nous enverrons par un tag (ou par une méthode expliquée plus loin pour simuler un tag). Quant à notre activité, nous nous contenterons de désérialiser ce fichier XML et de jouer avec l'adaptateur NFC, NfcAdapter. Son initialisation se fait avec la méthode public static NfcAdapter getDefaultAdapter(Context context) qui est une méthode statique pouvant être appelé à partir de la classe précédemment citée. Dès que c'est chose faite, nous devons vérifier que l'appareil qui tente de lancer l'activité a bien le NFC ou s'il est bien activé. Pensez qu'il est toujours possible pour un utilisateur de télécharger une application qui ne lui est pas destinée initialement. Il pourrait donc installer une application qui ne figure pas sur son Play Store parce que ses appareils enregistrés ne sont pas compatibles. Nous vérifierons que notre adaptateur est bien différent de null ou s'il est bien activé par la méthode public boolean isEnabled(). Notre méthode public void onCreate(Bundle savedInstanceState) ressemblera donc à quelque chose comme le code ci-dessous. Code : Java @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_nfc); this.mTextView = (TextView) findViewById(R.id.textView1); this.mNfcAdapter = NfcAdapter.getDefaultAdapter(this); if (mNfcAdapter == null || !mNfcAdapter.isEnabled()) { Toast.makeText(this, R.string.text_no_nfc, Toast.LENGTH_SHORT).show(); finish(); return; } }

Maintenant, pour que notre activité puisse gérer la découverte d'un TAG au premier plan, il est nécessaire de redéfinir la méthode protected void onResume() et la méthode protected void onPause(). Dans la première méthode, nous activerons la possibilité d'identifier le tag passé dans un Intent via la méthode public void enableForegroundDispatch(Activity activity, PendingIntent intent, IntentFilter[] filters, String[][] techLists). A quoi correspondent tous ces paramètres ? Le paramètre Activity est bien entendu destiné à renseigner l'activité sur lequel vous vous trouvez. Le paramètre PendingIntent renseigne un intent à exécuter plus tard pour indiquer l'activité qui se charge du traitement du tag. Le paramètre IntentFilter[] pour affiner le traitement des messages, mettre null si vous acceptez tout. Le paramètre String[][] est renseigné pour exécuter un matching de traitement avec le type de tag de priorité inférieur, mettre null si vous ne voulez rien matcher. Quant à la seconde méthode, nous devons désactiver cette possibilité de traitement des tags sur l'activité au premier plan par la méthode public void disableForegroundDispatch(Activity activity) en renseignant simplement l'activité courante. V ous aurez donc une implémentation similaire au code suivant : Code : Java @Override protected void onResume() { super.onResume(); Intent intent = new Intent(this, this.getClass()).addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP); PendingIntent pIntent = PendingIntent.getActivity(this, 0, intent, 0); IntentFilter[] filters = null; String[][] techListArray = null; mNfcAdapter.enableForegroundDispatch(this, pIntent, filters, techListArray); } @Override

www.siteduzero.com

Partie 2 : Des nouveaux composants
protected void onPause() { super.onPause(); mNfcAdapter.disableForegroundDispatch(this); }

74/79

Pour finir, nous allons voir comment traiter notre intent qui comporte notre NDEF message. Nous allons donc créer une méthode avec la signature private void resolveIntent(Intent intent) qui récupérera un tableau de Parcelable correspondant aux données extensions placés par le tag, et ce via la méthode public Parcelable[] getParcelableArrayExtra(String name) en lui passant en paramètre la constante NfcAdapter.EXTRA_NDEF_MESSAGES. A partir de là, nous pourrons recopier son contenu dans un tableau du type NdefMessage et traiter les données comme bon nous semble. Si nous prenons un exemple simple où il existe simplement des données dans le premier enregistrement du message NDEF, on aura une méthode similaire à : Code : Java private void resolveIntent(Intent intent) { String action = intent.getAction(); if (NfcAdapter.ACTION_NDEF_DISCOVERED.equals(action)) { Parcelable[] rawMsgs = intent.getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES); if (rawMsgs != null) { NdefMessage[] messages = new NdefMessage[rawMsgs.length]; for (int i = 0; i < rawMsgs.length; i++) { messages[i] = (NdefMessage) rawMsgs[i]; } // Exemple basique de récupération des données dans le tableau String str = new String(messages[0].getRecords()[0].getPayload()); mTextView.setText(str); } } }

Il vous suffit alors d'appeler cette méthode à la fin de la méthode public void onCreate(Bundle savedInstanceState) de votre activité pour gérer l'intent que vous recevrez dans votre activité lorsque votre système captera un tag NDEF. V otre application est maintenant capable d'intercepter les messages NDEF découvert par votre système et proposera donc votre activité pour les lire.

Un émulateur de tag NDEF
C'est bien beau tout ça mais comment pouvons-nous tester notre application si nous ne disposons pas de tag NFC comportant des NDEF messages ? C'est très simple. Pour ce faire, nous aurons besoin de 2 méthodes assez générique que vous n'aurez pas forcément besoin de comprende (c'est un peu technique puisque c'est de la manipulation de bits) et d'une autre activité (c'est important sinon ça ne fonctionnera pas). Nous aurons donc besoin des deux méthodes suivantes permettant la création d'un message NDEF et de ses records : Code : Java public static NdefMessage createMessage(String text, boolean encode) { NdefRecord[] records = new NdefRecord[1]; records[0] = createRecord(text, Locale.FRENCH, encode); return new NdefMessage(records); } public static NdefRecord createRecord(String text, Locale locale, boolean encode) { byte[] langBytes = locale.getLanguage().getBytes( Charset.forName("US-ASCII")); Charset utfEncoding = encode ? Charset.forName("UTF-8") : Charset

www.siteduzero.com

Partie 2 : Des nouveaux composants
.forName("UTF-16"); byte[] textBytes = text.getBytes(utfEncoding); int utfBit = encode ? 0 : (1 << 7); char status = (char) (utfBit + langBytes.length); byte[] data = new byte[langBytes.length + textBytes.length + 1]; data[0] = (byte) status; System.arraycopy(langBytes, 0, data, 1, langBytes.length); System.arraycopy(textBytes, 0, data, 1 + langBytes.length, textBytes.length); return new NdefRecord(NdefRecord.TNF_WELL_KNOWN, NdefRecord.RTD_TEXT, new byte[0], data); }

75/79

Pour des soucis de facilité, j'ai placé ces méthodes en static dans une classe utilitaire NFCUtils.

Dans notre activité, nous utiliserons la méthode public static NdefMessage createMessage(String text, boolean encode) que nous appellerons lorsqu'un utilisera cliquera sur un bouton pour lancer un intent test comportant un message que nous avons défini de la manière suivante : Code : Java public void sendTag(View v) { Intent i = new Intent(NfcAdapter.ACTION_NDEF_DISCOVERED); NdefMessage[] messages = new NdefMessage[1]; messages[0] = NFCUtils.createMessage("Simule message NDEF", true); i.putExtra(NfcAdapter.EXTRA_NDEF_MESSAGES, messages); startActivity(i); }

Ainsi, lorsque nous cliquerons sur le bouton, notre système nous proposera notre première activité qui offre la possibilité de gérer des NDEF messages.

www.siteduzero.com

Partie 2 : Des nouveaux composants 76/79 Exécution de l'émulateur de messages NDEF Echange par Beam Nous abordons maintenant la dernière partie de ce chapitre avec une utilisation du NFC très intéressante.siteduzero. L'idée est de lancer le partage juste en rapprochant deux smartphones dos à dos. Nous allons devoir ici être récepteur et envoyeur. c'est une chose de plus à implémenter. c'est que ce ne sont pas les technologies les plus rapides et les plus facile à utiliser pour transférer de l'information. V ous êtes censé pouvoir recevoir de l'information et en envoyer.com . Cependant. Cette fois-ci. pour les développeurs. Android offre une API légèrement différente pour que cela soit plus simple pour les développeurs d'envoyer des données. www. V ous connaissez tous les connectivités comme le Bluetooth ou le WiFi qui vous permettent d'échanger des données entre deux terminaux. Le problème. rien de plus. Pour ce faire. C'est là que le NFC arrive pour palier avec une facilité déconcertante. cela va être un peu différent que le lecteur de tag que nous avons développé.

Partie 2 : Des nouveaux composants 77/79 Commençons par implémenter une interface dans notre activité. Nous lui donnons donc l'instance du callback en paramètre et l'activité courante dans laquelle il se trouve pour rendre opérationnel notre code. nous allons appeler. payload). à quelques exceptions près.Nous implémentons donc la méthode public NdefMessage createNdefMessage(NfcEvent event) de façon très similaire à notre émulateur. dans la méthode protected void onCreate(Bundle savedInstanceState). byte[] payload) { byte[] mimeBytes = mimeType.TNF_MIME_MEDIA. NdefMessage msg = new NdefMessage(records). Nous devrons donc initialiser un tableau de record qui comporte l'enregistrement mime et le payload représentant la donnée à transférer. mimeBytes.com . return msg. NdefRecord[] records = new NdefRecord[] { NFCUtils. new byte[0]. CreateNdefMessageCallback.siteduzero.forName("US-ASCII")). Activity activity. Nous obtenons donc simplement le code suivant : Code : Java @Override public NdefMessage createNdefMessage(NfcEvent event) { String text = "Message share by Beam !".createMimeRecord( "application/com. vous arrivez au resultat suivant : www. } Maintenant. pour rendre actif l'appel à cette méthode. La réception des messages se fait exactement de la même façon que précédent sauf qu'il vous faudra redéfinir une méthode supplémentaire public void onNewIntent(Intent intent) pour appeler la méthode private void resolveIntent(Intent intent) développée dans la sous partie précédente de ce chapitre. A partir de là.android.nfc". Empaqueter le tout dans un NdefMessage pour ensuite le retourner dans la méthode.siteduzero.getBytes()) }. } Le mime nous permettra d'indiquer le chemin vers le paquetage contenant l'activité qui permettra de traiter le transfert Beam.CreateNdefMessageCallback callback. return mimeRecord. text. cette interface servira à implémenter les méthodes pour créer les messages NDEF lorsque nous envoyons des données à un autre terminal. NdefRecord mimeRecord = new NdefRecord(NdefRecord. Nous aurons besoin de la méthode suivante pour créer un mime : Code : Java public static NdefRecord createMimeRecord(String mimeType.getBytes(Charset. activities) sur l'adaptateur NFC que nous avons initialisé juste avant. si vous exécutez votre code et que vous mettez dos à dos deux terminaux avec la technologie Beam.. Comme vous pouvez le deviner.. la méthode public void setNdefPushMessageCallback (NfcAdapter. Activity.

siteduzero. Fumble pour la validation de mon tutoriel. ce tutoriel est très loin d'être terminé.Partie 2 : Des nouveaux composants 78/79 Exécution du programme Android Beam Bien entendu. Bluekicks pour l'icône de mon tutoriel. questions et remarques constructives ! Remerciements Aux lecteurs et bêta-testeurs qui me font des critiques constructives sur le contenu de mon tutoriel. Je suis donc ouvert à toutes vos critiques.com . V ous pourrez retrouver ce même tutoriel en bêta via ce lien. Il a pour but d'être le plus communautaire possible. N'hésitez pas à me donner votre avis pour faire évoluer ce tutoriel. www.