Moyen idéal pour annuler une AsyncTask en cours d'exécution

J'exécute des opérations de récupération de fichiers audio et de lecture de fichiers audio à distance dans un thread d'arrière-plan en utilisant AsyncTask. Une Cancellablebarre de progression s'affiche pour le temps d'exécution de l'opération d'extraction.

Je veux annuler / abandonner l' AsyncTaskexécution lorsque l'utilisateur annule (décide de ne pas) l'opération. Quelle est la manière idéale de gérer un tel cas?

Juste découvert que AlertDialogs« s que boolean cancel(...);je l' ai utilisé partout ne fait rien. Génial.
Alors...

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 vous faites des calculs :

• Vous devez vérifier isCancelled()périodiquement.

Si vous faites une requête HTTP :

• Enregistrez l'instance de votre HttpGetou HttpPostquelque part (par exemple, un champ public).
• Après avoir appelé cancel, appelez request.abort(). Cela provoquera IOExceptionêtre jeté à l'intérieur de votre fichier doInBackground.

Dans mon cas, j'avais une classe de connecteur que j'ai utilisée dans diverses AsyncTasks. Pour faire simple, j'ai ajouté une nouvelle abortAllRequestsméthode à cette classe et j'ai appelé cette méthode directement après l'appel cancel.

Le fait est que l'appel AsyncTask.cancel () n'appelle que la fonction onCancel dans votre tâche. C'est là que vous souhaitez traiter la demande d'annulation.

Voici une petite tâche que j'utilise pour déclencher une méthode de mise à jour

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: n'utilisez pas de fichier AsyncTask. AsyncTaskest conçu pour des opérations courtes qui se terminent rapidement (dizaines de secondes) et n'ont donc pas besoin d'être annulées. "Lecture de fichier audio" n'est pas admissible. Vous n'avez même pas besoin d'un fil d'arrière-plan pour la lecture de fichiers audio ordinaires.

La seule façon de le faire est de vérifier la valeur de la méthode isCancelled () et d'arrêter la lecture lorsqu'elle renvoie true.

C'est ainsi que j'écris mon AsyncTask
le point clé est d'ajouter 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;
    }

Notre variable de classe globale AsyncTask

LongOperation LongOperationOdeme = new LongOperation();

Et action KEYCODE_BACK qui interrompent AsyncTask

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

Ça marche pour moi.

Je n'aime pas forcer d'interrompre cancel(true)inutilement mes tâches asynchrones car elles peuvent avoir des ressources à libérer, telles que la fermeture de sockets ou de flux de fichiers, l'écriture de données dans la base de données locale, etc. D'autre part, j'ai été confronté à des situations dans lesquelles le La tâche async refuse de se terminer une partie du temps, par exemple parfois lorsque l'activité principale est en cours de fermeture et que je demande à la tâche asynchrone de se terminer depuis l'intérieur de la onPause()méthode de l'activité . Il ne s'agit donc pas simplement d'appeler running = false. Je dois opter pour une solution mixte: les deux appellent running = false, puis donnent à la tâche asynchrone quelques millisecondes pour terminer, puis appellent soit cancel(false)ou 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;
}

En conséquence, après les doInBackground()finitions, la onCancelled()méthode est parfois appelée, et parfois onPostExecute(). Mais au moins la fin de la tâche asynchrone est garantie.

En référence à la réponse de Yanchenko du 29 avril '10: Utiliser une approche 'while (running)' est bien lorsque votre code sous 'doInBackground' doit être exécuté plusieurs fois lors de chaque exécution de l'AsyncTask. Si votre code sous 'doInBackground' doit être exécuté une seule fois par exécution de l'AsyncTask, envelopper tout votre code sous 'doInBackground' dans une boucle 'while (running)' n'empêchera pas le code d'arrière-plan (thread d'arrière-plan) de s'exécuter lorsque le AsyncTask lui-même est annulé, car la condition 'while (running)' ne sera évaluée qu'une fois que tout le code à l'intérieur de la boucle while aura été exécuté au moins une fois. Vous devez donc soit (a.) Diviser votre code sous 'doInBackground' en plusieurs blocs 'while (running)' ou (b.) Effectuer de nombreux 'isCancelled'https://developer.android.com/reference/android/os/AsyncTask.html .

Pour l'option (a.), On peut donc modifier la réponse de Yanchenko comme suit:

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

// ...

Pour l'option (b.), Votre code dans 'doInBackground' ressemblera à ceci:

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

// ...