Développement sur Android V. Barichard vincent.barichard@univ-angers.fr LERIA - Département Informatique Université d Angers M2 - SILI M2 - SILI Développement sur Android 1
Rappels Chapitre I Rappels M2 - SILI Développement sur Android 2
Rappels Android Généralités Android est un système d exploitation Open Source basé sur un noyau Linux Il fonctionne sur smartphone, tablette, télévision, voiture, Initialement développé par une startup du même nom, rachetée par Google en 2005 Android offre un framework riche mais suffisamment rigide et étanche (XML, activités, services, ) Android permet d accéder aux fonctionnalités avancées de l appareil (stockage, réseau, multimédia, GPS, téléphonie) Le SDK d Android : Les applications Android sont écrites en Java Le code Java est compilé pour pouvoir s exécuter sur la machine virtuelle Dalvik/ART embarquée sur Android L application est empaquetée dans un fichier APK (Android PacKage) puis installée sur l appareil M2 - SILI Développement sur Android 3
Rappels Android SDK La base AndroidManifest.xml déclare les activités, services ainsi que la façon dont l application s intègre au système Séparer la description de l interface de son comportement Les principaux widgets héritent de la classe View : TextView, Button, ImageView, ImageButton, EditText, CheckBox, RadioButton Les widgets sont accessibles depuis le code Java Comme dans la plupart des bibliothèques graphiques, un «layout manager» place les widgets Pour donner les indications de placement, des «conteneurs» sont utilisés LinearLayout, RelativeLayout, TableLayout, ScrollView M2 - SILI Développement sur Android 4
Rappels Android SDK T.A.D. Android permet de lier directement certains widgets à un type abstrait de données adapté Ce sont les adapteurs Exemple : Le widget d Android pour les listes est le ListView ArrayAdapter permet de lier un tableau de données à un widget liste ListActivity est préconisé quand l activité se réduit à une liste M2 - SILI Développement sur Android 5
Rappels Rappel sur le procédé d inflation Extension au cas des menus Rappel : l interface graphique d une vue peut se créer dynamiquement grâce à l inflation d une ressource XML Interface d une activité, d une ligne d une liste, etc. Ceci s applique également aux menus : menu/main.xml <?xml version="1.0" encoding="utf-8"?> <menu xmlns:android="http://schemas.android.com/apk/res/android"> <item android:id="@+id/menu_ouvrir" android:title="ouvrir" /> </menu> M2 - SILI Développement sur Android 6
Rappels Instanciation d un menu par inflation Le code Java doit être adapté et charger l interface du menu grâce à un Inflater Le callback onoptionsitemselected se sert de l id de l élément spécifié dans la ressource XML pour identifier l action sélectionnée dans le menu Code Java @Override public boolean oncreateoptionsmenu(menu menu) { getmenuinflater().inflate(r.menu.main, menu); return(super.oncreateoptionsmenu(menu)); @Override public boolean onoptionsitemselected(menuitem item) { switch (item.getitemid()) { case R.id.menu_ouvrir:... return(true); return(super.onoptionsitemselected(item)); M2 - SILI Développement sur Android 7
Rappels Android SDK Cycle de vie Sur un PC l OS 1 peut tuer des processus Jamais utilisé en pratique Sur un smartphone, les ressources et notamment la mémoire sont plus limitées Des activités peuvent être tuées pour permettre à d autres de s exécuter Certaines doivent mourir pour que d autres vivent Sur Android il ne faut pas supposer que l application ira jusqu à son terme! 1. Operating System M2 - SILI Développement sur Android 8
Rappels Android SDK Cycle de vie Une activité est toujours dans l un des quatre états suivants : Active : elle s execute au premier plan En pause : l activité est visible mais inacessible (une notification ou un message apparaît devant) Stoppée : elle est cachée par une autre activité Morte : elle n a pas été lancée ou a été tuée Android fournit des méthodes appelées lors de la transition d un état à un autre Lors d un changement d orientation, Android supprime et recrée toutes les activités Il est possible d adapter les activités pour bien réagir face à la rotation La philosophie d Android demande au développeur de découper son application en activités autonomes M2 - SILI Développement sur Android 9
Rappels Android SDK Cycle de vie oncreate() : instanciation des objets et tâches invisibles onstart() : lancement des tâches visibles à l écran onresume() : abonnements, rétablissement contexte onpause() : désabonnements, enregistrement contexte OnStop() : arrêt des tâches et destruction des objets visibles ondestroy() : défaire les actions de oncreate M2 - SILI Développement sur Android 10
Gradle Chapitre II Gradle M2 - SILI Développement sur Android 11
Gradle Passage à Gradle Un nouveau système pour la construction des paquets Au début, le système de construction utilisé dans Android était ant ant est le système de gestion de compilation utilisé par Java Depuis JellyBean un nouveau système à été introduit : Gradle Il tend maintenant à devenir le système de constuction/compilation principal d Android Il est utilisé par AndroidStudio et intégré à l outil en ligne de commande M2 - SILI Développement sur Android 12
Gradle Présentation de Gradle Un moteur de production (à la cmake, ant, ) Gradle fonctionne à base de tâches décrivant le processus de construction Les tâches sont décrite dans un fichier de construction en Groovy 2 Lorsqu il utilise un démon en tâche de fond, les compilations suivantes sont plus rapides Il est souvent utilisé à travers un wrapper (un script) effectuant des vérifications supplémentaires./gradlew --help : pour obtenir l aide./gradlew tasks : donne la liste des tâches connues./gradlew installdebug : compile et installe le projet sur un device Android 2. Language objet similaire à Java M2 - SILI Développement sur Android 13
Gradle Présentation de Gradle Un moteur de production (à la cmake, ant, ) Gradle fonctionne à base de tâches décrivant le processus de construction Les tâches sont décrite dans un fichier de construction en Groovy 2 Lorsqu il utilise un démon en tâche de fond, les compilations suivantes sont plus rapides Il est souvent utilisé à travers un wrapper (un script) effectuant des vérifications supplémentaires./gradlew --help : pour obtenir l aide./gradlew tasks : donne la liste des tâches connues./gradlew installdebug : compile et installe le projet sur un device Android 2. Language objet similaire à Java M2 - SILI Développement sur Android 13
Gradle Android et Gradle Le greffon Android Gradle utilise des greffons pour l ajout d extensions Java, dépôt Maven, Android, tests unitaires Ces greffons créent la structure du projet, les tâches, Le greffon Android gère les spécificités d Android La structure d un projet a été remaniée Structure du projet pour le greffon Android build.gradle gradlew gradle/ src/main/ AndroidManifest.xml assets/ java/ --> (Sources) res/ --> (Ressources) src/androidtest/... M2 - SILI Développement sur Android 14
Gradle Android et Gradle Le greffon Android Gradle utilise des greffons pour l ajout d extensions Java, dépôt Maven, Android, tests unitaires Ces greffons créent la structure du projet, les tâches, Le greffon Android gère les spécificités d Android La structure d un projet a été remaniée Structure du projet pour le greffon Android build.gradle gradlew gradle/ src/main/ AndroidManifest.xml assets/ java/ --> (Sources) res/ --> (Ressources) src/androidtest/... M2 - SILI Développement sur Android 14
Gradle Android et Gradle Création et compilation d un projet Création du projet android create project -g --gradle-version 1.3.0 \ --path MonProjet \ --target android-21 \ --name MonProjet \ --activity MonActivite \ --package com.univangers.m2sili Pour créer un projet Android pour Gradle il faut indiquer la version du greffon Android à utuliser (ici, 1.3.0) Un bug dans la version actuelle du SDK nécessite d appeler la commande fixgradle dans le répertoire principal du projet juste après sa création Pour compiler et installer le projet, se positionner dans le répertoire racine du projet et taper :./gradlew installdebug M2 - SILI Développement sur Android 15
Les fragments Chapitre III Les fragments 1 Cycle de vie 2 Création d un fragment 3 Construire une interface multi-appareils avec des fragments 4 Fragment sans interface M2 - SILI Développement sur Android 16
Les fragments Présentation des fragments Introduction Introduits dans Android 3.0, les fragments permettent à l interface utilisateur d être plus flexible et dynamique En divisant une activité en fragments, l apparence de l application sera modifiée dynamiquement en fonction de l appareil Exemple : un lecteur de news M2 - SILI Développement sur Android 17
Les fragments Présentation des fragments Simple-panneau et multi-panneaux Sur l exemple précédent, l activité utilise deux fragments Sur tablette, les deux fragments sont montrés côte à côte Sur petits appareils, les fragments sont montrés successivement La première activité intègre le fragment de la liste des articles La deuxième activité intègre le fragment pour lire un article Sélectionner un article dans le premier fragment lance la deuxième activité La deuxième activité n est jamais utilisée sur tablette Créer des interfaces avec des fragments permet d avoir : Une interface simple-panneau sur petits appareils Multi-fragments, multiples activités Une interface multi-panneaux sur tablettes Multi-fragments, activité unique M2 - SILI Développement sur Android 18
Les fragments Présentation des fragments Qu est-ce qu un fragment? Un fragment est un composant indépendant et réutilisable mis dans une activité Un fragment possède sa propre interface utilisateur Il est possible de définir des fragments sans interface (tâches de fond) Plusieurs fragments peuvent cohabiter au sein d une activité Il s exécute dans une activité mais possède son propre cycle de vie Il est tout de même dépendant du cycle de vie de l activité Les fragments s ajoutent et se retirent de la pile de retours Ils peuvent être manipulés de manière statique et dynamique M2 - SILI Développement sur Android 19
Les fragments Pour créer un fragment, il faut créer une sous-classe de Fragment Le code ressemble à celui d une activité Il possède les fonctions nécessaires à la gestion de son cycle de vie Il y a des callbacks à redéfinir Il est facile de convertir une activité en fragment Comme pour les activités, la nouvelle classe doit hériter au choix de : Fragment : pour la création d un fragment classique DialogFragment : pour la création d une boîte de dialogue flottante ListFragment : pour gérer une liste en lien avec un Adapter PreferenceFragment : pour gérer les paramètres d une application M2 - SILI Développement sur Android 20
Les fragments Plan Cycle de vie 1 Cycle de vie 2 Création d un fragment 3 Construire une interface multi-appareils avec des fragments 4 Fragment sans interface M2 - SILI Développement sur Android 21
Les fragments Cycle de vie Cycle de vie propre onattach() : référence sur activité en cours oncreate() : instanciation objets non graphiques oncreateview() : inflation onactivitycreated() : référence sur activité, exécution des initialisations requérant l activité, restauration du contexte onstart() : lancement des tâches onresume() : abonnements, rétablissement contexte onpause() : désabonnements, enregistrement contexte OnStop() : arrêt des tâches, destruction des objets ondestroyview() : libération mémoire des composants graphiques ondestroy() et ondetach() : rien M2 - SILI Développement sur Android 22
Les fragments Lien avec l activité propriétaire Cycle de vie Le cycle de vie des fragments est lié à celui de l activité propriétaire Un fragment peut terminer son cycle de vie bien que l activité soit encore active Si une activité s arrête, ses fragments s arrêtent Comme pour les activités, les callbacks doivent rappeler les fonctions correspondantes de la super classe Il n est pas possible d obtenir le contexte depuis le fragment, il faut passer par l activité M2 - SILI Développement sur Android 23
Les fragments Plan Création d un fragment 1 Cycle de vie 2 Création d un fragment 3 Construire une interface multi-appareils avec des fragments 4 Fragment sans interface M2 - SILI Développement sur Android 24
Les fragments Création d un fragment Interface du fragment Le layout L interface graphique d un fragment est décrite dans une ressource xml Elle se déclare comme les activités simples vues antérieurement liste_details.xml <LinearLayout android:layout_width="wrap_content" android:layout_height="match_parent"> <TextView android:id="@+id/titre" android:layout_width="match_parent" android:layout_height="wrap_content" android:text="@string/titre" /> <ListView android:id="@+id/listelements" android:layout_width="match_parent" android:layout_height="wrap_content"/> </LinearLayout> M2 - SILI Développement sur Android 25
Les fragments Création d un fragment Interface du fragment Redéfinition de OnCreateView Il est nécessaire d avoir une classe héritant de Fragment La seule méthode à redéfinir obligatoirement est oncreateview @Override public View oncreateview(layoutinflater inflater, ViewGroup container, Bundle savedinstancestate) { View view = inflater.inflate(r.layout.liste_details, container, false); //Instanciation des composants graphiques (findviewbyid...) return view; Remarque : le dernier argument de l appel à inflate est false Ainsi, le système rattache la vue à l activité M2 - SILI Développement sur Android 26
Les fragments Activité intégrant le fragment Layout d un fragment statique Création d un fragment Un fragment statique peut être intégré dans une application en le déclarant dans le layout de l activité La balise xml à utiliser est fragment. Elle doit notamment spécifier : android:name spécifie la classe implémentant le fragment android:id identifiant unique pour accéder au fragment depuis le code Java fragment_layout.xml <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent"> <fragment class="com.univangers.info.exemple.fragmenttitres" android:id="@+id/fragment_titres" android:layout_width="match_parent" android:layout_height="match_parent" /> </FrameLayout> M2 - SILI Développement sur Android 27
Les fragments Activité intégrant le fragment Redéfinition de oncreate Création d un fragment La méthode oncreate de l activité s implémente comme d habitude @Override public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.fragment_layout); FragmentTitres mainfragment=(fragmenttitres)findviewbyid(r.id.fragments_titres); Le fragment peut être récupéré (grâce à findviewbyid) et manipulé dynamiquement M2 - SILI Développement sur Android 28
Les fragments Création d un fragment Positionnement des fragments La répartition de l espace entre fragments se fait comme les autres widgets Répartition 1 3 et 2 3 <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="horizontal" android:layout_width="match_parent" android:layout_height="match_parent"> <fragment android:name="com.univangers.info.fragmenta" android:id="@+id/list" android:layout_weight="1" android:layout_width="match_parent" android:layout_height="match_parent" /> <fragment android:name="com.univangers.info.fragmentb" android:id="@+id/viewer" android:layout_weight="2" android:layout_width="match_parent" android:layout_height="match_parent" /> </LinearLayout> M2 - SILI Développement sur Android 29
Les fragments Fragments dynamiques Ajout d un fragment Création d un fragment Les fragments peuvent être créés et manipulés dynamiquement avec le FragmentManager Un fragment peut être rattaché à un conteneur existant (par exemple un FrameLayout) : Le paramètre ViewGroup identifie le conteneur à utiliser L id unique de ce conteneur peut servir à retrouver le Fragment ultérieurement Les opérations sur les fragments sont regroupées dans des transactions Ajout d un fragment private static final String TAG_MON_FRAGMENT = "TAG_MON_FRAGMENT_1"; FragmentManager fragmentmanager = getfragmentmanager() FragmentTransaction fragmenttransaction = fragmentmanager.begintransaction(); ExampleFragment exfragment = new ExampleFragment(); fragmenttransaction.add(exfragment, TAG_MON_FRAGMENT); fragmenttransaction.commit(); M2 - SILI Développement sur Android 30
Les fragments Fragments dynamiques Rappel d un fragment Création d un fragment Il est possible de rappeler un fragment précédemment créé en utilisant son «TAG» Rappel d un fragment private static final String TAG_MON_FRAGMENT = "TAG_MON_FRAGMENT_1"; FragmentManager fm = getfragmentmanager(); ExampleFragment exfragment = (ExampleFragment) fm.findfragmentbytag(tag_mon_fragment); if (exfragment == null) { exfragment = new ExampleFragment(); fm.begintransaction().add(exfragment, TAG_TASKS_FRAGMENT).commit(); Il est aussi possible d utiliser des «id» qui sont obligatoirement uniques M2 - SILI Développement sur Android 31
Les fragments Fragments dynamiques Rappel d un fragment Création d un fragment Il est possible de rappeler un fragment précédemment créé en utilisant son «TAG» Rappel d un fragment private static final String TAG_MON_FRAGMENT = "TAG_MON_FRAGMENT_1"; FragmentManager fm = getfragmentmanager(); ExampleFragment exfragment = (ExampleFragment) fm.findfragmentbytag(tag_mon_fragment); if (exfragment == null) { exfragment = new ExampleFragment(); fm.begintransaction().add(exfragment, TAG_TASKS_FRAGMENT).commit(); Il est aussi possible d utiliser des «id» qui sont obligatoirement uniques M2 - SILI Développement sur Android 31
Les fragments Création d un fragment Fragments dynamiques La BackStack La backstack est gérée par l activité Il est possible de la modifier Lorsque l utilisateur presse la touche de retour, les transactions de la BackStack sont dépilées Remplacement d un fragment // Création d'un nouveau fragment Fragment newfragment =... instanciation d'un nouveau fragment... // Ajout du fragment à l'activité, ajout sur la backstack FragmentTransaction ft = getfragmentmanager().begintransaction(); ft.replace(r.id.simple_fragment, newfragment); ft.settransition(fragmenttransaction.transit_fragment_open); ft.addtobackstack(null); ft.commit(); addtobackstack permet de revenir à l ancien état en pressant la touche de retour M2 - SILI Développement sur Android 32
Les fragments Plan Construire une interface multi-appareils avec des fragments 1 Cycle de vie 2 Création d un fragment 3 Construire une interface multi-appareils avec des fragments 4 Fragment sans interface M2 - SILI Développement sur Android 33
Les fragments Construire une interface multi-appareils avec des fragments Utiliser l aptitude du système à appliquer différents layouts Android peut utiliser une ressource.xml différente en fonction de la taille de l écran Tablettes : res/layout-large/main.xml <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="horizontal" android:layout_width="match_parent" android:layout_height="match_parent" android:id="@+id/frags" > <!-- "Fragment A" --> <fragment class="com.example.android.fragmenttitres" android:id="@+id/list_frag" android:layout_width="@dimen/titles_size" android:layout_height="match_parent" /> <!-- "Fragment B" --> <fragment class="com.example.android.fragmentdetails" android:id="@+id/details_frag" android:layout_width="match_parent" android:layout_height="match_parent" /> </LinearLayout> M2 - SILI Développement sur Android 34
Les fragments Construire une interface multi-appareils avec des fragments Utiliser l aptitude du système à appliquer différents layouts Petits appareils : res/layout/main.xml <?xml version="1.0" encoding="utf-8"?> <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" > <!-- "Fragment A" --> <fragment class="com.example.android.fragmenttitres" android:id="@+id/list_frag" android:layout_width="match_parent" android:layout_height="match_parent" /> </FrameLayout> Si le fragment B est dans le layout l activité A notifie le fragment B Sinon, l activité A démarre l activité B contenant le fragment B M2 - SILI Développement sur Android 35
Les fragments Implémentation de la transition Construire une interface multi-appareils avec des fragments Code Java public class MainActivity extends Activity implements FragmentTitres.OnItemSelectedListener {... public void onitemselected(int position) { DisplayFragment detailsfrag = (DisplayFragment) getfragmentmanager().findfragmentbyid(r.id.details_frag); if (detailsfrag == null) { // FragmentDetails (Fragment B) n'est pas dans le layout (petit appareil), // démarrage de l'activité d'affichage (Activity B) // avec les options nécessaires au bon positionnement Intent intent = new Intent(this, DisplayActivity.class); intent.putextra("position", position); startactivity(intent); else { // FragmentsDetails (Fragment B) est dans le layout (tablette), // on demande juste au fragment de se mettre à jour details_frag.updatecontent(position); Quand l activité B démarre, elle lit les données stockées dans Intent pour positionner le fragment B M2 - SILI Développement sur Android 36
Les fragments Synthèse Construire une interface multi-appareils avec des fragments Dans les versions récentes du SDK, Android permet de spécifier des ressources différentes (dans des répertoires différents), fonction de la qualité et la précision de l écran Pour que cette interface responsive fonctionne, il est important de : Ne pas accéder à un fragment depuis un autre De laisser tout le code de gestion du fragment dans le fragment et non dans l activité Il faut définir des interfaces et des callbacks dans les fragments pour communiquer avec l activité et délivrer les messages M2 - SILI Développement sur Android 37
Les fragments Plan Fragment sans interface 1 Cycle de vie 2 Création d un fragment 3 Construire une interface multi-appareils avec des fragments 4 Fragment sans interface M2 - SILI Développement sur Android 38
Les fragments Sauvegarde/Restauration d un fragment Avant, avec les activités Fragment sans interface Android détruit souvent des activités (rotation, ) Il faut sauvegarder et restaurer le contexte Les widgets pourvus d id voient leur contenu sauvegardé et restauré Avec les activités il faut redéfinir deux méthodes : onsaveinstancestate qui permet de stocker dans un Bundle les champs primitifs ou parcelables onrestoreinstancestate qui permet de récupérer depuis un Bundle les champs primitifs ou parcelables M2 - SILI Développement sur Android 39
Les fragments Sauvegarde/Restauration d un fragment Avec les fragments Fragment sans interface La méthode onrestoreinstancestate n existe plus dans les fragments, il faut passer par les méthodes du cycle de vie : oncreate(bundle) oncreateview(layoutinflater,viewgroup,bundle) onactivitycreated(bundle) public void onactivitycreated(bundle savedinstancestate) { super.onactivitycreated(savedinstancestate); if (savedinstancestate!= null) { // Restauration des données du contexte utilisateur mcurcheckposition = savedinstancestate.getint("curchoice", 0); public void onsaveinstancestate(bundle outstate) { super.onsaveinstancestate(outstate); // Sauvegarde des données du contexte utilisateur outstate.putint("curchoice", mcurcheckposition); M2 - SILI Développement sur Android 40
Les fragments Fragment sans interface Quid des objets non primitifs, non parcelables? Les objets non primitifs ou non parcelables ne peuvent-être sauvegardés dans un Bundle Stuctures de données avancées, threads, Avant HoneyComb il existait la méthode onretainconfigurationinstance dans la classe Activity Depuis HoneyComb il faut utiliser des fragments sans interface utilisateur auxquels il est demandé de ne pas «mourir» Les données à sauvegarder sont stockées comme attributs du Fragment Un fragment sans interface s ajoute obligatoirement dynamiquement (sans conteneur) Pour qu un fragment ne soit pas détruit, il suffit d appeler sa méthode setretaininstance(true) M2 - SILI Développement sur Android 41
Les fragments Fragment sans interface Utilisation de setretaininstance Lors de l utilisation de setretaininstance(true), le cycle de vie change : ondestroy() n est pas appelée, mais ondetach() l est toujours oncreate(bundle) ne sera pas appelée (le fragment n est pas recréé) oncreateview( ), ondestroyview() ne seront pas appelées onattach(activity) et onactivitycreated(bundle) sont toujours appelées Ne jamais appeler setretaininstance(true) sur un fragment normal car la backstate sera corrompue Attention! Lorsque setretaininstance(true) est appelée, le Bundle savedinstancestate est null M2 - SILI Développement sur Android 42
Les tâches en arrière plan Chapitre IV Les tâches en arrière plan M2 - SILI Développement sur Android 43
Les tâches en arrière plan La solution : les «threads» Pour être agréable, une application doit être fluide et réactive Les tâches longues ne peuvent pas être mises en avant Android permet d utiliser des threads pour traiter des tâches en arrière plan Dans la majorité des bibliothèques graphiques, la gestion de l interaction et des rappels est réalisée par des files d attentes de messages Cela permet d avoir un thread dedié à l affichage indépendant du reste Pour que l application reste réactive, il faut que : Les opérations longues soient placées dans des threads Le thread principal (avec les rappels) soit le plus efficace possible M2 - SILI Développement sur Android 44
Les tâches en arrière plan La solution : les «threads» Application à Android Android ne déroge pas à la règle et gère des files de messages Si le thread principal nécessite trop de temps processeur : L affichage n est plus rafraîchi L application est considérée comme plantée (un message apparaît) Certaines activités doivent absolument être placées dans des threads : Les accès à Internet (téléchargement, envoi de données) Les opérations sur les fichiers (mémoire lente) Les traitements complexes et coûteux Android utilise la classe thread 3 de Java Il n est pas possible de modifier l interface depuis un thread! 3. paquet java.util.concurrent M2 - SILI Développement sur Android 45
Les tâches en arrière plan Faire patienter l utilisateur Il faut toujours informer l utilisateur sur la progression des tâches longues Le widget ProgressBar affiche une barre de progression Un entier naturel correspond au niveau de progression Il est possible d interagir avec depuis le code Java : setmax() fixe la valeur maximale de barre setprogress() et incrementprogressby() modifie la valeur de progression getprogress() retourne le niveau actuel de la barre <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="match_parent" android:layout_height="wrap_content"> <ProgressBar android:id="@+id/progress" style="?android:attr/progressbarstylehorizontal" android:layout_width="match_parent" android:layout_height="wrap_content" /> </LinearLayout> M2 - SILI Développement sur Android 46
Les tâches en arrière plan Exécuter une tâche de fond en informant l interface Un exemple de plusieurs façons M2 - SILI Développement sur Android 47
Les tâches en arrière plan Exécuter une tâche de fond en informant l interface Un exemple de plusieurs façons M2 - SILI Développement sur Android 47
Les tâches en arrière plan Exécuter une tâche de fond en informant l interface Un exemple de plusieurs façons M2 - SILI Développement sur Android 47
Les tâches en arrière plan Les handlers et les threads La méthode manuelle La classe Thread lance le thread en tâche de fond Les instances de la classe Handler font communiquer interface et thread Le handler gère une file d évènements thread safe La communication s effectue par envois de messages : sendmessage(), sendmessageatfrontofqueue(), sendmessagedelayed(), Redéfinition de la méthode handlemessage() du handler Utilisation d un bundle pour le passage des données à handlemessage() M2 - SILI Développement sur Android 48
Les tâches en arrière plan Les handlers et les threads Exemple public class Debut extends Activity { ProgressBar bar; AtomicBoolean isrunning = new AtomicBoolean(false); Handler handler = new Handler() { @Override public void handlemessage(message msg) { bar.incrementprogressby(msg.getdata().getint("valeur")); ; @Override public void oncreate(bundle state) { super.oncreate(state); setcontentview(r.layout.main); bar=(progressbar)findviewbyid(r.id.progress); public void onstart() {... public void onstop() {... M2 - SILI Développement sur Android 49
Les tâches en arrière plan Les handlers et les threads Exemple (suite)... public void onstart() { super.onstart(); bar.setprogress(0); Thread background = new Thread(new Runnable() { public void run() { try { for (int i=0; i<20 && isrunning.get(); i++) { Thread.sleep(1000); Message msg = handler.obtainmessage(); Bundle bdl = new Bundle(); bdl.putint("valeur",5); msg.setdata(bdl); handler.sendmessage(msg); catch (Throwable t) { ); isrunning.set(true); background.start(); public void onstop() { super.onstop(); isrunning.set(false); M2 - SILI Développement sur Android 50
Les tâches en arrière plan Les tâches asynchrones : la classe AsyncTask La méthode assistée par Android Depuis Android 1.5, AsyncTask a été introduit pour faciliter la gestion des tâches de fond C est Android qui se charge d exécuter le thread Le développeur n a plus qu à répartir son code dans les méthodes prévues AsyncTask<Params, Progress, Result> est une classe Template prenant trois paramètres : Params : type de la donnée passée au lancement de la tâche Progress : type de la donnée utilisée pour communiquer la progression Result : type de la donnée passée à la tâche lorsque celle-ci a terminée M2 - SILI Développement sur Android 51
Les tâches en arrière plan Implémenter une tâche de fond avec AsyncTask Il faut tout d abord créer une classe héritant de AsyncTask Il faut ensuite redéfinir certaines méthodes : onpreexecute : est appelée avant le début de la tâche, elle est exécutée dans le thread principal doinbackground (nécessaire) : Elle reçoit en paramètre un tableau de données et est exécutée dans un thread en arrière plan onprogressupdate : est appelée lors de l appel à publishprogress(), elle est exécutée dans le thread principal onpostexecute : est appelée quand la tâche est terminée, elle est exécutée dans le thread principal oncancelled : est appelée si AsyncTask().cancel() est appelée, terminant l exécution de la tâche Pour démarrer une AsyncTask, il faut appeler la méthode execute() de l instance M2 - SILI Développement sur Android 52
Les tâches en arrière plan Implémenter une tâche de fond avec AsyncTask Exemple public class Debut extends Activity { private ProgressBar bar; @Override public void oncreate(bundle state) { super.oncreate(state); setcontentview(r.layout.main); bar=(progressbar)findviewbyid(r.id.progress); new BackgroundTask().execute(); class BackgroundTask extends AsyncTask<Void, Integer, Void> { @Override protected Void doinbackground(void... unused) { for (int i=0; i<20; i++) { publishprogress(5); SystemClock.sleep(1000); return (null); @Override protected void onprogressupdate(integer... step) { bar.incrementprogressby(step[0]); ; ; M2 - SILI Développement sur Android 53
Les tâches en arrière plan Les threads et la rotation Lors d une rotation, les threads ne sont plus connectés à l interface Les mises à jour sont envoyées à l ancien thread principal qui n existe plus Pour s en convaincre, il suffit de rajouter la méthode : @Override protected void onpreexecute() { Toast.makeText(Debut.this,"Thread lancé!", Toast.LENGTH_LONG).show(); Un message est affiché à chaque rotation d écran Pour résoudre ce problème, il faut attacher manuellement l activité à la tâche de fond (via un fragment) M2 - SILI Développement sur Android 54
Les tâches en arrière plan Les threads et la rotation Pour que le thread puisse s exécuter en tâche de fond sans interruption, il faut : Ne pas le rattacher à l activité mais Le rattacher à un fragment «persistant» private TaskCallBacks mmainactivitylistener = null; @Override public void onattach(activity mainactivity) { super.onattach(mainactivity); this.mmainactivitylistener = (TaskCallBacks) mainactivity; @Override public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setretaininstance(true); @Override public void ondetach() { super.ondetach(); this.mmainactivitylistener = null; Il faudra donc définir trois classes héritant respectivement de : Activiy, Fragment et AsyncTask Une interface de «CallBack» est nécessaire pour que la tâche de fond puisse envoyer des données/informations à l activité M2 - SILI Développement sur Android 55
Les tâches en arrière plan Les threads et la rotation Exemple : L activité public class TP extends Activity implements TasksFragment.TaskCallBacks { private static final String TAG_TASKS_FRAGMENT = "tp_task_fragment"; private TasksFragment mtasksfragment; // ------------------------------------------------- // LIFE CYCLE MEMBER FUNCTIONS // ------------------------------------------------- @Override public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.main); FragmentManager fm = getfragmentmanager(); mtasksfragment = (TasksFragment) fm.findfragmentbytag(tag_tasks_fragment); if (mtasksfragment == null) { mtasksfragment = new TasksFragment(); fm.begintransaction().add(mtasksfragment, TAG_TASKS_FRAGMENT).commit();... @Override public void onitemupdate(titem item) {... @Override public void onitemdone(titem item) {...... M2 - SILI Développement sur Android 56
Les tâches en arrière plan Les threads et la rotation Exemple : le fragment public class TasksFragment extends Fragment { static interface TaskCallBacks { public void onitemupdate(titem item); public void onitemdone(titem item); private TaskCallBacks mmainactivitylistener = null; @Override public void onattach(activity mainactivity) { super.onattach(mainactivity); this.mmainactivitylistener = (TaskCallBacks) mainactivity; @Override public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setretaininstance(true); @Override public void ondetach() { super.ondetach(); this.mmainactivitylistener = null; protected void onprogressupdate(titem item) { if (mmainactivitylistener!= null) mmainactivitylistener.onitemupdate(item); protected void onpostexecute(titem item) { if (mmainactivitylistener!= null) mmainactivitylistener.onitemdone(item); // ---------------- BACKGROUND TASK ----------------------------------... M2 - SILI Développement sur Android 57
Les tâches en arrière plan Les threads et la rotation Exemple : la tâche // ------------------------------------------------------------------------- // ---------------- BACKGROUND TASK ---------------------------------- // ------------------------------------------------------------------------- class BackgroundTask extends AsyncTask<TItem, TItem, TItem> { protected TasksFragment tasksfragment = null; BackgroundTask(TasksFragment tasksfragment) { this.tasksfragment = tasksfragment; @Override protected URLItem doinbackground(titem... _item) {... @Override protected void onprogressupdate(titem... item) { super.onprogressupdate(item); tasksfragment.onprogressupdate(item0); @Override protected void onpostexecute(titem item) { super.onpostexecute(item); tasksfragment.onpostexecute(item); M2 - SILI Développement sur Android 58
Les tâches en arrière plan Les threads : synthèse Le traitement de certaines tâches en tâche de fond est incontournable en Android Plusieurs façons de faire : La classe Thread de Java (implémentation d objets runnable et de handlers) Étendre la classe AsyncTask (suffisant dans la majorité des cas) Un fragment persistant sans interface permet de ne pas perdre la tâche de fond pendant une destruction de l activité (rotations, passage à l arrière plan,...) Il est souvent nécessaire de créer des interfaces de callbacks pour rappeler les méthodes de l activité M2 - SILI Développement sur Android 59
Les notifications Chapitre V Les notifications M2 - SILI Développement sur Android 60
Les notifications Utilités d une notification Une notification est un message à l attention de l utilisateur affiché en dehors de l application Elle est utilisée pour deux types d actions : Afficher un message à l intention de l utilisateur Empêcher une activité d être tuée (lecteur audio, ) Une notification peut-être persistante ou éphémère Une notification peut se résumer à une simple icône Une notification peut être développée par l utilisateur pour permettre une interaction (simple) M2 - SILI Développement sur Android 61
Les notifications Créer une notification Android utilise un objet Notification.Builder pour créer la notification : Obligatoire : titre, texte détaillé, icône Autres paramètres sont optionnels Création de la notification Notification notification = new Notification.Builder(getActivity()).setContentTitle("Titre de la notification").setcontenttext("text de la notificationé).setsmallicon(r.drawable.nom_image).setautocancel(true).build(); Une notification peut se supprimer en appelant setautocancel lors du clique Une notification peut permettre de lancer une activité : Clique ou avec boutons supplémentaires M2 - SILI Développement sur Android 62
Les notifications Créer une notification Android utilise un objet Notification.Builder pour créer la notification : Obligatoire : titre, texte détaillé, icône Autres paramètres sont optionnels Création de la notification Notification notification = new Notification.Builder(getActivity()).setContentTitle("Titre de la notification").setcontenttext("text de la notificationé).setsmallicon(r.drawable.nom_image).setautocancel(true).build(); Une notification peut se supprimer en appelant setautocancel lors du clique Une notification peut permettre de lancer une activité : Clique ou avec boutons supplémentaires M2 - SILI Développement sur Android 62
Les notifications Créer une notification Android utilise un objet Notification.Builder pour créer la notification : Obligatoire : titre, texte détaillé, icône Autres paramètres sont optionnels Création de la notification Notification notification = new Notification.Builder(getActivity()).setContentTitle("Titre de la notification").setcontenttext("text de la notificationé).setsmallicon(r.drawable.nom_image).setautocancel(true).build(); Une notification peut se supprimer en appelant setautocancel lors du clique Une notification peut permettre de lancer une activité : Clique ou avec boutons supplémentaires M2 - SILI Développement sur Android 62
Les notifications Gérer les notifications La première action à réaliser est d afficher la notification : Déclenchement de la notification NotificationManager notificationmanager = (NotificationManager) getactivity().getsystemservice(activity.notification_service); notificationmanager.notify(0, notification); Le premier argument correspond à l id de la notification Une autre notification affichée avec le même id mettra à jour la notification existante Il est possible de la retirer depuis une activité grâce à son id en appelant la méthode cancel M2 - SILI Développement sur Android 63
Les notifications Ajouter une réaction à une notification Il est possible de définir une action lors du clique sur la notification Pour cela il faut créer un Intent qui démarrera une activité La notification définit une action à partir d un PendingIntent qui prend comme argument un Intent qui démarre une activité Création d un Intent Intent resultintent = new Intent(this, ResultActivity.class);... PendingIntent resultpendingintent = PendingIntent.getActivity(this, 0, resultintent, PendingIntent.FLAG_UPDATE_CURRENT); Cet Intent est ensuite ajouté à la notification Ajout de l intent PendingIntent resultpendingintent; notification.setcontentintent(resultpendingintent); M2 - SILI Développement sur Android 64
Les notifications Ajouter une réaction à une notification Il est possible de définir une action lors du clique sur la notification Pour cela il faut créer un Intent qui démarrera une activité La notification définit une action à partir d un PendingIntent qui prend comme argument un Intent qui démarre une activité Création d un Intent Intent resultintent = new Intent(this, ResultActivity.class);... PendingIntent resultpendingintent = PendingIntent.getActivity(this, 0, resultintent, PendingIntent.FLAG_UPDATE_CURRENT); Cet Intent est ensuite ajouté à la notification Ajout de l intent PendingIntent resultpendingintent; notification.setcontentintent(resultpendingintent); M2 - SILI Développement sur Android 64
Interaction avec les évènements systèmes : le Bluetooth Chapitre VI Interaction avec les évènements systèmes : le Bluetooth 1 Les «broadcast receiver» 2 Application à la gestion du Bluetooth M2 - SILI Développement sur Android 65
Interaction avec les évènements systèmes : le Bluetooth Les «broadcast receiver» Plan 1 Les «broadcast receiver» 2 Application à la gestion du Bluetooth M2 - SILI Développement sur Android 66
Interaction avec les évènements systèmes : le Bluetooth Les «broadcast receiver» À l écoute du système les «broadcast receiver» Un broadcast receiver est un composant Android permettant de se mettre en attente d évènements systèmes Un receiver (récepteur) se déclare soit dans le AndroidManifest.xml soit dynamiquement La classe principale à connaître est : BroadcastReceiver Android peut recycler un récepteur une fois sa méthode onreceive terminée Il existe un grand nombre de broadcast receivers répondant aux évènements systèmes : Intent.ACTION_BOOT_COMPLETED, Intent.ACTION_BATTERY_LOW, M2 - SILI Développement sur Android 67
Interaction avec les évènements systèmes : le Bluetooth Les «broadcast receiver» Implémenter un receiver Exemple d un receiver statique Exemple d implémentation (pris dans un tutorial) Fichier MyPhoneReceiver.java public class MyPhoneReceiver extends BroadcastReceiver { @Override public void onreceive(context context, Intent intent) { Bundle extras = intent.getextras(); if (extras!= null) { String state = extras.getstring(telephonymanager.extra_state); Log.w("MY_DEBUG_TAG", state); if (state.equals(telephonymanager.extra_state_ringing)) { String phonenumber = extras.getstring(telephonymanager.extra_incoming_number); Log.w("MY_DEBUG_TAG", phonenumber); M2 - SILI Développement sur Android 68
Interaction avec les évènements systèmes : le Bluetooth Les «broadcast receiver» Implémenter un receiver Exemple d un receiver statique (suite) Il suffit ensuite de l enregistrer au niveau de l application décrite dans AndroidManifest.xml Ajout dans AndroidManifest.xml <receiverandroid:name="myphonereceiver" > <intent-filter> <action android:name="android.intent.action.phone_state" > </action> </intent-filter> </receiver> M2 - SILI Développement sur Android 69
Interaction avec les évènements systèmes : le Bluetooth Les «broadcast receiver» Envoyer ses propres évènements («custom») Il est possible de créer un intent puis de l envoyer comme message broadcast Ajout dans AndroidManifest.xml Intent intent = new Intent(); intent.setaction("com.univangers.m2.testbroadcast"); sendbroadcast(intent); Le message sortira de l application et toute application enregistrée à ce récepteur sera avertie Il est possible d associer des paramètres/valeurs en les spécifiant dans l Intent M2 - SILI Développement sur Android 70
Interaction avec les évènements systèmes : le Bluetooth Les «broadcast receiver» Répondre à des évènements «custom» Cela se fait simplement en les enregistrants dynamiquement depuis le code ou statiquement dans l AndroidManifest.xml Ajout dans AndroidManifest.xml <receiverandroid:name="myreceiver" > <intent-filter> <actionandroid:name="com.univangers.m2.testbroadcast" /> </intent-filter> </receiver> Dans le cas d évènements locaux à l application, il est préférable d utiliser un LocalBroadcastManager plus rapide et plus sûr M2 - SILI Développement sur Android 71
Interaction avec les évènements systèmes : le Bluetooth Plan Application à la gestion du Bluetooth 1 Les «broadcast receiver» 2 Application à la gestion du Bluetooth M2 - SILI Développement sur Android 72
Interaction avec les évènements systèmes : le Bluetooth Application à la gestion du Bluetooth Introduction à l API Bluetooth d Android Le Bluetooth est un moyen d envoyer et de recevoir des informations entre deux appareils par ondes Il est peu consommateur d énergie et normalisé Ce protocole normalisé est supporté par de nombreuses plateformes Android fourni une API capable de : Détecter de nouveaux appareils Obtenir la liste des appareils liés Se connecter aux appareils par découverte de service Établir une connexion RFCOMM Transférer des données Gérer plusieurs connexions simultanées M2 - SILI Développement sur Android 73
Interaction avec les évènements systèmes : le Bluetooth Application à la gestion du Bluetooth Introduction à l API Bluetooth d Android Le Bluetooth est un moyen d envoyer et de recevoir des informations entre deux appareils par ondes Il est peu consommateur d énergie et normalisé Ce protocole normalisé est supporté par de nombreuses plateformes Android fourni une API capable de : Détecter de nouveaux appareils Obtenir la liste des appareils liés Se connecter aux appareils par découverte de service Établir une connexion RFCOMM Transférer des données Gérer plusieurs connexions simultanées M2 - SILI Développement sur Android 73
Interaction avec les évènements systèmes : le Bluetooth Obtenir les permissions Application à la gestion du Bluetooth Pour accéder au Bluetooth il faut ajouter des demandes de permissions dans l AndroidManifest.xml Modification de AndroidManifest.xml <manifest... > <uses-permission android:name="android.permission.bluetooth"/>... </manifest> Si on souhaite également modifier les paramètres ou lancer la découverte d appareils, il faut rajouter la permission android.permission.bluetooth_admin M2 - SILI Développement sur Android 74
Interaction avec les évènements systèmes : le Bluetooth Être averti lors de l activation du Bluetooth Création du broadcast receiver Application à la gestion du Bluetooth Points à retenir : Créer une instance de BroadcastReceiver (ou sous-classe) Redéfinir la méthode onreceive Identifier les évènements qui nous intéressent private final BroadcastReceiver mbtbroadcastreceiver = new BroadcastReceiver() { public void onreceive(context context, Intent intent) { String action = intent.getaction(); // When discovery finds a device if (BluetoothAdapter.ACTION_STATE_CHANGED.equals(action)) {...... ; La constante BluetoothAdapter.ACTION_STATE_CHANGED identifie les évènements émis lors de l activation du Bluetooth M2 - SILI Développement sur Android 75
Interaction avec les évènements systèmes : le Bluetooth Être averti lors de l activation du Bluetooth Enregistrement dynamique d un BroadcastReceiver Application à la gestion du Bluetooth L enregistrement dynamique d un broadcast receiver se fait au niveau de l activité Il faut récupérer l activité depuis le fragment Un filtre est nécessaire pour filtrer les évènements qui déclencheront notre récepteur L enregistrement doit être fait au minimum dans la méthode onstart Enregistrement d un «broadcast receiver» depuis un fragment @Override public void onstart() { super.onstart(); // Register the BroadcastReceiver IntentFilter filter = new IntentFilter(); filter.addaction(bluetoothadapter.action_state_changed); getactivity().registerreceiver(mbtbroadcastreceiver, filter);... M2 - SILI Développement sur Android 76
Interaction avec les évènements systèmes : le Bluetooth Application à la gestion du Bluetooth Être averti lors de l activation du Bluetooth L annulation doit être fait dans la méthode symétrique à celle de l enregistrement, ici onstop Annulation d un «broadcast receiver» @Override public void onstop() { super.onstop(); // Unregister broadcast receiver getactivity().unregisterreceiver(mbtbroadcastreceiver);... Il existe un grand nombre d évènements qui peuvent être ajoutés au même receiver (détection d un nouvel appareil, ) Une fois annulé, l application ne réagira plus à l évènement M2 - SILI Développement sur Android 77
Interaction avec les évènements systèmes : le Bluetooth Le Bluetooth Application à la gestion du Bluetooth Un objet BluetoothAdapter est nécessaire pour interagir, il correspond au composant de l appareil Il est ensuite possible de récupérer un grand nombre d informations sur le composant État et statistiques du composant Liste des appareils (devices) appairées etc. Il est aussi possible de lancer le scan (discovery) pour chercher de nouveaux appareils Chaque appareil est ensuite représenté par un objet de type BluetoothDevice : Nom, adresse, état (connecté ou non) La liste des informations et actions disponibles dépendent de la classe du périphérique M2 - SILI Développement sur Android 78
Interaction avec les évènements systèmes : le Bluetooth Application à la gestion du Bluetooth Utilisation de BluetothAdapter Accès aux BluetoothDevice La méthode getbondeddevices de BluetoothAdapter retourner l ensemble des appareils appairés Il ne reste plus qu à parcourir cet ensemble Parcours des appareils appairés BluetoothAdapter mbluetoothadapter = BluetoothAdapter.getDefaultAdapter(); if (mbluetoothadapter!= null) { Set<BluetoothDevice> paireddevices = mbluetoothadapter.getbondeddevices(); // If there are paired devices if (paireddevices.size() > 0) { // Loop through paired devices for (BluetoothDevice device : paireddevices) { Log.v(TAG,"Paired device: "+device.getname()+" "+ device.getbluetoothclass().getdeviceclass()); M2 - SILI Développement sur Android 79
Interaction avec les évènements systèmes : le Bluetooth Application à la gestion du Bluetooth En résumé Le mécanisme des broadcast receivers permet à une activité d être prévenue lors d évènements systèmes L activité doit s inscrire et se désinscrire de ces receivers dans les bonnes méthodes du cycle de vie Interagir avec le Bluetooth se fait facilement avec : Un BluetoothAdapter qui rend compte de l état du composant Bluetooth Un objet BluetoothDevice pour représenter un appareil Bluetooth lié ou non L API Bluetooth est bien plus riche (communication entre deux appareils) et la documentation d Android doit être lue avant tout développement conséquent M2 - SILI Développement sur Android 80