La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Android_Thread et + 1 Android UIThread, Thread, Handler et AsyncTask Notes de cours jean-michel Douin, douin au cnam point fr version : 28 Novembre 2013.

Présentations similaires


Présentation au sujet: "Android_Thread et + 1 Android UIThread, Thread, Handler et AsyncTask Notes de cours jean-michel Douin, douin au cnam point fr version : 28 Novembre 2013."— Transcription de la présentation:

1 Android_Thread et + 1 Android UIThread, Thread, Handler et AsyncTask Notes de cours jean-michel Douin, douin au cnam point fr version : 28 Novembre 2013

2 Android_Thread et + 2 Bibliographie utilisée Un ensemble de tutoriels à lire StrictMode (intégré en 4.0)

3 Android_Thread et + 3 Pré-requis Les threads en java –java.lang.Thread –java.lang.Runnable

4 Android_Thread et + 4 Sommaire UIThread déclenche une activity et gère lIHM –Les appels des « onXXXX » cest lui Thread, Handler, du java traditionnel AsyncTask, adapté et créé pour se passer du traditionnel StrictMode Aide au développement « correct » Inclus dès 4.0

5 Android_Thread et + 5 UIThread Gère laffichage de lActivity : –Prise en compte des évènements de lutilisateur Clic, déplacements, … … –Exécution des Listeners associés … LUIThread est le seul Thread « agréé » –Pour laffichage au sein dune activité Accès à lun des composants graphiques Les évènements liés à laffichage sont gérés par une file Alors –Toutes les opérations de mises à jour, modifications de lIHM doivent seffectuer depuis cet UIThread

6 Android_Thread et + 6 En « rappel » Une application engendre un processus linux A ce processus est associée une DVM Cette DVM installe des Threads Parmi ces Threads, –Un thread est nommé main alias UIThread Le thread main alias UIThread –Crée, initialise lactivité, –Déclenche les méthodes selon le cycle de vie –Et est chargé de laffichage, –De la prise en charge des actions de lutilisateur

7 Android_Thread et + 7 Exemples, et démonstration Exemples à ne pas suivre … Exemple 1 –La méthode onCreate contient un appel à Thread.sleep(30000) ! Un affichage est souhaité Thread.sleep(30000); –Ou SystemClock.sleep(30000); -> ce nest qu au bout de 30000ms que laffichage se produit !! –Cycle de vie … rappel

8 Android_Thread et + 8 En « rappel » le cycle de vie Thread.sleep(30000);

9 Android_Thread et + 9 Exemples suite, et démonstrations Exemple 2 –Au clic sur un bouton : Thread.sleep est appelée … –Ou bien SystemClock.sleep Un affichage est souhaité …

10 Android_Thread et + 10 Exemple à ne pas suivre : une IHM au ralenti Un clic déclenche la méthode faireQuelqueChose –LUIThread sendort … une seconde, deux secondes … et … et pas daffichage…

11 Android_Thread et + 11 IHM: affichage seulement au bout de 5 sec. Cest seulement au bout de 5 secondes –Quun nouveau clic devient possible, –Que la jauge est accessible (répond aux sollicitations de lutilisateur) –Laffichage nest pas effectué toutes les secondes comme la lecture du source le laisse supposer Démonstration de lexemple à ne pas suivre –Un seul affichage (visible) au temps écoulé : 5 sec !

12 Android_Thread et + 12 Démonstration Ici 5 secondes et avec appels de Log.i –Toujours rien à lécran, sauf au bout de 25 sec. –Les affichages ne sont pas pris en compte, lUIThread passe son temps à sendormir

13 Android_Thread et + 13 LUIThread gère lIHM et seulement Une première conclusion, par la force des choses… –Toutes les opérations coûteuses en temps dexécution doivent être placées dans un autre Thread, mais pas nimporte lequel…(lUIThread est réservé à lIHM) Ce qui arrive quand lUIThread est bloqué plus de 5 sec., Android considère que votre application ne répond plus cf. ANR, Application Not Responding

14 Android_Thread et + 14 Rappel : les Threads en java Rappels: les 5 prochaines diapositives peuvent être optionnelles Un Thread en java, –une classe, une interface, deux méthodes essentielles La classe java.lang.Thread Linterface java.lang.Runnable Les deux méthodes –start éligibilité du Thread, –run le code du Thread »issue de public interface Runnable{void run();}

15 Android_Thread et + 15 Contexte : Quasi-parallèle t1, t2, t3 sont des « Threads » t1t2t3 t1t2t3 vue logique vue du processeur activité du processeur ordonnancement

16 Android_Thread et + 16 Rappel : La classe java.lang.Thread Syntaxe : Création d une nouvelle instance Thread unThread = new T (); … T extends Thread (un(e) Thread pour processus allégé...) « Démarrage » du thread –unThread.start(); éligibilité de UnThread « Exécution » du thread –L ordonnanceur interne déclenche la méthode run() (unThread.run();)

17 Android_Thread et + 17 Rappel : java.langThread, syntaxe public class T extends Thread{ public void run(){ // traitement } Thread t = new T(); t.start(); // autre syntaxe, à laide dune classe anonyme Thread t = new Thread( new Runnable(){ public void run(){ // traitement } }); t.start();

18 Android_Thread et + 18 Runnable, autre syntaxe Runnable r = new Runnable(){ public void run(){ // traitement } }; new Thread(r).start();

19 Android_Thread et + 19 Reprenons lexemple à ne pas suivre Une « solution » serait de créer un Thread qui sendort pendant 5 * 1sec Au clic un Thread est créé onClick UIThread Un Thread

20 Android_Thread et + 20 Au clic un thread est créé faire quelque chose engendre un thread –UIThread devient disponible pour les sollicitations de lutilisateur, Sur cet exemple le curseur de la jauge devient accessible onClick UIThread Un Thread

21 Android_Thread et + 21 Sendormir dans un autre Thread

22 Android_Thread et + 22 Démonstration Cest mieux, –Le clic devient possible, –La jauge répond aux sollicitations avant les 5 secondes Mais

23 Android_Thread et + 23 Mais –Plus daffichage du tout … –Cet autre Thread ne doit pas tenter de modifier lIHM, »Nul ne peut se substituer à lUIThread … »Comportement incertain …

24 Android_Thread et + 24 Première solution Création dun Thread + Accès prédéfinis à lUIThread –envois de séquences daffichage runOnUIThread – envois de messages android.os.Handler, –Méthodes post, send, handleMessage …

25 Android_Thread et + 25 Accès à lUIThread Envois de séquences daffichage –runOnUiThread (Runnable r){… Méthode héritée de la classe Activity –Ou bien une instance de la classe Handler unHandler.post( Runnable r){ … Envois de messages –Avec une instance de la classe Handler unHandler.send( Message m){ … Ou le cumul des deux fonctionnalités Ce sera la classe AsyncTask

26 Android_Thread et + 26 Envoi de séquences daffichage Dépôt dans la file dattente de lUIThread runOnUIThread(Runnable r), –Cest une méthode de la classe Activity r est placé dans la file de lUIThread, –Avec une exécution immédiate si lappelant est lUIThread onClick ! UIThread unThread runOnUIThread(r) r

27 Android_Thread et + 27 runOnUIThread Tout semble correct

28 Android_Thread et + 28 runUIThread est héritée Tout semble correct –runOnUIThread est bien héritée de la classe Activity

29 Android_Thread et + 29 Affichage de 1,2,3,4 sec, enfin Ok Démonstration

30 Android_Thread et + 30 Une autre façon de faire android.os.Handler –Permet de poster des instructions dans la file de lUIThread Analogue à lusage de runOnUIThread –Permet aussi de poster des messages à lattention de lUIThread

31 Android_Thread et + 31 Handler … idem à runOnUIThread android.os.Handler –Cf. runOnUIThread –handler comme variable dinstance de lactivity

32 Android_Thread et + 32 Handler en Progress : il ny a quun pas Linterface sest enrichie dun « ProgressBar

33 Android_Thread et + 33 En progress, mais de moins en moins lisible…

34 Android_Thread et + 34 Une autre façon de faire, le retour Poster un message à destination de lUIThread Par exemple –informer lutilisateur du déroulement dun traitement Un top toutes les secondes –Il faut Obtenir une instance de message Installer au sein de lactivité, – la gestion du message par une méthode du handler »handleMessage est redéfinie

35 Android_Thread et + 35 Handler, Message et la classe Looper

36 Android_Thread et + 36 Réception dun message toutes les sec. Un handler comme variable dinstance de lactivité –Redéfinition de la méthode handleMessage

37 Android_Thread et + 37 LActivity Un Thread –Qui à chaque seconde, 1.Obtient un message identifié par un paramètre (i) 2.Envoie ce message –Le paramètre i correspond au champ msg.what

38 Android_Thread et + 38 Au sein de lActivity Envoi + réception du message –i == msg.what

39 Android_Thread et + 39 Messages à destination de lUIThread Un exemple classique –Extrait de android-n%C2%B022/03/02/2011/ android-n%C2%B022/03/02/2011/ –Une Activity avec deux longs, très longs calculs Un Thread se charge des deux calculs –Comment informer lutilisateur tout au long des calculs ? Au démarrage, Entre deux calculs, Dune erreur, De la fin

40 Android_Thread et + 40 Comment informer lutilisateur ? Attribut onClick … de lunique bouton de linterface (start) –Méthode onClickStart public void onClickStart(View v){ mProgressDialog = ProgressDialog.show(this, "Patience", "de longs calculs commencent...", true); Runnable r = new Runnable(){ public void run(){ // le premier calcul débute doLongOperation1(); // et maintenant le deuxième calcul doLongOperation2(); // voilà cest fini }}; new Thread(r).start(); }

41 Android_Thread et + 41 Copie décran de ce que lon souhaiterait Deux ProgressDialog et pour terminer un toast

42 Android_Thread et + 42 Comment informer lutilisateur ? Un handler est créé Des messages lui sont envoyés, Looper sen charge public void onClickStart(View v){ mProgressDialog = ProgressDialog.show(…); Runnable r = new Runnable(){ public void run(){ // message = le premier calcul débute // envoi du message à destination du handler doLongOperation1(); // message = maintenant le deuxième calcul // envoi du message à destination du handler doLongOperation2(); // message = voilà cest fini // envoi dun message à destination du handler }}; new Thread(r).start(); }

43 Android_Thread et + 43 onClickStart est décoré, MSG_IND==1, MSG_END==2 public void onClickStart(View v){ mProgressDialog = ProgressDialog.show(this, "Patience", "de longs calculs commencent...", true); Runnable r = new Runnable(){ public void run(){ String progressBarData = "le premier calcul débute..."; Message msg = mHandler.obtainMessage(MSG_IND, (Object) progressBarData); mHandler.sendMessage(msg); doLongOperation1(); progressBarData = "et maintenant le deuxième calcul..."; msg = mHandler.obtainMessage(MSG_IND, (Object) progressBarData); mHandler.sendMessage(msg); doLongOperation2(); progressBarData = "voilà c'est fini..."; msg = mHandler.obtainMessage(MSG_END, (Object) progressBarData); mHandler.sendMessage(msg); }}; new Thread(r).start(); }

44 Android_Thread et + 44 Un Handler est créé, redéfinition de handleMessage final Handler mHandler = new Handler() { public void handleMessage(Message msg) { if (mProgressDialog.isShowing()) { if(msg.what==MSG_IND) mProgressDialog.setMessage(((String) msg.obj)); if(msg.what==MSG_END){ Toast.makeText(getBaseContext(),"Info:" + (String)msg.obj, Toast.LENGTH_LONG ).show(); mProgressDialog.dismiss(); } }}};

45 Android_Thread et + 45 Envoi et réception final Handler mHandler = new Handler() { public void handleMessage(Message msg) { if (mProgressDialog.isShowing()) { if(msg.what==MSG_IND) mProgressDialog.setMessage(((String) msg.obj)); if(msg.what==MSG_END){ Toast.makeText(getBaseContext(),"Info:" + (String)msg.obj, Toast.LENGTH_LONG ).show(); mProgressDialog.dismiss(); } }}}; public void onClickStart(View v){ mProgressDialog = ProgressDialog.show(this, "Patience", "de longs calculs commencent...", true); Runnable r = new Runnable(){ public void run(){ String progressBarData = "le premier calcul débute..."; Message msg = mHandler.obtainMessage(MSG_IND, (Object) progressBarData); mHandler.sendMessage(msg); doLongOperation1(); progressBarData = "et maintenant le deuxième calcul..."; msg = mHandler.obtainMessage(MSG_IND, (Object) progressBarData); mHandler.sendMessage(msg); doLongOperation2(); progressBarData = "voilà c'est fini..."; msg = mHandler.obtainMessage(MSG_END, (Object) progressBarData); mHandler.sendMessage(msg); }}; new Thread(r).start(); } 1 2 3

46 Android_Thread et + 46 Copie décran obtenu … à quel prix … mais avec lhabitude ?

47 Android_Thread et + 47 Un premier résumé UIThread : à préserver Thread pas facile et ne suffit pas toujours –Rappel : Pas de thread autre que lUIThread pour gérer laffichage Handler –Une interface avec lUIThread post( une instance de Runnable sendMessage( un message Existe-t-il une classe toute prête et simplificatrice ? –UI ! –AsyncTask

48 Android_Thread et + 48 AsyncTask Avec la classe, AsyncTask –http://developer.android.com/reference/android/os/AsyncTask.htmlhttp://developer.android.com/reference/android/os/AsyncTask.html Nous avons un thread et un handler créés en interne Un thread : pour le traitement en tâche de fond Un handler : pour la mise à jour de lUI –Params type des paramètres transmis au Thread (tâche de fond) –Progress type des paramètres en cours de traitement transmis au Handler/UIThread –Result type du résultat pour lappelant

49 Android_Thread et + 49 AsyncTask Les méthodes publiques pour les clients –Une méthode pour lutilisateur execute(param1, param2, param3) Dautres méthodes publiques existent –cancel, get, executeOnExecutor, …

50 Android_Thread et + 50 Schéma de programme, syntaxe, AsyncTask public void onStart(){ … WorkAsyncTask wt = new WorkAsyncTask(); wt.execute(string1, string2, string3); … } private class WorkAsyncTask extends AsyncTask { }

51 Android_Thread et + 51 class WorkAsyncTask extends AsyncTask Les méthodes héritées –En liaison directe avec lUI Thread –doInBackground doit être redéfinie dans WorkAsyncTask –http://developer.android.com/reference/android/os/AsyncTask.htmlhttp://developer.android.com/reference/android/os/AsyncTask.html –publishProgress déclenche, appelle onProgressUpdate La quantité de sable du sablier …

52 Android_Thread et + 52 Schéma de programme, syntaxe, AsyncTask public void onStart(){ … WorkAsyncTask wt = new WorkAsyncTask(); wt.execute(string1, string2, string3); … } private class WorkAsyncTask extends AsyncTask { void onPreExecute() { // faire patienter lutilisateur, affichage dun sablier… Boolean doInBackGround(String... t){ // effectuer la tâche coûteuse en temps // t[0]/string1, t[1]/string2,… void onProgressUpdate(Long... v) { // informer lutilisateur que le traitement est en cours void onPostExecute(Boolean b) { // le sablier disparaît, une éventuelle erreur est affichée }

53 Android_Thread et + 53 Diagramme de séquences simplifié Discussions :Activity new :AsyncTask execute(p1,p2,p3) cancel() get() :UIThread:BackGroundThread onPreExecute() doInBackGround(p1,p2,p3) publishProgress(i1,i2,i3) onProgressUpdate(i1,i2,i3) onPostExecute(r1) return r1

54 Android_Thread et + 54 Exemple initial revu : affichage de 1,2,3,4 sec AsyncTask

55 Android_Thread et + 55 AsyncTask À chaque clic : new ProgressBarTask().execute(); private class ProgressBarTask extends AsyncTask { protected Integer doInBackGround(Void... v){ Pendant 5 fois sendormir une seconde prévenir laffichage à chaque seconde écoulée void onProgressUpdate(Integer... v) { afficher la seconde écoulée }

56 Android_Thread et + 56 Lexemple initial avec AsyncTask, plus simple… ? Tout est bien qui finit bien, –LUIThread gère lIHM –ProgressBar progresse, (cest lisible, nous sommes en progrès (facile…)) à chaque appel de publishProgress (lUIThread est réactualisé avec onProgressUpdate)

57 Android_Thread et + 57 Une autre version, 5 Thread * 1 sec À chaque clic : for(int i=1; i<=5; i++) new ProgressBarTask().execute(i); private class ProgressBarTask extends AsyncTask { protected Integer doInBackGround(Integer... t){ sendormir une seconde prévenir laffichage t[0] à chaque seconde écoulée void onPostExecute(Integer v) { afficher la seconde écoulée est appelée avec le résultat retourné par doInBackGround

58 Android_Thread et + 58 Lexemple avec AsyncTask, moins simple, en 5 Threads Un autre découpage en tâche élémentaire de 1 sec… Discussion... Démonstration

59 Android_Thread et + 59 Reprenons lexemple des longs calculs… ProgressDialog et pour terminer portons un toast

60 Android_Thread et + 60 Simplissime … Pas de Handler, pas de messages, … public void onClickStart(View v){ new LongsCalculs().execute(); } private class LongsCalculs extends AsyncTask { // transparent suivant }

61 Android_Thread et + 61 AsyncTask private class LongsCalculs extends AsyncTask { private ProgressDialog mProgressDialog; private Context thiss = LongsCalculsActivity.this; protected void onPreExecute() { mProgressDialog = ProgressDialog.show(thiss, "Patience", "de longs calculs commencent...", true); } protected String doInBackground(Void... inutilisé) { publishProgress("le premier calcul débute..."); doLongOperation1(); publishProgress("et maintenant le deuxième calcul..."); doLongOperation2(); return "voilà c'est fini"; } protected void onProgressUpdate(String... result){ mProgressDialog.setMessage(result[0]); } protected void onPostExecute(String s){ Toast.makeText(getBaseContext(), "Info: " + s, Toast.LENGTH_LONG).show(); mProgressDialog.dismiss();}}

62 Android_Thread et + 62 En résumé AsyncTask Depuis lUIThread –création dune instance et appel de la méthode execute Exemple new WorkAsyncTask().execute(str1, str2, str3); AsyncTask –Réalise une encapsulation dun Thread et dun Handler Méthodes onPreExecute() –Préambule, lUI exécute cette méthode Result doInBackground(Params…p) –Le contenu de cette méthode sexécute dans un autre Thread onProgressUpdate(Progress…p) –Mise à jour de lUI à la suite de lappel de publishProgress onPostExecute(Result) –Mise à jour de lUI à la fin de la méthode doInBackground

63 Android_Thread et + 63 Précautions … AsyncTask

64 Android_Thread et + 64 Résumé, conclusion Attention à la gestion de lécran –Laissons cet UIThread gérer tous les évènements de lutilisateur Alors Chaque opération coûteuse en temps dexécution se fera dans un autre Thread Si ce Thread doit interagir avec lécran (ProgressBar) alors –runOnUIThread, Handler représentent une solution AsyncTask »Est une autre solution avec une encapsulation (réussie) dun thread et dun handler Alors AsyncTask nous préfèrerons En annexe : Accès au Web, utilisation dAsyncTask

65 Android_Thread et + 65 Annexe Lecture dune page HTML Lactivité est détruite mais le Thread continue Outil de supervision

66 Android_Thread et + 66 Le patron Command/AsyncTask Cf. Command/NSY102 Discussion

67 Android_Thread et + 67 AsyncTask et réseau, un exemple Lire une page sur le web HTTP, requête GET –private class LirePageHTML extends AsyncTask { Schéma onPreExecute Afficher une fenêtre dinformations, ProgressDialog doInBackGround Ouvrir une connexion, avec un échec éventuel onPostExecute Informer lutilisateur

68 Android_Thread et + 68 Lire la page Si jai la permission … de naviguer sur le web – –Une IHM simple –Laccès au web est une opération coûteuse alors héritons de AsyncTask

69 Android_Thread et + 69 Une classe interne héritant de AsyncTask protected String doInBackground(String... args) { builder = new StringBuilder(); try { HttpClient client = new DefaultHttpClient(); HttpGet httpGet = new HttpGet(args[0]); HttpResponse response = client.execute(httpGet); StatusLine statusLine = response.getStatusLine(); int statusCode = statusLine.getStatusCode(); if (statusCode == 200) { HttpEntity entity = response.getEntity(); InputStream content = entity.getContent(); BufferedReader reader = new BufferedReader( new InputStreamReader(content)); String line; while ((line = reader.readLine()) != null) { builder.append(line); } } else {error = "Failed to download file";} } catch (Exception e) {error = e.getMessage();} return builder.toString();}

70 Android_Thread et + 70 Annexes asynctask-demistified.htmlhttp://som-itsolutions.blogspot.fr/2011/10/android- asynctask-demistified.html Le patron Command Lactivité est détruite, –Que devient le Thread ? Mise au point, déploiement

71 Android_Thread et + 71 Schéma de programme, syntaxe, AsyncTask public void onStart(){ … this.wt = new WorkAsyncTask(); wt.execute( string1, string2, string3 ); } private class WorkAsyncTask extends AsyncTask { void onPreExecute() { // affichage dun sablier… Boolean doInBackGround( String... t ){ // t[0]/string1, t[1]/string2,… } execute(string1,string2,string3) onPreExecute est appelée doInBackGround(string1,string2,string3

72 Android_Thread et + 72 Schéma de programme, syntaxe, AsyncTask public void onStart(){ … this.wt = new WorkAsyncTask(); wt.execute(string1, string2, string3); … } private class WorkAsyncTask extends AsyncTask { Boolean doInBackGround(String... t){ boolean resultat.. while(condition){ … publishProgress( valeur ) } return resultat; } void onProgressUpdate( Long... v ) { // informer lutilisateur que le traitement est en cours v[0] == valeur } doInBackGround publishProgress déclenche onProgressUpdate

73 Android_Thread et + 73 Schéma de programme, syntaxe, AsyncTask public void onStart(){ … this.wt = new WorkAsyncTask(); wt.execute(string1, string2, string3); … } private class WorkAsyncTask extends AsyncTask { Boolean doInBackGround(String... t){ return resultat; } void onPostExecute(Boolean b) { } doInBackGround se termine onPostExecute est appelée

74 Android_Thread et + 74 Schéma de programme, syntaxe, AsyncTask public void onStop(){ … wt.cancel(true); // true: le thread ( doInBackGround) peut être interrompu … } private class WorkAsyncTask extends AsyncTask { Boolean doInBackGround(String... t){ while(!isCancelled()){ // } return resultat; } void onCancelled(Boolean result) { } onCancelled est appelée doInBackGround se termine

75 Android_Thread et + 75 Lactivité est détruite Un thread est créé Lactivité sarrête, moult raisons Le thread est encore là

76 Android_Thread et + 76 Un autre exemple, avec sauvegarde dun thread Cf. Cycle de vie dune activité –Suspension pendant une communication … Rappel –Une rotation de lécran entraîne un arrêt puis un nouveau démarrage de lactivité, ce qui nécessite une sauvegarde des données de lactivité et sa restitution. –Il existe bien dautres possibilités darrêter lactivité en cours ET si un thread était en pleine activité… Lecture dune page sur le web, calculs intenses, …

77 Android_Thread et + 77 Une solution –Classe interne et statique + Variable de classe + Thread Un thread, indépendant du cycle de vie –(Nous préférerons un service) très inspiré de

78 Android_Thread et + 78 A la création public class ThreadStaticActivity extends Activity { private static ProgressDialog dialog; private static Handler handler; private static Thread horloge; public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); handler = new Handler(); // restitution éventuelle horloge = (Thread) getLastNonConfigurationInstance(); if (horloge != null && horloge.isAlive()) { dialog = ProgressDialog.show(this, "horloge", horloge.toString()); }

79 Android_Thread et + 79 Démarrage et Sauvegarde au cas où public void onClickStart(View v){ horloge = new Horloge(); horloge.start(); dialog = ProgressDialog.show(this, "horloge", horloge.toString()); public Object onRetainNonConfigurationInstance() { return horloge; }

80 Android_Thread et + 80 Horloge interne et statique … discussions public static class Horloge extends Thread{ private final static int MN = 60*1000; private final static int PERIODE = 10*1000; private int compteur = 0; public String toString(){ return Integer.toString(compteur); } public void run(){ while(compteur<(3*MN)/PERIODE){ // arrêt au bout de 3 mn try{ Thread.sleep(PERIODE); }catch(Exception e){} compteur++; } handler.post(new Runnable(){ // dismiss dans lUIThread public void run(){ dialog.dismiss(); } }); }}

81 Android_Thread et + 81 Copies décran LIHM est réactualisée à chaque rotation de lécran… –À chaque rotation sauvegarde du Thread …

82 Android_Thread et + 82 Mise au point, déploiement Outils graphiques prédéfinis StrictMode

83 Android_Thread et + 83 Déploiement, débogage Chaque appel de méthode est recensé –Outil traceview

84 Android_Thread et + 84 StrictMode, se souvenir Se souvenir des règles dutilisation de lUIThread et pas seulement, StrictMode le détecte –http://android-developers.blogspot.com/2010/12/new-gingerbread-api-strictmode.htmlhttp://android-developers.blogspot.com/2010/12/new-gingerbread-api-strictmode.html En cours de développement seulement –Lapplication sarrête, avec une explication trace LogCat D Debug if(DEVELOPER_MODE){ StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder().detectAll().penaltyLog().penaltyDeath().build()); StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder().detectAll().penaltyLog().penaltyDeath().build()); Ou StrictMode.enableDefaults(); API_

85 Android_Thread et + 85 La classe Looper, en détail Looper.loop() –Retrait des messages de la file dattente –Chaque message possède son Handler Dont la méthode handleMessage(Message msg) est appelée Suis-je dans lUIThread ? –Looper.getMainLooper().getThread().equals(Thread.currentThread()) –Looper.getMainLooper().equals(Looper.myLooper()) DDMS pour en savoir plus

86 Android_Thread et + 86 DDMS Méthode Looper.loop appelée depuis le thread main

87 Android_Thread et + 87 extensions possibles Comme serveur –Un serveur web sur votre mobile … –Cf. lapplication PawServer Déploiement & Développement –Pannes possibles, le wifi disparaît, le tunnel apparaît, ( le prévoir…) –StrictMode

88 Android_Thread et + 88 Un serveur web sur votre mobile (wifi) Attention, –Lancer lémulateur une fois connecté wifi (et non 3G) –depuis lémulateur accéder au serveur installé sur le PC hôte nest pas localhost mais –http://developer.android.com/guide/developing/tools/emulator.htmlhttp://developer.android.com/guide/developing/tools/emulator.html –Proxy : Settings.System.putString(getContentResolver(), Settings.System.HTTP_PROXY, "myproxy:8080");

89 Android_Thread et + 89


Télécharger ppt "Android_Thread et + 1 Android UIThread, Thread, Handler et AsyncTask Notes de cours jean-michel Douin, douin au cnam point fr version : 28 Novembre 2013."

Présentations similaires


Annonces Google