Ideale Möglichkeit, eine ausgeführte AsyncTask abzubrechen

Ich führe Remote-Operationen zum Abrufen von Audiodateien und zur Wiedergabe von Audiodateien in einem Hintergrundthread mit aus AsyncTask. CancellableFür die Zeit, in der der Abrufvorgang ausgeführt wird, wird ein Fortschrittsbalken angezeigt.

Ich möchte den AsyncTaskLauf abbrechen / abbrechen , wenn der Benutzer den Vorgang abbricht (sich dagegen entscheidet). Was ist der ideale Weg, um einen solchen Fall zu behandeln?

Ich habe gerade festgestellt, dass das AlertDialogs, was boolean cancel(...);ich überall benutzt habe, eigentlich nichts bewirkt. Toll.
So...

public class MyTask extends AsyncTask<Void, Void, Void> {

    private volatile boolean running = true;
    private final ProgressDialog progressDialog;

    public MyTask(Context ctx) {
        progressDialog = gimmeOne(ctx);

        progressDialog.setCancelable(true);
        progressDialog.setOnCancelListener(new OnCancelListener() {
            @Override
            public void onCancel(DialogInterface dialog) {
                // actually could set running = false; right here, but I'll
                // stick to contract.
                cancel(true);
            }
        });

    }

    @Override
    protected void onPreExecute() {
        progressDialog.show();
    }

    @Override
    protected void onCancelled() {
        running = false;
    }

    @Override
    protected Void doInBackground(Void... params) {

        while (running) {
            // does the hard work
        }
        return null;
    }

    // ...

}

Wenn Sie Berechnungen durchführen :

• Sie müssen isCancelled()regelmäßig überprüfen .

Wenn Sie eine HTTP-Anfrage stellen :

• Speichern Sie die Instanz Ihres HttpGetoder HttpPostirgendwo (z. B. ein öffentliches Feld).
• Rufen Sie nach dem cancelAnruf an request.abort(). Dies wird dazu führen, IOExceptiondass Sie in Ihre geworfen werden doInBackground.

In meinem Fall hatte ich eine Connector-Klasse, die ich in verschiedenen AsyncTasks verwendet habe. Um es einfach zu halten, habe ich abortAllRequestsdieser Klasse eine neue Methode hinzugefügt und diese Methode direkt nach dem Aufruf aufgerufen cancel.

Die Sache ist, dass der Aufruf von AsyncTask.cancel () nur die Funktion onCancel in Ihrer Aufgabe aufruft. Hier möchten Sie die Abbruchanforderung bearbeiten.

Hier ist eine kleine Aufgabe, mit der ich eine Aktualisierungsmethode auslöse

private class UpdateTask extends AsyncTask<Void, Void, Void> {

        private boolean running = true;

        @Override
        protected void onCancelled() {
            running = false;
        }

        @Override
        protected void onProgressUpdate(Void... values) {
            super.onProgressUpdate(values);
            onUpdate();
        }

        @Override
        protected Void doInBackground(Void... params) {
             while(running) {
                 publishProgress();
             }
             return null;
        }
     }

Einfach: Verwenden Sie keine AsyncTask. AsyncTaskist für kurze Vorgänge ausgelegt, die schnell enden (mehrere zehn Sekunden) und daher nicht abgebrochen werden müssen. "Wiedergabe von Audiodateien" ist nicht qualifiziert. Sie benötigen nicht einmal einen Hintergrund-Thread für die normale Wiedergabe von Audiodateien.

Die einzige Möglichkeit, dies zu tun, besteht darin, den Wert der Methode isCancelled () zu überprüfen und die Wiedergabe zu stoppen, wenn true zurückgegeben wird.

So schreibe ich meine AsyncTask.
Der entscheidende Punkt ist das Hinzufügen von Thread.sleep (1).

@Override   protected Integer doInBackground(String... params) {

        Log.d(TAG, PRE + "url:" + params[0]);
        Log.d(TAG, PRE + "file name:" + params[1]);
        downloadPath = params[1];

        int returnCode = SUCCESS;
        FileOutputStream fos = null;
        try {
            URL url = new URL(params[0]);
            File file = new File(params[1]);
            fos = new FileOutputStream(file);

            long startTime = System.currentTimeMillis();
            URLConnection ucon = url.openConnection();
            InputStream is = ucon.getInputStream();
            BufferedInputStream bis = new BufferedInputStream(is);

            byte[] data = new byte[10240]; 
            int nFinishSize = 0;
            while( bis.read(data, 0, 10240) != -1){
                fos.write(data, 0, 10240);
                nFinishSize += 10240;
                **Thread.sleep( 1 ); // this make cancel method work**
                this.publishProgress(nFinishSize);
            }              
            data = null;    
            Log.d(TAG, "download ready in"
                  + ((System.currentTimeMillis() - startTime) / 1000)
                  + " sec");

        } catch (IOException e) {
                Log.d(TAG, PRE + "Error: " + e);
                returnCode = FAIL;
        } catch (Exception e){
                 e.printStackTrace();           
        } finally{
            try {
                if(fos != null)
                    fos.close();
            } catch (IOException e) {
                Log.d(TAG, PRE + "Error: " + e);
                e.printStackTrace();
            }
        }

        return returnCode;
    }

Unsere globale AsyncTask-Klassenvariable

LongOperation LongOperationOdeme = new LongOperation();

Und KEYCODE_BACK-Aktion, die AsyncTask unterbricht

   @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_BACK) {
            LongOperationOdeme.cancel(true);
        }
        return super.onKeyDown(keyCode, event);
    }

Für mich geht das.

Ich möchte meine asynchronen Aufgaben nicht cancel(true)unnötig unterbrechen, da sie möglicherweise Ressourcen freigeben müssen, z. B. das Schließen von Sockets oder Dateistreams, das Schreiben von Daten in die lokale Datenbank usw. Andererseits habe ich Situationen erlebt, in denen die Die asynchrone Aufgabe weigert sich, sich zeitweise selbst zu beenden, zum Beispiel manchmal, wenn die Hauptaktivität geschlossen wird und ich die asynchrone Aufgabe auffordere, sie innerhalb der onPause()Methode der Aktivität zu beenden . Es geht also nicht nur darum anzurufen running = false. Ich muss mich für eine gemischte Lösung entscheiden: Beide rufen auf running = false, geben der asynchronen Aufgabe einige Millisekunden Zeit und beenden dann entweder cancel(false)oder cancel(true).

if (backgroundTask != null) {
    backgroundTask.requestTermination();
    try {
        Thread.sleep((int)(0.5 * 1000));
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    if (backgroundTask.getStatus() != AsyncTask.Status.FINISHED) {
        backgroundTask.cancel(false);
    }
    backgroundTask = null;
}

Als Nebenergebnis wird nach doInBackground()Abschluss manchmal die onCancelled()Methode aufgerufen, und manchmal onPostExecute(). Zumindest die Beendigung der asynchronen Aufgabe ist jedoch garantiert.

In Bezug auf Yanchenkos Antwort vom 29. April '10: Die Verwendung eines "while (running)" - Ansatzes ist ordentlich, wenn Ihr Code unter "doInBackground" bei jeder Ausführung der AsyncTask mehrmals ausgeführt werden muss. Wenn Ihr Code unter 'doInBackground' nur einmal pro Ausführung der AsyncTask ausgeführt werden muss, wird durch das Umschließen Ihres gesamten Codes unter 'doInBackground' in eine 'while (running)' - Schleife nicht verhindert, dass der Hintergrundcode (Hintergrundthread) ausgeführt wird, wenn der AsyncTask selbst wird abgebrochen, da die Bedingung 'while (running)' erst ausgewertet wird, wenn der gesamte Code in der while-Schleife mindestens einmal ausgeführt wurde. Sie sollten daher entweder (a.) Ihren Code unter 'doInBackground' in mehrere 'während (laufende)' Blöcke aufteilen oder (b.) Zahlreiche 'isCancelled' ausführen.https://developer.android.com/reference/android/os/AsyncTask.html .

Für Option (a.) Kann man daher Yanchenkos Antwort wie folgt ändern:

public class MyTask extends AsyncTask<Void, Void, Void> {

private volatile boolean running = true;

//...

@Override
protected void onCancelled() {
    running = false;
}

@Override
protected Void doInBackground(Void... params) {

    // does the hard work

    while (running) {
        // part 1 of the hard work
    }

    while (running) {
        // part 2 of the hard work
    }

    // ...

    while (running) {
        // part x of the hard work
    }
    return null;
}

// ...

Für Option (b.) Sieht Ihr Code in 'doInBackground' ungefähr so ​​aus:

public class MyTask extends AsyncTask<Void, Void, Void> {

//...

@Override
protected Void doInBackground(Void... params) {

    // part 1 of the hard work
    // ...
    if (isCancelled()) {return null;}

    // part 2 of the hard work
    // ...
    if (isCancelled()) {return null;}

    // ...

    // part x of the hard work
    // ...
    if (isCancelled()) {return null;}
}

// ...