Discussion :

[lulz17]

Bonjour à tous,

Cela fait quelques temps que je m'inspire du forum pour résoudre mes erreurs et suivre les cours qui sont géniaux

Mais la je vais devoir vous demander conseil car je ne pige pas la logique...

J'utilise l'API Google Maps pour afficher des Markers qui sont stockés sur mon serveur. Au début, j'utilisais un simple Thread pour faire la requète HTTP et pour Parser le tableau JSON que je récupérais. Ensuite, pour chaque élément du tableau je faisais appel à un Handler. En effet, pour pouvoir ajouter un Marker sur la map il faut ètre sur l'activité principale (d'ou le role du Handler). Néanmoins, le Handler ne suivait le traitement effectuer dans un boucle pour chaque élement du tableau: sur 70 élements seulement une vingtaine s'affichaient ... Je devais cliquer au moins 3 fois sur mon bouton pour tout afficher.


En faisant quelque recherche, j'ai vu qu'il était préférable d'utiliser un AsyncTasck pour justement effectuer ce traitement en entier et récupérer les élements de mon tableau.

Voila comment fonctionne mon code:
-> Appel du ASynctasck depuis mon activité principale
-> Dans le AsyncTasck, la requète HTTP se passe et je Parse mon tableau (en utilisant les méthodes DoInBackground() & onPostExecute())
-> Comment transmetter mes Markers d'ici à l'activité principale ?

J'ai essayer deux méthodes pour résoudre mon problème (mais qui ne marche pas):
-> Appel d'une méthode de l'activité principale depuis l'ASyncTasck pour afficher les Markers. Problème: je suis pas dans la bonne activité (Activité princpale nécessaire pour ajouter les Markers).
-> Faire appel à une méthode dans l'activité principale (qui fera appel à un Getter de mon tableau JSON de l'AsyncTasck) à la suite de mon ASyncTasck.execute(). Problème: le traitement n'attend pas la fin d'éxecution de l'AsyncTasck et appel direct la méthode qui m'affichera un NullPointerException car mon tableau JSON est vide (depuis le Getter).


Si quelqu'un pourrait m'orienter sur mon problème car la je ne vois pas du tout comment la jouer!


++

[Hizin]

Il faut simplement que ton AsyncTask notifie ton Activity dans le onPostExecute, lui dire "eyh, j'ai fini, et voici les Markers !".

Pour ce faire, il faut que ton AsyncTask connaisse l'Activity ou le Fragment qui l'appelle et invoque une méthode (au hasard : putMarkersOnMap(List<Marker>) ).

C'est un pattern Observer à mettre en place en somme.

[lulz17]

Salut Hizin,

Merci de ta réponse

Je comprends un peu mieux la logique.

J'avais oublié de préciser mais lors de mes tests, j'ai remarquer que l'AsyncTasck continue de tourner en boucle ... Comment lui dire "hey, j'ai finis !" comme tu dis ?

Pour le pattern Observer, je vais regarder sa de plus prés. Merci encore de m'avoir mis sur la bonne piste !

[Hizin]

L'AsyncTask continue de tourner ?
Alors ton code doit avoir un problème. Une AsyncTask réalise le onPreExecute, puis le doInBackground, puis le onPostExecute.

Le onPostExecute n'est appelé qu'une fois le doInBackground est fini.

[lulz17]

Effectivement, il continue de tourner dans le vide .. J'avais utiliser une méthode bidon qui affichait un message bidon dans un while(AsynTasck.getStatus(RUNNING) et cela me faisait planter l'appli ^^

J'utilise le doInBackground pour faire ma requête http et le traitement JSON après je fais appel au onPostExecute() (dans ma méthode doInBackground) et de la bah j'étais bloqué.. Et je trouvais cela étonnant de devoir l'appelé moi même.

Je dois avoir une petite erreur de le code de l'AsyncTask ..

[nicroman]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Activity:
    * MyTask task = new MyTask(... parametres optionnels ...);
    * task.execute(PARAMS);
    * return;

Task:
(UI thread)    * onPreExecute()

Task:
(worker thread) * doInBackground(PARAMS);
                      * return RESULT;

Task:
(UI thread)    * onPostExecute(RESULT)
     * Activity.this.onTaskFinished(RESULT);

Activity:
    * onTaskFinished(RESULT)
    * ...;

[lulz17]

Salut Nicroman,

Merci pour ton post!

Je vais regarder sa ce week end et revenir rapidement pour mettre un résolu à cette discussion

[lulz17]

En cherchant un peu plus à comprendre comment fonctionnait les AsyncTasck et la manière la plus simple de notifier l'arrêt j'ai trouvé une ancienne discussion sur le forum --> http://www.developpez.net/forums/d12...n-d-asynctask/

Et j'ai pas trop réussit avec cette méthode: * Activity.this.onTaskFinished(RESULT);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

monAsyncTask.get();

Et ça marche du premier coup

merci à tous

[nicroman]

get() ?

Normalement tu n'as jamais besoin d'appeler cette fonction.
On pourrait voir ton code ?

[Hizin]

AsyncTask#get() réduit considérablement l'intérêt de l'AsyncTask.
Cette méthode demande le résultat et est bloquante pour le thread qui l'appelle. Si l'AsyncTask n'a pas finie son traitement, le thread appelant se met en pause jusqu'à ce qu'il obtienne le retour, faisant un traitement équivalent à l'absence d'AsyncTask. Comme le souligne nicroman, tu ne devrais pas en avoir besoin.

[lulz17]

Ok, je n'avais pas remarquer l'activité ce bloquait lors de mes premiers tests .. Effectivement, cela est totalement inutile ...

Bon je vais mettre mon code cela sera plus simple!

MainActivity.java

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
 
public class MainActivity extends FragmentActivity implements LocationListener {
 
protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activitymain);
 
 
 
		session = new SessionManager(getApplicationContext());
 
Toast.makeText(getApplicationContext(), "User Login Status: " + session.isLoggedIn(), Toast.LENGTH_LONG).show();
					 session.checkLogin();
 
Button B3 =  (Button)findViewById(R.id.button_message);
		B3.setClickable(true);
 
		B3.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
 
            	Afficher_Marker();
        }
            });
}
 
 
public void Afficher_Marker()
	{
 
		AsyncTaskRunner AST = new AsyncTaskRunner();
		AST.execute("http://www.monsite.com/GetIncident.php");
}
 
 
}

AsyncTaskRunner.java

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
 
public class AsyncTaskRunner extends AsyncTask<String, Void, JSONArray >  {
 
	String ville ="";
	final static HttpClient client = new DefaultHttpClient();
	 final HttpPost post = new HttpPost();
	 static HttpResponse response;
	 static JSONArray jObj = null;
	 static String json = "";
	 MarkerOptions markerr;
 
	 JSONObject JO = null;
		String latt;
		String longg;
		Double l1 = null;
		Double l2= null;
 
	protected JSONArray doInBackground(String... arg0) {
		// TODO Auto-generated method stub
 
		HttpConnectionParams.setConnectionTimeout(client.getParams(), 10000); //Timeout Limit
		final HttpPost post = new HttpPost(arg0[0]);
 
         try {
        	ville = MainActivity.getVille();
        	 final ArrayList<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(1);
    		 nameValuePairs.add(new BasicNameValuePair("ville", " "+ville));
    		 System.out.println(ville);
 
    		 post.setEntity(new UrlEncodedFormEntity(nameValuePairs));
			response = client.execute(post);
		} catch (ClientProtocolException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
 
 
 
 
 
         /*Checking response */
         if(response!=null){
 
 
 
 
             try {
            	  InputStream in = response.getEntity().getContent(); //Get the data in the entity
     			BufferedReader reader = new BufferedReader(new InputStreamReader(
     					in, "iso-8859-1"), 8);
     			StringBuilder sb = new StringBuilder();
     			String line = null;
     			while ((line = reader.readLine()) != null) {
     				sb.append(line + "\n");
 
     				json = sb.toString();
     				jObj = new JSONArray(json);
 
 
     			}
     			in.close();
 
 
 
 
     		} catch (Exception e) {
     			Log.e("Buffer Error", "Error converting result " + e.toString());
     		}
         }
 
 
 
		return jObj;
	}
 
 
protected void onPostExecute(JSONArray jObj) 
	  {
 
 
 
		 if(jObj != null)
		 {
                   // ... 
		  }
 
 
		 return jObj; 
 
}

Je n'ai pas encore réussi à à appliquer les conseils que vous m'avez donné dans vos précédents post. J'ai été plus limité par le temps que je le pensais et par ma fausse joie d'avoir trouver quelque chose d'inutile ^^

[nicroman]

Bon alors commençons par l'utilisation type de AsyncTask:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
// Note: pas forcément Activity, ca peut être Fragment, ou tout autre objet "graphique".
class MaSuperActivity extends Activity
{
 
    // Dans le on-create... mais ca pourrait être ailleurs dans un "onClick" par exemple
    public void onCreate() {
         ...
         MySuperTask task = new MySuperTask();
         task.execute(PARAMS);
    }
 
    // sera appelé par MySuperTask
    public void onMySuperTaskResult(RESULTS results)
    {
        // action sur l'UI
    }
 
    // appelé pour afficher un dialog de progress (et disabler l'interface ?)
    public void startProgress() { }
 
    public void stopProgress() {}
 
 
    // la subtilité: une classe *fille*
    // inconveniant: utilisable *que* dans l'activité
    // avantage: reference sur l'activité par MaSuperActivity.this
    class MySuperTask extends AsyncTask<PARAMS,Void,RESULTS>
    {
          public void onPreExecute()
          {
               MaSuperActivity.this.startProgress();
          }
 
          public void onPostExecute(RESULTS res)
          {
               MaSuperActivity.this.stopProgress();
               if (res != null)
                   MaSuperActivity.this.onMySuperTaskResult(res);
          }
 
          public RESULTS doInBackground(PARAMS ...)
          {
                 ... 
          }
     }
}

Maintenant, il y a une version à deux fichiers (réutilisation de la "task" possible):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
class MySuperTask extends AsyncTask<PARAMS,Void,RESULTS>
{
      public static interface Callback
      {
            public void onMySuperTaskResults(RESULTS);
            public void startProgress();
            public void stopProgress();
      }
 
      private Callback callback;
 
      public MySuperTask(Callback cb) { this.callback = cb; }
 
      public void onPreExecute()
      {  this.callback.startProgress(); }
 
      public void onPostExecute(RESULTS res)
      {  this.callback.stopProgress();
          if (res != null) this.callback.onMySuperTaskResults(res); }
 
      public RESULTS doInBackground(PARAMS ...)
      {
          ...
      }
}

Et l'activité:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
class MaSuperActivity extends Activity implements MySuperTask.Callback
{
 
    // Dans le on-create... mais ca pourrait être ailleurs dans un "onClick" par exemple
    public void onCreate() {
         ...
         MySuperTask task = new MySuperTask(this);
         task.execute(PARAMS);
    }
 
    public void onMySuperTaskResults(RESULTS) { ... }
    public void startProgress() { ... }
    public void stopProgress() { ... }
}

Et pour finir un mot sur ton code. A chaque fois qu'on colle une variable, il faut se demander si elle fait sens, et sa durée de vie.
Par exemple... le HTTPClient a-t-il sens pour toute la durée de vie de la tâche ? non évidemment, elle n'a de sens *que* pendant le doInBackground.
Pareil pour JSONObject... il y a peu de chances pour que l'UI ai besoin d'un JSONObject ! Donc autant le "traduire" pendant le doInBackground.

Ensuite le code du doInBackground ne va pas... surtout pour les exceptions (et les Log).
Voici un exemple de doInBackground qui fait *exactement* la même chose mais correctement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
 
private static final String INCIDENT_URL = "http://www.monsite.com/GetIncident.php";
 
// on passe "ville" en paramètre à l'execute... on ne fait pas un getVille() statique (qui risque d'appeler l'UI dans un thread à part en prime) !
// par contre l'URL est dépendante du web-service et de la task... donc... statique locale à la tâche (les utilisateurs de la tâches n'ont pas à connaitre cette URL).
public JSONArray doInBackground(String ... ville)
{
 
     JSONArray ret = null;
     try {
         // construction de l'environnement HTTP
         HttpConnectionParams.setConnectionTimeout(client.getParams(), 10000);
         HttpClient client = new DefaultHttpClient();
 
         // construction du Post
         HttpPost post = new HttpPost(INCIDENT_URL);
         ArrayList<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(1);
    	 nameValuePairs.add(new BasicNameValuePair("ville", " "+ville)); // pourquoi " " avant ?
         post.setEntity(new UrlEncodedFormEntity(nameValuePairs));
 
         // envoi du post et reception
	 HttpResponse response = client.execute(post);
 
         // pas besoin de faire compliqué avec des stream (mal fermés)
         String jsonStr = EntityUtils.toString(response.getEntity());
 
         // on transforme en JSON... mais encore une fois, il peut
         // valoir le coup d'en profiter et décoder ICI le JSON en truc plus typés !
         ret = new JSONArray(jsonStr);
 
     } catch (Exception ex) {
        Log.e("AsyncTaskRunner", "Error getting reuslts",e); // noter le passage de l'exception en parametre !
     }
     return ret;
}

[lulz17]

Merci pour tes explications Nicroman! Vraiment top de ta part :cool:

Je vais essayer sa tout de suite! Et je reviendrai pour dire si j'ai bien résolus le problème.

C'est vrai que mon code n'est pas bien écrit, je m'en cache pas. La dessus, j'ai beaucoup d'effort à faire! Mais je passe tellement de temps à remanier le code que ça devient vite n'importe quoi. Tant que j'ai pas une version stable du bout de la feuille je prends pas le temps de la nettoyer ... C'est pas top je sais mais c'est souvent pas manque de temps.

Cela ne justifie en rien ce que tu viens de dire et tu fais bien de me le rappeler! Je prendrai plus de temps sur ça par la suite.

[lulz17]

J'ai repris les grandes lignes que tu m'as donné et ça marche nickel.

Je vais prendre le temps de compléter avec le reste et de m'appliquer un peu sur la syntaxe (les Logs) et de l'utilisation correct du code.

Je posterai ce que j'aurai pu faire si cela peut aider un autre utilisateur.

Encore

[Hizin]

A ce compte-là, je vais faire un passage avec les conventions Java :

Classes en UpperCamelCase : débutent pas une majuscule, puis majuscule à chaque mot. Pas de tiret bas.
Variables & méthodes en lowerCamelCase : débutent par une minuscule, puis majuscule à chaque mot. Pas de tiret bas.
Constantes en MAJUSCULES_AVEC_TIRET_BAS_COMME_SEPARATEUR : c'est le seul endroit où les tirets bas sont acceptés

En dehors de ça : mets des noms explicatifs ! Prends un peu de temps pour bien nommer tes variables, ça épargne énormément de temps après coup (et les refactorer au besoin quand elles ont changés d'utilités).

[lulz17]

Merci Hizin pour la suite des conseils & méthodes, je les prends

Je vais me faire une bonne session "nettoyage" avant de continuer le reste.