Android: Annuler Une Tâche Asynchrone

De SDK:

Annulation d'une tâche

Une tâche peut être annulé à tout moment en appelant annuler(boolean).
L'invocation de cette méthode provoque des appels ultérieurs à isCancelled()
retourner la valeur true.

Après l'invocation de cette méthode, onCancelled(Objet), au lieu de
onPostExecute(Objet) sera invoquée après doInBackground(Object[]) renvoie la.

Pour s'assurer qu'une tâche est annulée aussi rapidement que possible,
vous devriez toujours vérifier la valeur de retour de isCancelled() afin de
doInBackground(Object[]), si possible (dans une boucle par exemple.)

De sorte que votre code est bon pour boîte de dialogue de l'auditeur:

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

Maintenant, comme je l'ai mentionné précédemment, à partir de SDK, vous devez vérifier si la tâche est annulée ou pas, pour que vous devez vérifier isCancelled() à l'intérieur de la onPreExecute() la méthode.

Par exemple:

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

J'ai passé tout en essayant de se faire, tout ce que je voulais, c'était un simple exemple de comment le faire, donc je pensais que je poste comment je l'ai fait. C'est un code qui met à jour une bibliothèque et dispose d'une boîte de dialogue de progression montrant combien de livres ont été mis à jour et annule lorsqu'un utilisateur ferme la boîte de dialogue:

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

Je voudrais améliorer le code. Lorsque vous canel le aSyncTask la onCancelled() (méthode de rappel de aSyncTask) est automatiquement appelé, et il vous pouvez masquer votre progressBarDialog.

Vous pouvez inclure ce code:

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

Vous pouvez simplement demander une annulation, mais pas vraiment d'y mettre fin. Voir ce réponse.

Comment annuler AsyncTask

Réponse complète est ici - Android AsyncTask Exemple

AsyncTask fournit une meilleure annulation de la stratégie, pour terminer la tâche en cours d'exécution.

annuler(boolean mayInterruptIfitRunning)

matache.annuler(faux)- Il fait isCancelled renvoie la valeur true. Permet d'annuler la tâche.

matache.annuler(vrai) – Il permet aussi isCancelled() renvoie true, interrompre le thread d'arrière-plan et soulage les ressources .

Il est considéré comme un arrogant, Si il y a n'importe quel thread.sleep() la méthode d'exécution dans le thread d'arrière-plan, d'annuler(vraie) interrompre le thread d'arrière-plan à cette époque. Mais annuler(false) va l'attendre et annuler la tâche lorsque cette méthode est terminée.

Si vous appelez annuler() et doInBackground() n'a pas commencé à exécuter encore. onCancelled() appellera.

Après avoir invoqué annuler(...) vous devriez vérifier la valeur retournée par isCancelled() sur doInbackground() périodiquement. comme indiqué ci-dessous.

protected Object doInBackground(Params… params)  { 
while (condition)
{
...
if (isCancelled()) 
break;
}
return null; 
}