Android: Cancelar Tarea Asíncrona

Desde SDK:

Cancelar una tarea

Una tarea puede ser cancelada en cualquier momento invocando cancel(booleano). Invocar este método causará llamadas posteriores a isCancelled() para devolver true.

Después de invocar este método, onCancelled (Object), en lugar de onPostExecute (Object) se invocará después de que regrese doInBackground(Object []).

Para garantizar que una tarea se cancele lo antes posible, siempre debe comprobar el valor devuelto de isCancelled () periódicamente desde doInBackground (Object []), si es posible (dentro de un bucle, por ejemplo.)

Así que su código es correcto para el oyente de diálogo:

uploadingDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
    public void onCancel(DialogInterface dialog) {
        myTask.cancel(true);
        //finish();
    }
});

Ahora, como he mencionado anteriormente desde SDK, tienes que comprobar si la tarea está cancelada o no, para eso tienes que comprobar isCancelled() dentro del método onPreExecute ().

Por ejemplo:

if (isCancelled()) 
    break;
else
{
   // do your work here
}

Pasé un tiempo averiguando esto, todo lo que quería era un ejemplo simple de cómo hacerlo, así que pensé en publicar cómo lo hice. Este es un código que actualiza una biblioteca y tiene un diálogo de progreso que muestra cuántos libros se han actualizado y se cancela cuando un usuario descarta el diálogo:

private class UpdateLibrary extends AsyncTask<Void, Integer, Boolean>{
    private ProgressDialog dialog = new ProgressDialog(Library.this);
    private int total = Library.instance.appState.getAvailableText().length;
    private int count = 0;

    //Used as handler to cancel task if back button is pressed
    private AsyncTask<Void, Integer, Boolean> updateTask = null;

    @Override
    protected void onPreExecute(){
        updateTask = this;
        dialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
        dialog.setOnDismissListener(new OnDismissListener() {               
            @Override
            public void onDismiss(DialogInterface dialog) {
                updateTask.cancel(true);
            }
        });
        dialog.setMessage("Updating Library...");
        dialog.setMax(total);
        dialog.show();
    }

    @Override
    protected Boolean doInBackground(Void... arg0) {
            for (int i = 0; i < appState.getAvailableText().length;i++){
                if(isCancelled()){
                    break;
                }
                //Do your updating stuff here
            }
        }

    @Override
    protected void onProgressUpdate(Integer... progress){
        count += progress[0];
        dialog.setProgress(count);
    }

    @Override
    protected void onPostExecute(Boolean finished){
        dialog.dismiss();
        if (finished)
            DialogHelper.showMessage(Str.TEXT_UPDATELIBRARY, Str.TEXT_UPDATECOMPLETED, Library.instance);
        else 
            DialogHelper.showMessage(Str.TEXT_UPDATELIBRARY,Str.TEXT_NOUPDATE , Library.instance);
    }
}

Crea algunas variables miembro en tu actividad como

YourAsyncTask mTask;
Dialog mDialog;

Use estos para su diálogo y tarea;

En onPause() simplemente llame a

if(mTask!=null) mTask.cancel(); 
if(mDialog!=null) mDialog.dismiss();

Me gustaría mejorar el código. Cuando canel el aSyncTask el onCancelled() (método de devolución de llamada de aSyncTask) se llama automáticamente, y allí puede ocultar su progressBarDialog.

También puedes incluir este código:

public class information extends AsyncTask<String, String, String>
    {
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }

        @Override
        protected String doInBackground(String... arg0) {
            return null;
        }

        @Override
        protected void onPostExecute(String result) {
            super.onPostExecute(result);
            this.cancel(true);
        }

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

        @Override
        protected void onCancelled() {
            Toast.makeText(getApplicationContext(), "asynctack cancelled.....", Toast.LENGTH_SHORT).show();
            dialog.hide(); /*hide the progressbar dialog here...*/
            super.onCancelled();
        }

    }

La mayor parte del tiempo que uso AsyncTask mi lógica de negocio es en una clase de negocio separada en lugar de estar en la interfaz de usuario. En ese caso, no podría tener un bucle en doInBackground (). Un ejemplo sería un proceso de sincronización que consume servicios y persiste datos uno tras otro.

Termino entregando mi tarea al objeto de negocio para que pueda manejar la cancelación. Mi configuración es así:

public abstract class MyActivity extends Activity {

    private Task mTask;
    private Business mBusiness;

    public void startTask() {
        if (mTask != null) {
            mTask.cancel(true);
        }
        mTask = new mTask();
        mTask.execute();
    }
}

protected class Task extends AsyncTask<Void, Void, Boolean> {
    @Override
    protected void onCancelled() {
        super.onCancelled();

        mTask.cancel(true);

        // ask if user wants to try again
    }

    @Override
    protected Boolean doInBackground(Void... params) {
        return mBusiness.synchronize(this);
    }

    @Override
    protected void onPostExecute(Boolean result) {
        super.onPostExecute(result);

        mTask = null;

        if (result) {
            // done!
        }
        else {
            // ask if user wants to try again
        }
    }
}

public class Business {
    public boolean synchronize(AsyncTask<?, ?, ?> task) {
        boolean response = false;
        response = loadStuff(task);

        if (response)
            response = loadMoreStuff(task);

        return response;
    }

    private boolean loadStuff(AsyncTask<?, ?, ?> task) {
        if (task != null && task.isCancelled()) return false;

        // load stuff

        return true;
    }
}

Solo puede solicitar la cancelación, pero en realidad no terminarla. Vea esta respuesta.

Tuve un problema similar - esencialmente estaba recibiendo un NPE en una tarea asincrónica después de que el usuario había destruido la actividad. Después de investigar el problema del desbordamiento de pila, adopté la siguiente solución:

volatile boolean running;

public void onActivityCreated (Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);

    running=true;
    ...
    }


public void onDestroy() {
    super.onDestroy();

    running=false;
    ...
}

Luego, compruebo "si se está ejecutando" periódicamente en mi código asincrónico. He probado el estrés esto y ahora soy incapaz de "romper" mi actividad. Esto funciona perfectamente y tiene la ventaja de ser más simple que algunas de las soluciones que he visto en SO.