Comment obtenir le résultat de OnPostExecute() pour activité principale raison AsyncTask est dans une classe à part?

Facile:

1. Créer interface classe, où String output est facultative, ou peut-être ce que les variables que vous souhaitez retourner.

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

2. Aller à votre AsyncTask classe, et de déclarer l'interface AsyncResponse comme un champ :

   public class MyAsyncTask extends AsyncTask<Void, Void, String> {
   public AsyncResponse delegate = null;
   @Override
   protected void onPostExecute(String result) {
   delegate.processFinish(result);
   }
   }

3. Dans votre Activité principale que vous devez implements interface AsyncResponse.

   public class MainActivity implements AsyncResponse{
   MyAsyncTask asyncTask =new MyAsyncTask();
   @Override
   public void onCreate(Bundle savedInstanceState) {
   //this to set delegate/listener back to this class
   asyncTask.delegate = this;
   //execute the async task 
   asyncTask.execute();
   }
   //this override the implemented method from asyncTask
   @Override
   void processFinish(String output){
   //Here you will receive the result fired from async class 
   //of onPostExecute(result) method.
   }
   }

---

Mise à JOUR

Je ne connaissais pas ce est un favori de beaucoup d'entre vous. Voici donc la simple et pratique façon d'utiliser interface.

toujours en utilisant le même interface. Pour info, vous pouvez combiner ce dans AsyncTask classe.

dans AsyncTask classe :

public class MyAsyncTask extends AsyncTask<Void, Void, String> {
//you may separate this or combined to caller class.
public interface AsyncResponse {
void processFinish(String output);
}
public AsyncResponse delegate = null;
public MyAsyncTask(AsyncResponse delegate){
this.delegate = delegate;
}
@Override
protected void onPostExecute(String result) {
delegate.processFinish(result);
}
}

le faire dans votre Activity classe

public class MainActivity extends Activity {
MyAsyncTask asyncTask = new MyAsyncTask(new AsyncResponse(){
@Override
void processFinish(String output){
//Here you will receive the result fired from async class 
//of onPostExecute(result) method.
}
}).execute();
}

Ou, la mise en œuvre de l'interface sur la reprise de l'Activité

public class MainActivity extends Activity 
implements AsyncResponse{
@Override
public void onCreate(Bundle savedInstanceState) {
//execute the async task 
new MyAsyncTask(this).execute();
}
//this override the implemented method from AsyncResponse
@Override
void processFinish(String output){
//Here you will receive the result fired from async class 
//of onPostExecute(result) method.
}
}

Comme vous pouvez le voir 2 solutions ci-dessus, la première et la troisième, elle doit créer de la méthode processFinish, l'autre, la méthode est à l'intérieur de l'appelant paramètre. La troisième est plus soigné car il n'est pas imbriquée classe anonyme. Espérons que cela aide

Astuce: Changement String output, String response, et String result à différents types de correspondance afin d'obtenir différents objets.

J'ai senti le ci-dessous approche est très facile.

J'ai déclaré une interface pour rappel

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

Ensuite créé Tâche asynchrone pour répondre à tout type de demandes parallèles

 public class MyAsyncTask extends AsyncTask<Object, Object, Object> {
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);
}
}

Appelait alors la tâche asynchrone lorsque vous cliquez sur un bouton dans l'activité de la Classe.

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:", (String) output);
mbtnPress.setText((String) output);
}
});
asyncTask.execute(new Object[] { "Your request to aynchronous task class is giving here.." });
}
});
}
}

Grâce

Cette réponse peut être en retard mais je tiens à mentionner quelques choses lors de votre Activity dépend AsyncTask. Qui pourrait vous aider à éviter les collisions et la gestion de la mémoire. Comme déjà mentionné dans les réponses ci-dessus, aller avec interface, nous avons également dire rappels. Ils vont travailler en tant qu'informateur, mais jamais, jamais, jamais envoyer forte de référence de Activity ou interface toujours utiliser faible de référence dans ces cas.

Veuillez vous référer à la capture d'écran ci-dessous pour trouver comment qui peuvent provoquer des problèmes.

Comme vous pouvez le voir si nous avons commencé AsyncTask avec un forte de référence, alors il n'ya aucune garantie que notre Activity/Fragment sera en vie jusqu'à ce que nous obtenir les données, de sorte qu'il serait préférable d'utiliser WeakReference dans ces cas, et qui va également aider dans la gestion de la mémoire que nous ne pourrons jamais tenir la référence forte de notre Activity alors il sera admissible pour la collecte des ordures après sa déformation.

Découvrez ci-dessous l'extrait de code pour savoir comment utiliser génial WeakReference -

MyTaskInformer.java Interface qui va fonctionner comme un informateur.

public interface MyTaskInformer {
void onTaskDone(String output);
}

MySmallAsyncTask.java AsyncTask de faire de longues tâches en cours d'exécution, ce qui permettra d'utiliser WeakReference.

public class MySmallAsyncTask extends AsyncTask<String, Void, String> {
//***** Hold weak reference *****
private WeakReference<MyTaskInformer> mCallBack;
public MySmallAsyncTask(MyTaskInformer callback) {
this.mCallBack = new WeakReference<>(callback);
}
@Override
protected String doInBackground(String... params) {
//Here do whatever your task is like reading/writing file
//or read data from your server or any other heavy task
//Let us suppose here you get response, just return it
final String output = "Any out, mine is just demo output";
//Return it from here to post execute
return output;
}
@Override
protected void onPostExecute(String s) {
super.onPostExecute(s);
//Here you can't guarantee that Activity/Fragment is alive who started this AsyncTask
//Make sure your caller is active
final MyTaskInformer callBack = mCallBack.get();
if(callBack != null) {
callBack.onTaskDone(s);
}
}
}

MainActivity.java Cette classe est utilisée pour démarrer mon AsyncTask mettre en œuvre interface sur cette classe et override cette méthode.

public class MainActivity extends Activity implements MyTaskInformer {
private TextView mMyTextView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mMyTextView = (TextView) findViewById(R.id.tv_text_view);
//Start your AsyncTask and pass reference of MyTaskInformer in constructor
new MySmallAsyncTask(this).execute();
}
@Override
public void onTaskDone(String output) {
//Here you will receive output only if your Activity is alive.
//no need to add checks like if(!isFinishing())
mMyTextView.setText(output);
}
}

dans votre Oncreate():

`

myTask.execute("url");
String result = "";
try {
result = myTask.get().toString();
} catch (InterruptedException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}catch (ExecutionException e) {
//TODO Auto-generated catch block
e.printStackTrace();

}`

Vous pouvez appeler la get() méthode de AsyncTask (ou la surcharge get(long, TimeUnit)). Cette méthode va bloquer jusqu'à ce que le AsyncTask a terminé son travail, à quel point il va vous retourner le Result.

Il serait sage de faire d'autres travaux entre le la création/démarrage de votre async tâche et l'appel de la get méthode, sinon vous n'êtes pas en utilisant l'async tâche de manière très efficace.

Vous pouvez écrire votre propre écouteur. C'est même comme HelmiB's réponse, mais paraît plus naturel:

Créer auditeur interface:

public interface myAsyncTaskCompletedListener {
void onMyAsynTaskCompleted(int responseCode, String result);
}

Puis rédigez votre tâche asynchrone:

public class myAsyncTask extends AsyncTask<String, Void, String> {
private myAsyncTaskCompletedListener listener;
private int responseCode = 0;
public myAsyncTask() {
}
public myAsyncTask(myAsyncTaskCompletedListener listener, int responseCode) {
this.listener = listener;
this.responseCode = responseCode;
}
@Override
protected void onPreExecute() {
super.onPreExecute();
}
@Override
protected String doInBackground(String... params) {
String result;
String param = (params.length == 0) ? null : params[0];
if (param != null) {
//Do some background jobs, like httprequest...
return result;
}
return null;
}
@Override
protected void onPostExecute(String finalResult) {
super.onPostExecute(finalResult);
if (!isCancelled()) {
if (listener != null) {
listener.onMyAsynTaskCompleted(responseCode, finalResult);
}
}
}
}

Finalement mettre en place l'auditeur dans l'activité:

public class MainActivity extends AppCompatActivity implements myAsyncTaskCompletedListener {
@Override
public void onMyAsynTaskCompleted(int responseCode, String result) {
switch (responseCode) {
case TASK_CODE_ONE: 
//Do something for CODE_ONE
break;
case TASK_CODE_TWO:
//Do something for CODE_TWO
break;
default: 
//Show some error code
}        
}

Et c'est comment vous pouvez appeler asyncTask:

 protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//Some other codes...
new myAsyncTask(this,TASK_CODE_ONE).execute("Data for background job");
//And some another codes...
}

Je le faire fonctionner en utilisant le filetage et le gestionnaire de messages.
Les étapes comme suit:
Déclarer une boîte de Dialogue de progression

ProgressDialog loadingdialog;

Créer une fonction pour fermer la boîte de dialogue lorsque l'opération est terminée.

   private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
loadingdialog.dismiss();
}
};

Code votre les détails de l'Exécution:

 public void startUpload(String filepath) {
loadingdialog = ProgressDialog.show(MainActivity.this, "Uploading", "Uploading Please Wait", true);
final String _path = filepath;
new Thread() {
public void run() {
try {
UploadFile(_path, getHostName(), getPortNo());
handler.sendEmptyMessage(0);
} catch (Exception e) {
Log.e("threadmessage", e.getMessage());
}
}
}.start();
}

essayez ceci:

public class SomAsyncTask extends AsyncTask<String, Integer, JSONObject> {
private CallBack callBack;
public interface CallBack {
void async( JSONObject jsonResult );
void sync( JSONObject jsonResult );
void progress( Integer... status );
void cancel();
}
public SomAsyncTask(CallBack callBack) {
this.callBack = callBack;
}
@Override
protected JSONObject doInBackground(String... strings) {
JSONObject dataJson = null;
//TODO query, get some dataJson
if(this.callBack != null)
this.callBack.async( dataJson );//asynchronize with MAIN LOOP THREAD
return dataJson;
}
@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
if(this.callBack != null)
this.callBack.progress(values);//synchronize with MAIN LOOP THREAD
}
@Override
protected void onPostExecute(JSONObject jsonObject) {
super.onPostExecute(jsonObject);
if(this.callBack != null)
this.callBack.sync(jsonObject);//synchronize with MAIN LOOP THREAD
}
@Override
protected void onCancelled() {
super.onCancelled();
if(this.callBack != null)
this.callBack.cancel();
}
}

Et exemple d'utilisation:

public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
final Context _localContext = getContext();
SomeAsyncTask.CallBack someCallBack = new SomeAsyncTask.CallBack() {
@Override
public void async(JSONObject jsonResult) {//async thread
//some async process, e.g. send data to server...
}
@Override
public void sync(JSONObject jsonResult) {//sync thread
//get result...
//get some resource of Activity variable...
Resources resources = _localContext.getResources();
}
@Override
public void progress(Integer... status) {//sync thread
//e.g. change status progress bar...
}
@Override
public void cancel() {
}
};
new SomeAsyncTask( someCallBack )
.execute("someParams0", "someParams1", "someParams2");
}