Forma ideal de cancelar una AsyncTask en ejecución

Estoy ejecutando operaciones remotas de recuperación de archivos de audio y reproducción de archivos de audio en un hilo en segundo plano usando AsyncTask. Se Cancellablemuestra una barra de progreso durante el tiempo que se ejecuta la operación de búsqueda.

Quiero cancelar / abortar la AsyncTaskejecución cuando el usuario cancela (decide en contra) la operación. ¿Cuál es la forma ideal de manejar un caso así?

Acabo de descubrir que AlertDialogs's boolean cancel(...);He estado usando todas partes en realidad no hace nada. Excelente.
Entonces...

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

    // ...

}

Si está haciendo cálculos :

• Tienes que comprobarlo isCancelled()periódicamente.

Si está haciendo una solicitud HTTP :

• Guarde la instancia de su HttpGeto en HttpPostalgún lugar (por ejemplo, un campo público).
• Después de llamar cancel, llame request.abort(). Esto hará que IOExceptionse arroje dentro de su doInBackground.

En mi caso, tenía una clase de conector que usé en varias AsyncTasks. Para mantenerlo simple, agregué un nuevo abortAllRequestsmétodo a esa clase y llamé a este método directamente después de llamar cancel.

La cuestión es que la llamada AsyncTask.cancel () solo llama a la función onCancel en su tarea. Aquí es donde desea manejar la solicitud de cancelación.

Aquí hay una pequeña tarea que utilizo para activar un método de actualización

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

Simple: no uses un AsyncTask. AsyncTaskestá diseñado para operaciones cortas que terminan rápidamente (decenas de segundos) y por lo tanto no necesitan ser canceladas. La "reproducción de archivos de audio" no califica. Ni siquiera necesita un hilo de fondo para la reproducción normal de archivos de audio.

La única forma de hacerlo es verificando el valor del método isCancelled () y deteniendo la reproducción cuando devuelve verdadero.

Así es como escribo mi AsyncTask,
el punto clave es agregar 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;
    }

Nuestra variable de clase global AsyncTask

LongOperation LongOperationOdeme = new LongOperation();

Y la acción KEYCODE_BACK que interrumpe AsyncTask

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

Esto funciona para mi.

No me gusta forzar la interrupción de mis tareas asíncronas cancel(true)innecesariamente porque pueden tener recursos para liberar, como cerrar sockets o flujos de archivos, escribir datos en la base de datos local, etc. Por otro lado, me he enfrentado a situaciones en las que el La tarea asíncrona se niega a terminar parte del tiempo, por ejemplo, a veces cuando se cierra la actividad principal y solicito que la tarea asíncrona termine desde dentro del onPause()método de la actividad . Así que no se trata simplemente de llamar running = false. Tengo que buscar una solución mixta: ambos llaman running = false, luego dan a la tarea asíncrona unos milisegundos para que finalice, y luego llaman cancel(false)o 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;
}

Como resultado secundario, después de doInBackground()finalizar, a veces onCancelled()se llama al método y, a veces onPostExecute(). Pero al menos se garantiza la terminación de la tarea asíncrona.

Con referencia a la respuesta de Yanchenko el 29 de abril de '10: Usar un enfoque 'while (running)' es bueno cuando su código bajo 'doInBackground' debe ejecutarse varias veces durante cada ejecución de AsyncTask. Si su código bajo 'doInBackground' tiene que ejecutarse solo una vez por ejecución de AsyncTask, envolver todo su código bajo 'doInBackground' en un ciclo 'while (running)' no detendrá la ejecución del código de fondo (subproceso de fondo) cuando el AsyncTask en sí se cancela, porque la condición 'while (en ejecución)' solo se evaluará una vez que todo el código dentro del ciclo while se haya ejecutado al menos una vez. Por lo tanto, debe (a.) Dividir su código en 'doInBackground' en múltiples bloques 'while (running)' o (b.) Realizar numerosos 'isCancelled'https://developer.android.com/reference/android/os/AsyncTask.html .

Para la opción (a.), Uno puede modificar la respuesta de Yanchenko de la siguiente manera:

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

// ...

Para la opción (b.), Su código en 'doInBackground' se verá así:

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

// ...