Yürütülen bir AsyncTask'ı iptal etmenin ideal yolu

Kullanarak bir arka plan iş parçacığında uzaktan ses dosyası getirme ve ses dosyası oynatma işlemlerini çalıştırıyorum AsyncTask. CancellableGetirme işleminin çalıştığı süre için bir ilerleme çubuğu gösterilir.

AsyncTaskKullanıcı işlemi iptal ettiğinde (karşı karar verdiğinde) çalışmayı iptal etmek / iptal etmek istiyorum . Böyle bir vakayı halletmenin ideal yolu nedir?

Sadece keşfetti AlertDialogs's boolean cancel(...);her yerde aslında kullanarak hiçbir şey yapmaz oldum. Harika.
Yani...

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

    // ...

}

Hesaplama yapıyorsanız :

• isCancelled()Periyodik olarak kontrol etmelisiniz .

Bir HTTP isteği yapıyorsanız :

• Örneğinizi HttpGetveya bir HttpPostyere kaydedin (ör. Bir kamu alanı).
• Aradıktan sonra cancelarayın request.abort(). Bu IOExceptionsizin içine atılmasına neden olacaktır doInBackground.

Benim durumumda, çeşitli AsyncTasks'ta kullandığım bir bağlayıcı sınıfım vardı. Basit tutmak abortAllRequestsiçin o sınıfa yeni bir yöntem ekledim ve bu yöntemi çağırdıktan sonra doğrudan çağırdım cancel.

AsyncTask.cancel () çağrısının yalnızca görevinizdeki onCancel işlevini çağırmasıdır. İptal isteğini işlemek istediğiniz yer burasıdır.

İşte bir güncelleme yöntemini tetiklemek için kullandığım küçük bir görev

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

Basit: bir AsyncTask. AsyncTaskhızlı biten (onlarca saniye) ve bu nedenle iptal edilmesi gerekmeyen kısa işlemler için tasarlanmıştır. "Ses dosyası oynatma" uygun değildir. Sıradan ses dosyası oynatmak için bir arka plan iş parçacığına bile ihtiyacınız yok.

Bunu yapmanın tek yolu, isCancelled () yönteminin değerini kontrol etmek ve doğruya döndüğünde oynatmayı durdurmaktır.

AsyncTask'ımı
bu şekilde yazıyorum , anahtar nokta add 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;
    }

Global AsyncTask sınıfı değişkenimiz

LongOperation LongOperationOdeme = new LongOperation();

Ve AsyncTask'ı kesen KEYCODE_BACK eylemi

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

Benim için çalışıyor.

Zaman uyumsuz görevlerimi cancel(true)gereksiz yere kesintiye uğratmaktan hoşlanmıyorum çünkü bunlar serbest bırakılacak kaynaklara sahip olabilir, örneğin soketleri veya dosya akışlarını kapatmak, yerel veritabanına veri yazmak vb. Öte yandan, zaman uyumsuz görev, örneğin bazen ana etkinlik kapatılırken ve zaman uyumsuz görevin etkinlik onPause()yönteminin içinden bitirmesini istediğimde, zamanın bir bölümünde kendisini bitirmeyi reddediyor . Yani bu sadece bir arama meselesi değil running = false. Karma bir çözüme gitmem gerekiyor: her ikisi de arayın running = false, sonra asenkron görevi bitirmek için birkaç milisaniye verin ve sonra ya cancel(false)da çağırın 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;
}

Bir yan sonuç olarak, doInBackground()bitirdikten sonra bazen onCancelled()yöntem çağrılır ve bazen onPostExecute(). Ancak en azından eşzamansız görev sonlandırma garantilidir.

Yanchenko'nun 29 Nisan '10'daki cevabına referansla: 'doInBackground' altındaki kodunuzun AsyncTask'ın her yürütülmesi sırasında birden çok kez çalıştırılması gerektiğinde 'while (koşarken)' yaklaşımını kullanmak düzgündür. 'DoInBackground' altındaki kodunuz, AsyncTask'ın her yürütülmesi için yalnızca bir kez yürütülmesi gerekiyorsa, tüm kodunuzu 'doInBackground' altında bir 'while (çalışırken)' döngüsüne sarmak arka plan kodunun (arka plan iş parçacığı) çalışmasını durdurmaz. AsyncTask'ın kendisi iptal edildi, çünkü 'while (çalışırken)' koşulu yalnızca while döngüsünün içindeki tüm kod en az bir kez çalıştırıldığında değerlendirilecektir. Bu nedenle ya (a.) 'DoInBackground' altındaki kodunuzu birden çok 'while (çalışırken)' bloğuna bölmeli veya (b.) Çok sayıda 'isCancelled' gerçekleştirmelisinizhttps://developer.android.com/reference/android/os/AsyncTask.html .

Seçenek (a.) İçin, Yanchenko'nun cevabı şu şekilde değiştirilebilir:

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

// ...

Seçenek (b.) İçin 'doInBackground'daki kodunuz şuna benzer:

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

// ...