Discussion :

[Didier_Agritechtrade]

Bonjour à tout les développeurs android,
y aurait-il des personnes de la communauté qui pourraient m'aider?
Je développe actuellement une application Android et j'ai un petit problème d'affichage.
Un écran noir fait disparaître le préload lorsque je teste la fin du téléchargement (du Thread).
préload : affichage d'une petite roue qui tourne pendant le téléchargement pour faire patienter l'utilisateur.

Ennoncé du problème :
*******************
Dans ma classe principale, j'instancie la classe_téléchargement puis j'appelle sa méthode Web_Service.
La méthode Web_Service :
- Appelle à la classe Thread qui télécharge les données et les insère dans un tableau.
- Teste la fin du Thread
- renvoie le tableau rempli.

Plan du script
**************

classe principale
-----------------

Code :

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

1
2
3
4
5
6
7
8
9
10
11
//Afficher le préload
progressDialog.show();
 
//instancie la classe_telechargement
Datas = new classe_telechargement();
 
//appelle sa méthode Web_Service (qui télécharge les données et les insère dans un tableau) et récupère le tableau.
tableau = Datas.Web_Service();
 
//Appel la méthode  "setListAdapter"  qui permet d'afficher le tableau.
setListAdapter(new Remplissage_List());

Méthode Web_Service dans la classe "classe_telechargement"
----------------------------------------------------------
//méthode qui fait appel à la classe Thread (qui télécharge les données et les insère dans un tableau), test la fin du Thread et renvoie le tableau.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public tableau[] Web_Service() {
 
	//Appelle la classe Thread (qui télécharge les données, les insère dans un tableau)
	thread = new Thread(new runGetDatas());
	thread.start();
 
	//la méthode join() de la classe Thread temporise le "return" jusqu'à ce que le thread se termine.
	thread.join();
 
	return tableau;
}

Le problème :
-------------
La méthode Web_Service renvoie le tableau pour être afficher dans la classe principale.
Si je ne teste pas la fin du téléchargement dans la méthode Web_Service à l'aide de la fonction "thread.join()", cela provoque une erreur.
L'erreur est logique puisque La méthode Web_Service renvoie le tableau pour être afficher dans la classe principale alors qu'il n'est pas encore rempli ou que le téléchargement n'est pas terminé.
Donc, dans la méthode Web_Service, il est indispensable que je teste la fin du téléchargement (de la classe du Thread) qui permet de patienter le retour du tableau pendant qu'il se rempli.
Le téléchargement et le remplissage du tableau se passe bien mais le problème est que lorsque je teste la fin du Thread, un écran noir apparaît, et donc, fait disparaître le préload.

Je suis ouvert à toutes critiques.
Merci à ceux qui veulent bien se pencher sur ce petit problème d'affichage.

[CrikTeCroque]

Bonsoir

C'est une Activity ta classe principale?

Si oui, il vaut mieux ne pas faire attendre le Thread principal (celui de ton activité) ça le vexe!!

J'aime bien utiliser un Handler auquel je passe une reference de mon activité.
Tu lances ton thread et juste avant de sortir de la méthode run() tu "send" un message à ton handler.. ainsi, ton activité est gentiment à l’écoute de l' événement "fin du thread" et non pas obligée de l'attendre...

Dans ton Handler, lorsqu'il reçoit le message correspondant à la fin du thread, tu lances la suite des opérations (ton setListAdapter..)

J'espère que ça t'aidera Si ça te parait trop obscur, j'essayerai de te mettre un ptit bout de code...

[Hizin]

Tout d'abord : les conventions Java.

• pas de tiret bas dans les noms (sauf séparateur de constante et d'énumération)
• UpperCamelCase pour les Classe (et assimilées) : commencent par une majuscule, mots collés, chaque nouveau mot commençant pas une majuscule (exemple : MaSuperClasseExemple),
• lowerCamelCase pour les variables (et assimilées) : commencent par une minuscule, mots collés, chaque nouveau mot commençant pas une majuscule (exemple : monSuperExempleDeVariable).

L'écran noir vient du fait que tu bloques l'UI avec Thread#join. L'application se lance, l'écran noir du thème standard apparaît et... bloque ensuite, join étant un appel bloquant.
Tu dois mettre en place un système de notification de fin de traitement dan ton Thread, par exemple via un handler, comme CrikTeCroque te l'as suggéré. L'idée est que le thread de traitement prévienne le thread graphique de la fin du traitement.

Etant sur Android, tu peux aussi t'intéresser à la classe AsyncTask, qui se charge de faire tourner les méthodes en background et sur thread graphique pour tout ce qui est loader, callback, progress, terminé...

[Didier_Agritechtrade]

Bonjour CrikTeCroque et Hizin, merci de m'avoir répondu rapidement.
J'ai lu avec attention vos commentaires et je vais étudier vos conseils avec attention aujourd'hui. Je vous tiens informé de l'évolution à mon problème.

Pour répondre à la question de CrikTeCroque, étant donné que ma classe_principale est une ListActivity, sur vos conseils, je vais me pencher sur la classe AsyncTask. Je débute en programmation avec java sous android, donc, un petit bout de code serai le bien venu.

En ce qui concerne Hizin, je te remercie de tes conseils de nommage avec java.
J'espère à très bientôt pour d'autres conseilles. Didiou

[Hizin]

Code Java :

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
public class AsyncTaskExample extends AsyncTask<TypeDesDonneesEnEntree, TypeDesDonneesDeProgression, TypeDesDonnesEnSortie> {
 
    private static final String TAG = "AsyncTaskExample";
 
    private Context           context;
 
    public AsyncTaskExample(Context ctx) {
        context = ctx;
    }
 
    // Cette méthode est automatiquement invoquée au tout début du traitement, avec le doInBackground et se déroule sur le thread graphique
    @Override
    protected void onPreExecute() {
        ...
    }
 
    // C'est ici que se déroule le traitement de la tâche. Cette méthode se déroule sur un thread AUTRE que le thread graphique, automatiquement géré par Android
    @Override
    protected TypeDesDonnesEnSortie doInBackground(TypeDesDonneesEnEntree... donnees) {
        TypeDesDonnesEnSortie result;
        ...
        publishProgress(progress); // optionnel, permet de publier le progrès de la tâche quand celui-ci set mesurable, le type de progress est TypeDesDonneesDeProgression
        ...
        return result;
    }
 
 
    // C'est ici que se déroule la notification du progrès de la tâche à l'utilisateur, si publishProgress(TypeDesDonneesDeProgression...) est utilisée. Cette méthode est invoquée sur le thread graphique.
    @Override
    protected void onProgressUpdate(TypeDesDonneesDeProgression... values) {
        ...
    }    
 
    // Cette méthode est automatiquement invoquée à la fin de doInBackground et se déroule sur le thread graphique
    @Override
    protected void onPostExecute(TypeDesDonnesEnSortie... result) {
        ...
    }
 
}

Et ça se lance via maTache.execute(mesDonneesEnEntree);.

Voici l'exemple d'une AsyncTask. Il n'est absolument pas obligé de passer le context, il est tout à fait possible de créer l'élément de notification utilisateur et de la transmettre à la place (ou toute autre chose).

Fais bien attention au caractère "..." dans le prototype des méthodes. C'est une ellipse, et TypeDesDonneesDeProgression... est équivalent à TypeDesDonneesDeProgression[]. C'est un tableau qui est reçu, mais pas forcément transmis.

Exemple :
maTache.execute(maDonnee);.
maTache.execute(maPremiereDonnee, maSecondeDonnee, maTroisiemeDonnee);.

Les deux sont valides, et coté traitement dans les méthodes de l'AsyncTask, il faut considérer un tableau

Il y a aussi le onCancel à gérer, si la tâche est arrêtable, mais ce n'est pas trop compliqué à gérer.

Au niveau des generics utilisé, si tu n'en utilises pas un, utilise simplement Void et ne traite pas les paramètres concernés.

Je crois avoir fait le tour... avec un raccourci qui ne devrait normalement pas t'impacter.
Attention par contre à la gestion des AsyncTask lors du cycle de vie de l'application (rotation, par exemple). De mémoire, ce tutoriel en parle bien : http://mathias-seguy.developpez.com/...nc_memleak/#L4

[nicroman]

Il faudrait vraiment supprimer les fonctions "join()" et "sleep()" de la classe Thread... C'est tellement tentant de les utiliser.
L'utilisation de ces fonction devrait immédiatement sonner dans la tête comme "j'ai fait une erreur de conception".

[CrikTeCroque]

Hizin, merci pour ce code (ben vi quoi j'en profites aussi du coup )

Dirais tu que Handler soit à bannir ou bien simplement est-ce une autre façon recevable de faire?
J'ai tendance à utiliser ça car je le trouve simple à implémenter et plutôt pratique mais il est vrai que bien souvent, le plus facile n'est pas le plus otpi..

[nicroman]

Handler correspond à un "handler" des messages dans la boucle principale de messages...

Ainsi envoyer un message "Toto" à un handler revient à dire que la boucle de message va appeler la fonction "onMessage(Toto)" de ce handler quand elle en aura fini avec les évenements actuels.
C'est l'outil n°1 de discussion avec le thread principal.

Tout utilise des handlers: Les AsyncTask, la fonction "runOnUiThread()", etc...

Mais entre:
* Créer un thread (déjà ça c'est long en coût CPU) + handler, gérer le cancel, les exceptions, la communication (par le handler) pour être notifié de la fin du thread ou de la progression de celui-ci, etc...
* Créer un AsyncTask (qui réutilise des workers thread: 0 CPU) qui va gérer le cancel, la progress, la communication avec l'UI thread automatiquement....

Le choix est vite fait non ?

[CrikTeCroque]

Le choix est vite fait non ?

Ah oué mais tu sais, quand la belle en détresse arrive au bord du gouffre au fond duquel cours une rivière alors qu'elle est pourchassée par un troupeau de lions affamés.. le choix est vite fait mais ça l'empêche pas de rester pendant 30 secondes à hésiter sur fond de musique palpitante et soleil couchant

Bon prochaine fois que j'ai envie de ressortir un ptit handler fait maison, j'implémenterai une AsynkTask

[nicroman]

J'ai pas dit que j'étais contre l'utilisation des Handler... ils peuvent s'avérer fort utiles...

Mais je suis 100% contre les méthodes "sleep()" (qui indique qu'on a oublié un message ou simplement un wait() / signal() ) et "join()" (qui supprime entièrement tous les intérêts d'un thread à part).

[Didier_Agritechtrade]

Merci Hizin pour ton code et merci à Nicroman pour tes conseils.
Aujourd'hui, j'essaie d'adapter mon programme à la classe AsyncTask qui remplace la classe Thread.
Si vous voulez, Je vous tiens informé de l'évolution à mon problème.
J'espère à très bientôt pour de nouveaux conseils.
Didier

[Didier_Agritechtrade]

Pour commencer, je voudrais remercier Hizin pour son code commenté de la classe Asyntash. Il m'a beaucoup servi.

voici la suite de mon problème :
Après avoir réussi à faire fonctionné la classe Asyntask en récupérant mon tableau, je suis confronté au même problème que la classe Thread.
Le téléchargement et le remplissage du tableau se passe bien avec un affichage d'une barre de progression (sans récupérer mon tableau en exécutant simplement la classe) :
"calcul.execute();"

Des que je récupère mon tableau en exécutant la classe :
"tableau_objet_breves2 = calcul.execute();"

un écran noir apparaît, et donc, fait disparaître la barre de progression

2° petit problème : je voudrai faire apparaître un préload au lieu d'une barre de progression. J'ai essayé à plusieurs endroit de faire afficher le préload (dans la méthode "onCreate" de ma classe principale et dans la méthode "onPreExecute() de la classe Asyntesk) , mais sans succès, aucun préload ne s'affiche.

Merci à ceux qui veulent bien se pencher sur ces petits problèmes d'affichages.

Voici le code de la classe principale qui inclue la classe Asyntask (avec les explications, se sera plus claire) :

Code Java :

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
public class Activite_Breves3 extends ListActivity {
 
	private ProgressBar mProgressBar; 
	public AsyncTask<Void,Integer,Activite_breves_tableau[]> tableau_objet_breves2 = null;
	public ProgressDialog progressDialog;
	@Override
	public void onCreate(Bundle icicle) {
      	super.onCreate(icicle);
	setContentView(R.layout.breves);
 
		// On récupère le composant  ProgressBar de notre layout
		mProgressBar = (ProgressBar) findViewById(R.id.pBAsync);
 
		//Instance et Parametre progressDialog
		//************************************
		progressDialog = new ProgressDialog(this);
		// On ajoute  un message à  notre progress dialog
		progressDialog.setMessage("Chargement en cours");
		// Affichage du ProgressBar
		progressDialog.show();
 
		//Appelle la classe Asyntask
		//***********************
		BigCalcul_interne calcul = null;
		calcul = new BigCalcul_interne();
		//Récupere le tableau
		//***********************
		tableau_objet_breves2 = calcul.execute();
 
		//Appel la methode  setListAdapter  afin d'aficher mon tableau
		setListAdapter(new Remplissage_List());
 
		//Appel la methode qui  efface le ProgressBar
		progressDialog.dismiss();
} //fin Oncreate()
********************************************************************************
	// 2.2 Methode ListAdapter est composée de méthodes permettant de remplir la liste personnalisée 
********************************************************************************
. . . ect	
 
	//***************************************************************
	//     Classe AsyncTask
	//***************************************************************
	private class BigCalcul_interne extends AsyncTask<Void, Integer, Activite_breves_tableau[]> {
 
		@Override
		protected void onPreExecute() {
			super.onPreExecute();
			Toast.makeText(getApplicationContext(), "Début du traitement asynchrone", Toast.LENGTH_LONG).show();
			System.out.println("Début du traitement asynchrone"); 
 
			// On récupère le composant  ProgressBar de notre layout
//			mProgressBar = (ProgressBar) findViewById(R.id.pBAsync);
//			
//			//Instance et Parametre progressDialog
//			//************************************
//			progressDialog = new ProgressDialog(this);
//			// On ajoute  un message à  notre progress dialog
//			progressDialog.setMessage("Chargement en cours");
			// Affichage du ProgressBar
//			progressDialog.show();
		}
 
		@Override
		protected void onProgressUpdate(Integer... values){
			super.onProgressUpdate(values);
			mProgressBar.setProgress(values[0]);
		}
 
		@Override
		protected Activite_breves_tableau[] doInBackground(Void... arg0) {
			Activite_breves_tableau[] tableau_objet_breves = null;
			int progress = 0;
		//Templissage du tableau
		// . . . Ect	
			for (progress=0;progress<=100;progress++)
			{
				for (int i=0; i<1000000; i++){}
				//la méthode publishProgress met à jour l'interface en invoquant la méthode onProgressUpdate
				publishProgress(progress);
				progress++;				
			}			
			return tableau_objet_breves;
		}
 
		@Override
		protected void onPostExecute(Activite_breves_tableau[] result) {
			Toast.makeText(getApplicationContext(), "Le traitement asynchrone est terminé", Toast.LENGTH_LONG).show();
			System.out.println("Le traitement asynchrone est terminé"); 
		}
	}
}	//Fin classe principale

[Didier_Agritechtrade]

Merci les amis, j'ai réussi à résoudre mon problème en utilisant la classe Asyntask.
A bientôt pour de nouvelles aventures.
Didier