Meilleure façon de lancer différentes tâches

Question

Je développe une application pour les personnes aveugles. Je dois travailler tout le temps avec le module TextToSpeech, le GPS et la connexion réseau.

Je dois faire une requête comme celle-ci: Consulter le GPS, faire un appel JSON et appeler le module TextToSpeech (TTS).

Je me demande quel est le meilleur moyen de gérer les différentes tâches qui communiquent avec le thread principal de l'interface utilisateur. J'ai vu jusqu'ici: Objets de gestionnaire et classe AsyncTask.

Je dois lancer chaque tâche séquentiellement, donc je veux appeler le TTS après avoir récupéré des données du réseau. J'ai donc utilisé "mHandler.post (Runnable)" et à l'intérieur de ce runnable appelant un autre et ainsi de suite.

Cependant, j'ai vu que l'utilisation de la classe AsynTask est recommandée. Mais dans ce cas, je pense que je dois implémenter une classe différente pour chaque tâche, alors que je ne sais pas si ces tâches s'exécuteront séquentiellement. Quelque chose comme:

AsyntaskClass1 at1; 
AsyntaskClass2 at2; 
AsyntaskClass3 at3; 

at1.execute(); 
at2.execute(); 
at3.execute(); 

Est-ce que ces tâches s'exécuteront dans l'ordre? Parce que le module de synthèse vocale doivent attendre la tâche réseau pour terminer ...

Merci pour votre aide,

BR.David.

Answer 1

Non, ils seront exécutés presque simultanément ... à savoir le deuxième AsyncTask ne sera pas attendre premier à terminer.

Je vous suggère de regrouper toutes les tâches dans un seul AsyncTask et d'utiliser publishprogress() pour mettre à jour l'interface utilisateur après la fin de chaque tâche.

afin que vous puissiez commencer que AsyncTask après la fin du réseau et l'interface utilisateur seront mis à jour de manière séquentielle

par exemple.

public Object doInBackground(Object... params){ 
    //do task one's stuff 
    publishProgress(1); 
// do task two's stuff 
publishProgress(2) 
    //do task 3 
publishProgress(3) 


} 
public void onProgressUpdate(Integer... int){ 
switch(int[0]){ 
case 1: 
//ui update for task 1 
case 2: 
//ui update for task 3 
case 3: 
//ui update for task 3 
} 

Answer 2

Vous pouvez tout avec une seule classe AsyncTask:

private class AsyncTask1 extends AsyncTask<Object, Void, Object> { 

@Override 
protected String doInBackground(Object... args) { 
    // Get a result from the GPS. 

    // Make a network call 

    // Communicate with the TTS 
    } 

@Override 
protected void onPostExecute(Object result) { 
    // Return a result to the main thread 
    // You are only allowed to touch the UI here 
    } 

} 

Answer 3

L'ordre d'exécution n'est pas garanti dans votre exemple. Le thread UI lancerait les 3 AsyncTasks. Ces trois tâches seraient alors exécutées simultanément.

Si vous voulez exécuter le code dans les tâches de manière synchrone, vous avez au moins deux façons de acomplish il:

combinons les trois tâches dans celui où vous avez commandé le travail à effectuer de manière séquentielle à savoir:

AsyncTaskCombined task = new AsyncTaskCombined(); 
task.execute(); 

private class AsyncTaskCombined extends AsyncTask<Void, Void, Void> { 
    protected Bitmap doInBackground(Void... urls) { 
     // Initialize classes that implement the work logic 
     Work1 work1; 
     Work2 work2; 
     Work3 work3; 
     // Do the work sequentially... 
     work1.doWork(); 
     work2.doWork(); 
     work3.doWork(); 
    } 
} 

ou potentiellement vous pourriez avoir 3 différents AsyncTask puis dans le onPostExecute de la première tâche de créer et d'appeler la seconde AsyncTask et dans le second créer onPostExecute de AsyncTask et appeler la troisième et dernière AsyncTask. Cependant cela me semble un peu contrarié ...

// Emil H