android asynctask envoie des rappels à l’interface utilisateur

J’ai la classe asynctask suivante qui n’est pas dans l’activité. Dans l’activité, j’initialise la tâche asynchrone et je souhaite que la tâche d’asynchronisation renvoie les rappels à mon activité. C’est possible? Ou est-ce que l’asynctask doit être dans le même fichier de classe que l’activité?

protected void onProgressUpdate(Integer... values) { super.onProgressUpdate(values); caller.sometextfield.setText("bla"); } 

Quelque chose comme ça?

Vous pouvez créer une interface , la transmettre à AsyncTask (dans le constructeur), puis appeler la méthode dans onPostExecute()

Par exemple:

Votre interface:

 public interface OnTaskCompleted{ void onTaskCompleted(); } 

Votre activité:

 public class YourActivity implements OnTaskCompleted{ // your Activity } 

Et votre AsyncTask:

 public class YourTask extends AsyncTask{ //change Object to required type private OnTaskCompleted listener; public YourTask(OnTaskCompleted listener){ this.listener=listener; } // required methods protected void onPostExecute(Object o){ // your stuff listener.onTaskCompleted(); } } 

MODIFIER

Comme cette réponse est devenue très populaire, je veux append certaines choses.

Si vous êtes nouveau dans le développement Android, AsyncTask est un moyen rapide de faire fonctionner les choses sans bloquer les threads de l’interface utilisateur. Cela résout effectivement certains problèmes, il n’y a rien de mal avec le fonctionnement de la classe. Cependant, cela entraîne certaines implications, telles que:

  • Possibilité de memory leaks. Si vous continuez à faire référence à votre Activity , celle-ci restra en mémoire même après que l’utilisateur a quitté l’écran (ou fait pivoter l’appareil).
  • AsyncTask ne fournit pas de résultat à Activity si Activity a déjà été détruit. Vous devez append du code supplémentaire pour gérer tous ces éléments ou effectuer deux opérations.
  • Code compliqué qui fait tout dans l’ Activity

Lorsque vous sentez que vous avez suffisamment évolué pour passer à Android, jetez un coup d’œil à cet article qui, je pense, est un meilleur moyen de développer vos applications Android avec des opérations asynchrones.

J’ai senti que l’approche ci-dessous est très facile.

J’ai déclaré une interface pour le rappel

 public interface AsyncResponse { void processFinish(Object output); } 

Puis créé une tâche asynchrone pour répondre à tous les types de requêtes parallèles

  public class MyAsyncTask extends AsyncTask { public AsyncResponse delegate = null;//Call back interface public MyAsyncTask(AsyncResponse asyncResponse) { delegate = asyncResponse;//Assigning call back interfacethrough constructor } @Override protected Object doInBackground(Object... params) { //My Background tasks are written here return {resutl Object} } @Override protected void onPostExecute(Object result) { delegate.processFinish(result); } } 

Ensuite, appelé la tâche asynchrone en cliquant sur un bouton dans la classe d’activité.

 public class MainActivity extends Activity { @Override public void onCreate(Bundle savedInstanceState) { Button mbtnPress = (Button) findViewById(R.id.btnPress); mbtnPress.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { MyAsyncTask asyncTask =new MyAsyncTask(new AsyncResponse() { @Override public void processFinish(Object output) { Log.d("Response From Asynchronous task:", (Ssortingng) output); mbtnPress.setText((Ssortingng) output); } }); asyncTask.execute(new Object[] { "Youe request to aynchronous task class is giving here.." }); } }); } } 

Merci

A la fin des réponses ci-dessus, vous pouvez également personnaliser vos solutions de remplacement pour chaque appel asynchrone que vous faites, de sorte que chaque appel à la méthode ASYNC générique remplisse des données différentes, en fonction des éléments onTaskDone que vous y avez placés.

  Main.FragmentCallback FC= new Main.FragmentCallback(){ @Override public void onTaskDone(Ssortingng results) { localText.setText(results); //example TextView } }; new API_CALL(this.getApplicationContext(), "GET",FC).execute("&Books=" + Main.Books + "&args=" + profile_id); 

Rappel: j’ai utilisé l’interface sur l’activité principale, où “Main” vient, comme ceci:

 public interface FragmentCallback { public void onTaskDone(Ssortingng results); } 

Mon post-exécution API ressemble à ceci:

  @Override protected void onPostExecute(Ssortingng results) { Log.i("TASK Result", results); mFragmentCallback.onTaskDone(results); } 

Le constructeur de l’API ressemble à ceci:

  class API_CALL extends AsyncTask { private Main.FragmentCallback mFragmentCallback; private Context act; private Ssortingng method; public API_CALL(Context ctx, Ssortingng api_method,Main.FragmentCallback fragmentCallback) { act=ctx; method=api_method; mFragmentCallback = fragmentCallback; } 

Je vais répéter ce que les autres ont dit, mais je vais juste essayer de le rendre plus simple …

Tout d’abord, créez simplement la classe Interface

 public interface PostTaskListener { // K is the type of the result object of the async task void onPostTask(K result); } 

Deuxièmement, créez la classe AsyncTask (qui peut être une classe statique interne de votre activité ou de votre fragment) qui utilise l’interface, en incluant une classe concrète. Dans l’exemple, PostTaskListener est paramétré avec Ssortingng, ce qui signifie qu’il attend une classe Ssortingng suite à la tâche asynchrone.

 public static class LoadData extends AsyncTask { private PostTaskListener postTaskListener; protected LoadData(PostTaskListener postTaskListener){ this.postTaskListener = postTaskListener; } @Override protected void onPostExecute(Ssortingng result) { super.onPostExecute(result); if (result != null && postTaskListener != null) postTaskListener.onPostTask(result); } } 

Enfin, la partie où vous combinez votre logique. Dans votre activité / fragment, créez le PostTaskListener et transmettez-le à la tâche asynchrone. Voici un exemple:

 ... PostTaskListener postTaskListener = new PostTaskListener() { @Override public void onPostTask(Ssortingng result) { //Your post execution task code } } // Create the async task and pass it the post task listener. new LoadData(postTaskListener); 

Terminé!