Sto eseguendo operazioni remote di recupero file audio e riproduzione di file audio in un thread in background utilizzando AsyncTask. UNCancellable una barra di avanzamento per il tempo di esecuzione dell'operazione di recupero.
Voglio annullare / interrompere l' AsyncTaskesecuzione quando l'utente annulla (decide contro) l'operazione. Qual è il modo ideale per gestire un caso del genere?
Risposte:
Appena scoperto che AlertDialogs's boolean cancel(...);ho usato in tutto il mondo in realtà non fa nulla. Grande.
Così...
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;
}
// ...
}while(running)con while(!isCancelled())come altri hanno detto qui nei commenti.
Se stai facendo calcoli :
isCancelled()periodicamente.Se stai eseguendo una richiesta HTTP :
HttpGetoHttpPost da qualche parte (ad es. Un campo pubblico).cancel, chiama request.abort(). Questo farà sì che IOExceptionvenga gettato dentro il tuo doInBackground.Nel mio caso, avevo una classe connettore che ho usato in vari AsyncTask. Per mantenerlo semplice, ho aggiunto un nuovo abortAllRequestsmetodo a quella classe e ho chiamato questo metodo direttamente dopo la chiamata cancel.
HttpGet.abort()da un thread in background o otterrai un file android.os.NetworkOnMainThreadException.
cancel(true)interrompere la richiesta? Dalla documentazione:If the task has already started, then the mayInterruptIfRunning parameter determines whether the thread executing this task should be interrupted in an attempt to stop the task.
HttpURLConnection.disconnect();
cancel(true). L'ho usato e funziona.
Il fatto è che la chiamata AsyncTask.cancel () chiama solo la funzione onCancel nella tua attività. Qui è dove vuoi gestire la richiesta di annullamento.
Ecco una piccola attività che utilizzo per attivare un metodo di aggiornamento
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;
}
}runningflag. AsyncTask ha un flag interno che viene impostato quando l'attività è stata annullata. Sostituisci while (running)con while (!isCancelled()). developer.android.com/reference/android/os/… Quindi, in questo semplice caso, non è necessario onCancelled()eseguire l'override.
Semplice: non utilizzare un file AsyncTask. AsyncTaskè progettato per operazioni brevi che terminano velocemente (decine di secondi) e quindi non necessitano di essere annullate. "Riproduzione di file audio" non si qualifica. Non hai nemmeno bisogno di un thread in background per la normale riproduzione di file audio.
onPostExecute()per vedere se dovresti andare avanti con il lavoro.
È così che scrivo il mio AsyncTask
il punto chiave è aggiungere 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;
}La nostra variabile di classe AsyncTask globale
LongOperation LongOperationOdeme = new LongOperation();E l'azione KEYCODE_BACK che interrompe AsyncTask
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK) {
LongOperationOdeme.cancel(true);
}
return super.onKeyDown(keyCode, event);
}Per me funziona.
Non mi piace forzare l'interruzione delle mie attività asincrone cancel(true)inutilmente perché potrebbero avere risorse da liberare, come la chiusura di socket o flussi di file, la scrittura di dati nel database locale ecc. D'altra parte, ho dovuto affrontare situazioni in cui il l'attività asincrona si rifiuta di terminare se stessa una parte del tempo, ad esempio a volte quando l'attività principale viene chiusa e chiedo che l'attività asincrona finisca dall'interno del onPause()metodo dell'attività . Quindi non si tratta semplicemente di chiamare running = false. Devo optare per una soluzione mista: entrambi chiamano running = false, quindi assegnano all'attività asincrona alcuni millisecondi per terminare, quindi chiamano o 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;
}Di conseguenza, dopo doInBackground() termine, a volte onCancelled()viene chiamato il metodo e talvolta onPostExecute(). Ma almeno la terminazione asincrona dell'attività è garantita.
Con riferimento alla risposta di Yanchenko del 29 aprile '10: l'utilizzo di un approccio 'while (running)' è accurato quando il tuo codice sotto 'doInBackground' deve essere eseguito più volte durante ogni esecuzione dell'AsyncTask. Se il codice in 'doInBackground' deve essere eseguito solo una volta per esecuzione di AsyncTask, avvolgere tutto il codice in 'doInBackground' in un ciclo 'while (running)' non interromperà l'esecuzione del codice in background (thread in background) quando il AsyncTask stesso viene annullato, perché la condizione 'while (running)' verrà valutata solo una volta che tutto il codice all'interno del ciclo while è stato eseguito almeno una volta. Dovresti quindi (a.) Suddividere il codice in "doInBackground" in più blocchi "while (running)" o (b.) Eseguire numerosi "isCancelled"https://developer.android.com/reference/android/os/AsyncTask.html .
Per l'opzione (a.) Si può quindi modificare la risposta di Yanchenko come segue:
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;
}
// ...Per l'opzione (b.) Il tuo codice in 'doInBackground' sarà simile a questo:
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;}
}
// ...