Android asynctask sendet callbacks zu ui

Ich habe die folgende Asynctask-Klasse, die nicht innerhalb der Aktivität ist. In der Aktivität bin ich die Initialisierung der Asynthask, und ich möchte die Asynthask, um Rückrufe zurück zu meiner Aktivität zu melden. Ist es möglich? Oder muss die asynctask in der gleichen Klassendatei wie die Aktivität sein?

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

Etwas wie das?

  • AsyncTask doInBackground läuft nicht
  • Fatal Spin-On-Suspend / Stuck auf ThreadID
  • Warum meine Anwendung alle Speicher verwenden und OutOfMemoryError bekommen: Fehler beim Zuordnen?
  • AsyncTask onPostExecute wird niemals aufgerufen
  • Wie kann ein AsyncTask noch eine Aktivität verwenden, wenn der Benutzer bereits von ihm entfernt hat?
  • Welches Design-Konzept zu verwenden, um die UI async zu aktualisieren
  • So verwenden Sie AsyncTask richtig in Android
  • Effizienter Ansatz zur kontinuierlichen Überprüfung, ob Internetverbindung in Android verfügbar ist
  • 4 Solutions collect form web for “Android asynctask sendet callbacks zu ui”

    Sie können eine interface erstellen, an AsyncTask (im Konstruktor) und dann die Methode in onPostExecute()

    Beispielsweise:

    Ihre Schnittstelle:

     public interface OnTaskCompleted{ void onTaskCompleted(); } 

    Ihre Tätigkeit:

     public class YourActivity implements OnTaskCompleted{ // your Activity } 

    Und deine AsyncTask:

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

    BEARBEITEN

    Da diese Antwort ganz populär wurde, möchte ich etwas hinzufügen.

    Wenn Sie eine neue Android-Entwicklung sind, ist AsyncTask ein schneller Weg, um Dinge zu machen, ohne die UI-Thread zu blockieren. Es löst einige Probleme in der Tat, es ist nichts falsch mit dem, wie die Klasse sich selbst arbeitet. Allerdings bringt es einige Implikationen, wie zum Beispiel:

    • Möglichkeit der Speicherlecks. Wenn Sie auf Ihre Activity verweisen, bleibt es auch im Speicher, nachdem der Benutzer den Bildschirm verlassen hat (oder das Gerät gedreht).
    • AsyncTask liefert kein Ergebnis an Activity wenn Activity bereits zerstört wurde. Sie müssen zusätzlichen Code hinzufügen, um all das Zeug zu verwalten oder Operationen zweimal durchzuführen.
    • Faszinierter Code, der alles in Activity

    Wenn du fühlst, dass du genug reifst, um mit Android weiter zu gehen, schau doch einen Blick auf diesen Artikel, der, wie ich glaube, ein besserer Weg ist, um deine Android Apps mit asynchronen Operationen zu entwickeln.

    Ich fühlte die unten Ansatz ist sehr einfach.

    Ich habe eine Schnittstelle zum Rückruf erklärt

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

    Dann erstellt asynchrone Aufgabe für die Beantwortung aller Art von parallelen Anfragen

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

    Dann die asynchrone Task aufgerufen, wenn du auf eine Schaltfläche in der Aktivitätsklasse klickst.

     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[] { "Youe request to aynchronous task class is giving here.." }); } }); } } 

    Vielen Dank

    In Fertigstellung zu oben Antworten können Sie auch Ihre Fallbacks für jeden asynchronen Anruf anpassen, den Sie tun, damit jeder Aufruf zur generischen ASYNC-Methode verschiedene Daten bevölkert, je nach dem onTaskDone-Material, das Sie dort setzen.

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

    Erinnern: Ich habe Schnittstelle auf die Hauptaktivität, wo "Main" kommt, wie folgt:

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

    Meine API-Post-Ausführung sieht so aus:

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

    Der API-Konstruktor sieht so aus:

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

    Ich werde wiederholen, was die anderen sagten, aber wird einfach versuchen, es einfacher zu machen …

    Zuerst erstellen Sie einfach die Interface-Klasse

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

    Zweitens erstellen Sie die AsyncTask (die eine innere statische Klasse Ihrer Aktivität oder Fragment sein kann), die die Schnittstelle verwendet, indem sie eine konkrete Klasse enthält. Im Beispiel wird der PostTaskListener mit String parametriert, dh er erwartet eine String-Klasse als Ergebnis der asynchronen Task.

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

    Endlich der Teil, wo du deine Logik kombinierst. Erstellen Sie in Ihrer Aktivität / Fragment den PostTaskListener und übergeben Sie ihn an den asynchronen Task. Hier ist ein Beispiel:

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

    Erledigt!

    Das Android ist ein Google Android Fan-Website, Alles ├╝ber Android Phones, Android Wear, Android Dev und Android Spiele Apps und so weiter.