So behandeln Sie den Rückgabewert von AsyncTask

Ich benutze die AsyncTask Klasse mit folgender Unterschrift:

 public class ApiAccess extends AsyncTask<List<NameValuePair>, Integer, String> { ... private String POST(List<NameValuePair>[] nameValuePairs){ ... return response; } } protected String doInBackground(List<NameValuePair>... nameValuePairs) { return POST(params); } 

Ich versuche es von einer anderen Klasse zu nennen:

  • Pull to Refresh in Android ohne beliebte Bibliothek
  • AAPT2 Kompilieren fehlgeschlagen: ungültige Dimen auf Android 3.0 Kanarischen 1
  • Klicken Sie auf Benachrichtigung, um meine App in Android zu betreten
  • Android-Layout - Wie man einen festen / gefrorenen Kopf und Spalte implementiert
  • Wie man ein untenes relatives Layout behebt, wenn die Softtastatur kommt?
  • Debugging Reagieren Native über adb tcpip
  •  ApiAccess apiObj = new ApiAccess (0, "/User"); // String signupResponse = apiObj.execute(nameValuePairs); String serverResponse = apiObj.execute(nameValuePairs); //ERROR 

    Aber hier bekomme ich diesen Fehler:

     Type mismatch: cannot convert from AsyncTask<List<NameValuePair>,Integer,String> to String 

    Warum ist das, wenn ich String als den dritten Parameter in Class Extension Zeile angegeben?

  • Speicherverlust in WebView
  • Jodatime, wie man weiß, ob die Sommerzeit eingeschaltet ist
  • Adb Geräteliste leer - Snow Leopard
  • Android App lizenziert neue und alte - Zweifel
  • Wie man eine Fragmentansicht zwischenspeichert
  • Android - Beim Umschalten zwischen zwei Aktivitäten, die rufende Reihenfolge der Lebenszyklus Methoden der Aktivität
  • 4 Solutions collect form web for “So behandeln Sie den Rückgabewert von AsyncTask”

    Sie können das Ergebnis erhalten, indem Sie AsyhncTasks get () -Methode auf die zurückgegebene AsyncTask aufrufen, aber es wird es von einer asynchronen Aufgabe in eine synchrone Aufgabe umwandeln, da es darauf wartet, das Ergebnis zu erhalten.

     String serverResponse = apiObj.execute(nameValuePairs).get(); 

    Da du deine AsyncTask in einer separaten Klasse hast, kannst du eine Schnittstellenklasse erstellen und sie in der AsyncTask deklarieren und deine neue Schnittstellenklasse als Delegate in der Klasse implementieren, auf die du auf die Ergebnisse zugreifen möchte. Ein guter Führer ist hier: Wie bekomme ich das Ergebnis von OnPostExecute () zur Hauptaktivität, weil AsyncTask eine separate Klasse ist? .

    Ich werde versuchen, den obigen Link auf Ihren Kontext anzuwenden.

    (IApiAccessResponse)

     public interface IApiAccessResponse { void postResult(String asyncresult); } 

    (ApiAccess)

     public class ApiAccess extends AsyncTask<List<NameValuePair>, Integer, String> { ... public IApiAccessResponse delegate=null; protected String doInBackground(List<NameValuePair>... nameValuePairs) { //do all your background manipulation and return a String response return response } @Override protected void onPostExecute(String result) { if(delegate!=null) { delegate.postResult(result); } else { Log.e("ApiAccess", "You have not assigned IApiAccessResponse delegate"); } } } 

    (Deine Hauptklasse, die IApiAccessResponse implementiert)

     ApiAccess apiObj = new ApiAccess (0, "/User"); //Assign the AsyncTask's delegate to your class's context (this links your asynctask and this class together) apiObj.delegate = this; apiObj.execute(nameValuePairs); //ERROR //this method has to be implement so that the results can be called to this class void postResult(String asyncresult){ //This method will get call as soon as your AsyncTask is complete. asyncresult will be your result. } 

    Ich würde vorschlagen, einen Handler Callback zu implementieren. Du würdest den Fragment (oder Activity) Handler an die AsyncTask weitergeben, die die AsyncTask anrufen wird, wenn sie fertig ist. Die AsyncTask kann auch ein beliebiges Objekt zurückgeben.

    Hier ist ein Beispiel AsyncTask, das ich in seiner eigenen Datei habe (nicht subclassed):

     public class MyTask extends AsyncTask<Void, String, String> { private static final String TAG = "MyTask"; private Handler mCallersHandler; private Candy mObject1; private Popsicle mObject2; // Return codes public static final int MSG_FINISHED = 1001; public SaveVideoTask(Handler handler, Candy candyCane, Popsicle grapePop ) { this.mCallersHandler = handler; this.mObject1 = candyCane; this.mObject2 = grapePop; } @Override protected String doInBackground(Void... params) { // Do all of the processing that you want to do... // You already have the private fields because of the constructor // so you can use mObject1 and mObject2 Dessert objectToReturn = mObject1 + mObject2; // Tell the handler (usually from the calling thread) that we are finished, // returning an object with the message mCallersHandler.sendMessage( Message.obtain( mCallersHandler, MSG_FINISHED, objectToReturn ) ); return (null); } } 

    Dieses Beispiel geht davon aus, dass Ihr AsyncTask ein Stück Süßigkeiten und ein Popsicle braucht. Dann wird es ein Dessert zu deinem Fragment zurückbringen.

    Du kannst die AsyncTask in einer Zeile aus deinem Fragment konstruieren und ausführen mit:

     ( new MyTask( mFragmentHandler, candyCane, grapePop ) ).execute(); 

    Aber natürlich musst du zuerst den Fragmenthandler (myFragmentHandler) aufbauen. Um dies zu tun, sollte Ihr Fragment (oder Aktivität) aussehen (HINWEIS die "implementiert Handler.Callback"):

     public class MyFragment extends Fragment implements Handler.Callback { private Handler mFragmentHandler; private Candy candyCane; private Popsicle grapePop; @Override public void onCreate(Bundle savedInstanceState) { // Standard creation code super.onCreate(savedInstanceState); setRetainInstance(true); // Create a handler for this fragment mFragmentHandler = new Handler(this); // Other stuff... } @Override public View onCreateView(LayoutInflater inflater, ViewGroup parent, Bundle savedInstanceState) { // Inflate the layout View v = inflater.inflate(R.layout.my_fragment_layout, parent, false ); // The candyCane and grapePop don't need to be set up here, but // they MUST be set up before the button is pressed. // Here would be a good place to at least initialize them... // Perhaps you have a button in "my_fragment_layout" that triggers the AsyncTask... Button mButton = (Button) v.findViewById(R.id.mButton); mButton.setOnClickListener( new OnClickListener() { @Override public void onClick(View v) { ( new MyTask( mFragmentHandler, candyCane, grapePop ) ).execute(); } }); return v; } @SuppressWarnings("unchecked") @Override public boolean handleMessage(Message msg) { switch (msg.what) { case MyTask.MSG_FINISHED: // Let's see what we are having for dessert Dessert myDessert = (Dessert) msg.obj; break; } return false; } } 

    Wenn du diese Stücke von Code benutzt, drückt ein Knopfdruck die AsyncTask aus. Das aufrufende Fragment wird weiterhin ausgeführt, während die AsyncTask verarbeitet wird. Dann, wenn die AsyncTask fertig ist, wird es eine Nachricht an das Fragment senden, dass es fertig ist, und übergeben Sie ein Objekt mit der Nachricht. An diesem Punkt wird das Fragment die Botschaft sehen und was du willst.

    Hinweis: Es könnte Tippfehler geben. Dies ist aus einem sehr großen und komplizierten Code geschnitten.

    Bitte lesen Sie AsyncTask . Sie erhalten Ergebnis auf onPostExecute Methode. Du kannst nicht so etwas machen:

     String serverResponse = apiObj.execute(nameValuePairs); 

    Weil es async ist

    Das Problem ist, dass, wenn Sie aufrufen, das AsyncTask-Objekt zurückgegeben wird, aber nicht das Ergebnis noch. Das Ergebnis wird im Hintergrund berechnet. Die Art des Ergebnisses wird schließlich ein String (wie Sie angegeben), und wird an onPostExecute() .

    Sie sollten die AsyncTask wie folgt verwenden:

     public class ApiAccess extends AsyncTask<List<NameValuePair>, Integer, String> { ... private String POST(List<NameValuePair>[] nameValuePairs){ ... return response; } protected void onPreExecute (){ // this is run on the main (UI) thread, before doInBackground starts } protected void onPostExecute (String result){ // this is run on the main (UI) thread, after doInBackground returns } protected String doInBackground(List<NameValuePair>... nameValuePairs) { // run in another, background thread return POST(params); } } 

    Beachten Sie, dass Sie in Ihrem Beispiel nicht das Ergebnis in doInBackground() , was Sie sollten.

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