Chiamata AsyncTask da un'altra classe

Question

In un'applicazione esistente ho un'attività con una classe interna che si estende AsyncTask, questo appare come il seguente:

public class Activity_1 extends BaseActivity { 
    .... 
    new async().execute(); 
    ... 

    public class asyncextends AsyncTask<Void, Void, String> { 
     protected String doInBackground(Void... progress) { ... } 
     protected void onPreExecute() { ... } 
     protected void onPostExecute(String result) { ... } 
    } 
} 

Ora, ho bisogno di chiamare lo stesso doInBackground-metodo da un altro attività, ma il onPostExecute() di questa classe interna opera su alcune variabili UI locali e quindi non è possibile utilizzarlo dall'esterno del clas. Esiste un modo per chiamare questo AsyncTask, e sovrascrivere il metodo onPostExecute e onPreExecute o devo creare un'altra classe interna nell'altra attività, fare la stessa cosa in background (ovviamente spostarlo nella classe di utilità comune) o qualcosa), ecc ...?

Answer 1

È possibile effettuare una classe privata separata pacchetto di astratto, che si estende AsyncTask e l'attuazione di doInBackground() metodo:

abstract class MyAsyncTask extends AsyncTask<Void, Void, String> { 
    @Override 
    final protected String doInBackground(Void... progress) { 
     // do stuff, common to both activities in here 
    } 
} 

e nella vostra attività appena ereditano da MyAsyncTask (nuova classe probabilmente dovrebbe essere privata, tra l'altro), attuazione onPostExecute() e onPreExecute() metodi:

public class Activity_1 extends BaseActivity { 

    ... 
    new Async1().execute(); 
    ... 

    private class Async1 extends MyAsyncTask { 
     @Override 
     protected void onPreExecute(){ 
      // Activity 1 GUI stuff 
     } 

     @Override 
     protected void onPostExecute(String result) { 
      // Activity 1 GUI stuff 
     } 
    } 
} 

Se onPreExecute e onPostExecute contengono alcune azioni comuni così, è possibile applicare il seguente schema:

abstract class MyAsyncTask extends AsyncTask<Void, Void, String> { 
    public interface MyAsyncTaskListener { 
     void onPreExecuteConcluded(); 
     void onPostExecuteConcluded(String result); 
    } 

    private MyAsyncTaskListener mListener; 

    final public void setListener(MyAsyncTaskListener listener) { 
     mListener = listener; 
    } 

    @Override 
    final protected String doInBackground(Void... progress) { 
     // do stuff, common to both activities in here 
    } 

    @Override 
    final protected void onPreExecute() { 
     // common stuff 
     ... 
     if (mListener != null) 
      mListener.onPreExecuteConcluded(); 
    } 

    @Override 
    final protected void onPostExecute(String result) { 
     // common stuff 
     ... 
     if (mListener != null) 
      mListener.onPostExecuteConcluded(result); 
    } 
} 

e utilizzarlo nella vostra attività come segue:

public class Activity_1 extends BaseActivity { 

    ... 
    MyAsyncTask aTask = new MyAsyncTask(); 
    aTask.setListener(new MyAsyncTask.MyAsyncTaskListener() { 
     @Override 
     void onPreExecuteConcluded() { 
      // gui stuff 
     } 

     @Override 
     void onPostExecuteConcluded(String result) { 
      // gui stuff 
     } 
    }); 
    aTask.execute(); 
    ... 
}  

Si può anche avere il vostro Activity implementare MyAsyncTaskListener così:

public class Activity_1 extends BaseActivity implements MyAsyncTask.MyAsyncTaskListener { 
    @Override 
    void onPreExecuteConcluded() { 
     // gui stuff 
    } 

    @Override 
    void onPostExecuteConcluded(String result) { 
     // gui stuff 
    } 

    ... 
    MyAsyncTask aTask = new MyAsyncTask(); 
    aTask.setListener(this); 
    aTask.execute(); 
    ... 

} 

Ho scritto il codice dalla testa, quindi potrebbe contenere errori, ma dovrebbe illustrare l'idea.

Answer 2

Se creiamo un metodo statico che è in una classe e che verrà eseguito in qualsiasi classe in doInBackground di AsyncTask, possiamo facilmente aggiornare l'interfaccia utente attraverso la stessa classe e persino in classi diverse.

Answer 3

È così semplice, basta semplicemente creare un oggetto della classe principale e di chiamare la classe interna come questo

OuterMainClass outer = new OuterMainClass(); 
     outer.new InnerAsyncClass(param) 
     .execute(); 

questa risposta è troppo tardi per aiutare voi, ma spero che aiutare gli altri.

Grazie

Answer 4

1.Creare un costruttore di AsynckTask in ClassOne.

2.Crate oggetto o ClassOne con nuova parola chiave.

3.Call Async Task per oggetto

ClassOne{ 

class AsyncParmas extends AsyncTask { 

     public ADDloadGeofenceDetails() { 
     } 

     @Override 
     protected void onPreExecute() { 


      super.onPreExecute(); 
     } 

     @Override 
     protected Object doInBackground(Object... params) { 

} 
} 

Class ClassTwo{ 
ClassOne obj= new ClassOne(); 

        obj.new AsyncParmas().execute(); 
} 
} 

GoodLuck Chi stavano affrontando problema.