Jak uzyskać wynik OnPostExecute () do głównej aktywności, ponieważ AsyncTask jest oddzielną klasą?

Istnieje kilka opcji:

• Zagnieźdź klasę AsyncTask w swojej klasie Activity. Zakładając, że nie używasz tego samego zadania w wielu działaniach, jest to najprostszy sposób. Cały Twój kod pozostaje taki sam, po prostu przenosisz istniejącą klasę zadania, aby stała się klasą zagnieżdżoną wewnątrz klasy Twojej aktywności.

  public class MyActivity extends Activity {
      // existing Activity code
      ...
  
      private class MyAsyncTask extends AsyncTask<String, Void, String> {
          // existing AsyncTask code
          ...
      }
  }
  

• Utwórz niestandardowy konstruktor dla twojego AsyncTask, który ma odniesienie do twojego Activity. Utworzyłbyś zadanie czymś takim jak new MyAsyncTask(this).execute(param1, param2).

  public class MyAsyncTask extends AsyncTask<String, Void, String> {
      private Activity activity;
  
      public MyAsyncTask(Activity activity) {
          this.activity = activity;
      }
  
      // existing AsyncTask code
      ...
  }
  

Czułem, że poniższe podejście jest bardzo łatwe.

I have declared an interface for callback

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

Następnie utworzono zadanie asynchroniczne do odpowiadania na wszystkie typy równoległych żądań

 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);
    }

}

Następnie wywołane zadanie asynchroniczne po kliknięciu przycisku w klasie activity.

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.." });


            }
        });

    }



}

Dzięki

Możesz wypróbować ten kod w swojej klasie głównej. To działało dla mnie, ale zaimplementowałem metody w inny sposób

try {
    String receivedData = new AsyncTask().execute("http://yourdomain.com/yourscript.php").get();
} 
catch (ExecutionException | InterruptedException ei) {
    ei.printStackTrace();
}

Możesz to zrobić w kilku wierszach, po prostu nadpisuj onPostExecute podczas wywoływania AsyncTask. Oto przykład dla ciebie:

new AasyncTask()
{
    @Override public void onPostExecute(String result)
    {
       // do whatever you want with result 
    }
}.execute(a.targetServer);

Mam nadzieję, że ci pomogło, miłego rozpieszczania :)

In your 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();

}`

Dlaczego ludzie tak to utrudniają?

Nie implementuj onPostExecute na zadaniu asynchronicznym, raczej zaimplementuj go na aktywności:

public class MainActivity extends Activity 
{

@Override
public void onCreate(Bundle savedInstanceState) {

    //execute the async task 
    MyAsyncTask task = new MyAsyncTask(){
            protected void onPostExecute(String result) {
                //Do your thing
            }       

    }

    task.execute("Param");

}


}

Ta odpowiedź może się spóźnić, ale chciałbym wspomnieć o kilku rzeczach, gdy Activity zależy od AsyncTask. To pomoże Ci w zapobieganiu awariom i zarządzaniu pamięcią. Jak już wspomniano w powyższych odpowiedzi iść z interface, mówimy również ich wywołań zwrotnych. Będą pracować jako informator, ale nigdy przenigdy nie wysyłają silnego odniesienia Activity lub interface Zawsze używaj słabego odniesienia w tych przypadkach.

Zapoznaj się z poniższym zrzutem ekranu, aby dowiedzieć się, jak może to spowodować problemy.

Jak widać, jeśli zaczęliśmy AsyncTask od silnego odniesienia to nie ma gwarancji, że nasz Activity/Fragment będzie żył dopóki nie uzyskamy danych, więc lepiej byłoby użyć WeakReference w takich przypadkach, a to również pomoże w zarządzaniu pamięcią, ponieważ nigdy nie będziemy trzymać silnej referencji naszego Activity, wtedy będzie on kwalifikował się do zbierania śmieci po jego zniekształceniu.

Sprawdź poniższy fragment kodu, aby dowiedzieć się, jak używać awesome WeakReference -

MyTaskInformer.java interfejs, który będzie działał jako informator.

public interface MyTaskInformer {

    void onTaskDone(String output);

}

MySmallAsyncTask.java AsyncTask do wykonania długiego zadania, które użyje 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 ta klasa jest używana do rozpoczęcia mojej AsyncTask implementacji interface na tej klasie i {[19] } tej obowiązkowej metody.

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);
    }
}

Można nazwać get() metoda AsyncTask (lub przeciążenie get(long, TimeUnit)). Ta metoda zostanie zablokowana, dopóki AsyncTask nie zakończy swojej pracy, w którym to momencie zwróci ci Result.

Mądrze byłoby wykonać inną pracę między utworzeniem / rozpoczęciem zadania asynchronicznego a wywołaniem metody get, w przeciwnym razie nie wykorzystasz zadania asynchronicznego bardzo efektywnie.

Witam mozna zrobic cos takiego:

1. Tworzenie klasy implementującej AsyncTask

   // TASK 
   public class SomeClass extends AsyncTask<Void, Void, String>>
   {
   
       private OnTaskExecutionFinished _task_finished_event;
   
       public interface OnTaskExecutionFinished
       {
           public void OnTaskFihishedEvent(String Reslut);
       }
   
       public void setOnTaskFinishedEvent(OnTaskExecutionFinished _event)
       {
           if(_event != null)
           {
               this._task_finished_event = _event;
           }
       }
   
       @Override
       protected void onPreExecute()
       {
           super.onPreExecute();
   
       }
   
       @Override
       protected String doInBackground(Void... params)
       {
           // do your background task here ...
   
           return "Done!";
       }
   
       @Override
       protected void onPostExecute(String result)
       {
           super.onPostExecute(result);
           if(this._task_finished_event != null)
           {
               this._task_finished_event.OnTaskFihishedEvent(result);
           }
           else
           {
               Log.d("SomeClass", "task_finished even is null");
           }
       }
   }
   

2. Dodaj do głównej aktywności

   // MAIN ACTIVITY
   public class MyActivity extends ListActivity
   {
      ...
       SomeClass _some_class = new SomeClass();
       _someclass.setOnTaskFinishedEvent(new _some_class.OnTaskExecutionFinished()
       {
       @Override
       public void OnTaskFihishedEvent(String result)
       {
           Toast.makeText(getApplicationContext(),
                   "Phony thread finished: " + result,
                   Toast.LENGTH_SHORT).show();
       }
   
      });
      _some_class.execute();
      ...
    }
   

Możesz napisać własnego słuchacza. Jest taka sama jak odpowiedź HelmiB, ale wygląda bardziej naturalnie:

Utwórz interfejs słuchacza:

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

Następnie napisz swoje zadanie asynchroniczne:

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);
            }
        }
    }
}

Wreszcie zaimplementuj słuchacza w aktywności:

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
        }        
    }

I tak można wywołać 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...
}

Utwórz statyczny członek w klasie aktywności. Następnie przypisz wartość podczas onPostExecute

Na przykład, jeśli wynikiem Asynctasku jest łańcuch znaków, Utwórz publiczny łańcuch statyczny w aktywności

public static String dataFromAsyncTask;

Następnie, w onPostExecute AsyncTask, po prostu wykonaj statyczne wywołanie do swojej głównej klasy i ustaw wartość.

MainActivity.dataFromAsyncTask = "result blah";

I make it work by using threading and handler / message. Kroki w następujący sposób: Declare a progress Dialog

ProgressDialog loadingdialog;

Utwórz funkcję zamykającą okno dialogowe po zakończeniu operacji.

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

    }
    };

Koduj Szczegóły Wykonania:

 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();
}

Musisz użyć "protokołów" do delegowania lub przekazywania danych do AsynTask.

Delegaci i źródła danych

Delegat to obiekt, który działa w imieniu lub w koordynacji z innym obiektem, gdy ten obiekt napotka Zdarzenie w programie. (definicja jabłka )

Protokoły są interfejsami, które definiują niektóre metody delegowania niektórych zachowań.

Oto kompletny przykład!!!