Wie bekommt man das Ergebnis von OnPostExecute() zur Hauptaktivität, weil AsyncTask eine separate Klasse ist?

Question

Ich habe diese zwei Klassen. Meine Hauptaktivität und diejenige, die die AsyncTask In meiner Hauptaktivität muss ich nun das Ergebnis aus der OnPostExecute() en el AsyncTask . Wie kann ich meine Haupttätigkeit bestehen oder das Ergebnis erhalten?

Hier sind die Beispielcodes.

Meine Haupttätigkeit.

public class MainActivity extends Activity{

    AasyncTask asyncTask = new AasyncTask();

    @Override
    public void onCreate(Bundle aBundle) {
        super.onCreate(aBundle);            

        //Calling the AsyncTask class to start to execute.  
        asyncTask.execute(a.targetServer); 

        //Creating a TextView.
        TextView displayUI = asyncTask.dataDisplay;
        displayUI = new TextView(this);
        this.setContentView(tTextView); 
    }

}

Dies ist die AsyncTask-Klasse

public class AasyncTask extends AsyncTask<String, Void, String> {

TextView dataDisplay; //store the data  
String soapAction = "http://sample.com"; //SOAPAction header line. 
String targetServer = "https://sampletargeturl.com"; //Target Server.

//SOAP Request.
String soapRequest = "<sample XML request>";    

@Override
protected String doInBackground(String... string) {

String responseStorage = null; //storage of the response

try {

    //Uses URL and HttpURLConnection for server connection. 
    URL targetURL = new URL(targetServer);
    HttpURLConnection httpCon = (HttpURLConnection) targetURL.openConnection();
    httpCon.setDoOutput(true);
    httpCon.setDoInput(true);
    httpCon.setUseCaches(false); 
    httpCon.setChunkedStreamingMode(0);

    //properties of SOAPAction header
    httpCon.addRequestProperty("SOAPAction", soapAction);
    httpCon.addRequestProperty("Content-Type", "text/xml; charset=utf-8"); 
    httpCon.addRequestProperty("Content-Length", "" + soapRequest.length());
    httpCon.setRequestMethod(HttpPost.METHOD_NAME);

    //sending request to the server.
    OutputStream outputStream = httpCon.getOutputStream(); 
    Writer writer = new OutputStreamWriter(outputStream);
    writer.write(soapRequest);
    writer.flush();
    writer.close();

    //getting the response from the server
    InputStream inputStream = httpCon.getInputStream(); 
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
    ByteArrayBuffer byteArrayBuffer = new ByteArrayBuffer(50);

    int intResponse = httpCon.getResponseCode();

    while ((intResponse = bufferedReader.read()) != -1) {
        byteArrayBuffer.append(intResponse);
    }

    responseStorage = new String(byteArrayBuffer.toByteArray()); 

    } catch (Exception aException) {
    responseStorage = aException.getMessage(); 
    }
    return responseStorage;
}

protected void onPostExecute(String result) {

    aTextView.setText(result);

}       

}

Answer 1

Wahrscheinlich über Bord gehen ein bisschen, aber ich zur Verfügung gestellt Rückrufe für beide den Ausführungscode und die Ergebnisse. offensichtlich für Thread-Sicherheit möchten Sie vorsichtig sein, was Sie in Ihre Ausführung Rückruf zugreifen.

Die AsyncTask-Implementierung:

public class AsyncDbCall<ExecuteType,ResultType> extends AsyncTask<ExecuteType, Void,  
ResultType>
{
    public interface ExecuteCallback<E, R>
    {
        public R execute(E executeInput);
    }
    public interface PostExecuteCallback<R>
    {
        public void finish(R result);
    }

    private PostExecuteCallback<ResultType> _resultCallback = null;
    private ExecuteCallback<ExecuteType,ResultType> _executeCallback = null;

    AsyncDbCall(ExecuteCallback<ExecuteType,ResultType> executeCallback, PostExecuteCallback<ResultType> postExecuteCallback)
    {
        _resultCallback = postExecuteCallback;
        _executeCallback = executeCallback;
    }

    AsyncDbCall(ExecuteCallback<ExecuteType,ResultType> executeCallback)
    {
        _executeCallback = executeCallback;
    }

    @Override
    protected ResultType doInBackground(final ExecuteType... params)
    {
        return  _executeCallback.execute(params[0]);
    }

    @Override
    protected void onPostExecute(ResultType result)
    {
        if(_resultCallback != null)
            _resultCallback.finish(result);
    }
}

Ein Rückruf:

 AsyncDbCall.ExecuteCallback<Device, Device> updateDeviceCallback = new 
 AsyncDbCall.ExecuteCallback<Device, Device>()
    {
        @Override
        public Device execute(Device device)
        {
            deviceDao.updateDevice(device);
            return device;
        }
    };

Und schließlich die Ausführung der asynchronen Aufgabe:

 new AsyncDbCall<>(addDeviceCallback, resultCallback).execute(device);

Answer 2

Ich hoffe, Sie haben die cette falls nicht, lesen Sie bitte.

https://developer.Android.com/reference/Android/os/AsyncTask

Je nach Art der Ergebnisdaten sollten Sie die bestmögliche Option wählen, die Ihnen einfällt.

Es ist eine gute Wahl, eine Schnittstelle

Einige andere Optionen wären.

• Wenn die AsyncTask-Klasse innerhalb der Klasse definiert ist, die Sie das Ergebnis verwenden wollen, verwenden Sie eine statische globale Variable oder get() , verwenden Sie es von äußeren Klasse ( flüchtige Variable falls erforderlich), sollte aber die AsyncTask Fortschritte oder sollte sich zumindest vergewissern, dass er die Aufgabe erledigt hat und das Ergebnis ist über die globale Variable / get()-Methode verfügbar ist. Sie können Abfrage, onProgressUpdate(Fortschritt...) Synchronisierung oder Schnittstellen (was immer für Sie am besten passt)

• Wenn das Ergebnis mit einem sharedPreference-Eintrag kompatibel ist oder als Datei im Speicher gespeichert werden kann, können Sie es speichern sogar von der Hintergrundaufgabe selbst und könnte die onPostExecute() Methode
  um benachrichtigt zu werden, wenn das Ergebnis im Speicher verfügbar ist.

• Wenn die Zeichenkette klein genug ist und mit Beginn eines Aktivität verwendet werden soll, ist es möglich, die Beabsichtigungen ( putExtra() ) innerhalb onPostExecute() aber denken Sie daran, dass statische Kontexte sind nicht so sicher zu bewältigen.

• Wenn möglich, können Sie eine statische Methode von der onPostExecute()-Methode, mit dem Ergebnis, dass Ihre Parameter