Android - Impostazione di un timeout per un AsyncTask?

Ho una AsyncTaskclasse che eseguo che scarica un grande elenco di dati da un sito Web.

Nel caso in cui l'utente finale disponga di una connessione dati molto lenta o imprevedibile al momento dell'uso, vorrei effettuare il AsyncTasktimeout dopo un periodo di tempo. Il mio primo approccio a questo è così:

MyDownloader downloader = new MyDownloader();
downloader.execute();
Handler handler = new Handler();
handler.postDelayed(new Runnable()
{
  @Override
  public void run() {
      if ( downloader.getStatus() == AsyncTask.Status.RUNNING )
          downloader.cancel(true);
  }
}, 30000 );

Dopo aver avviato il AsyncTask, viene avviato un nuovo gestore che annullerà AsyncTaskdopo 30 secondi se è ancora in esecuzione.

è un buon approccio? O c'è qualcosa AsyncTaskche è più adatto a questo scopo?

Sì, c'è AsyncTask.get ()

myDownloader.get(30000, TimeUnit.MILLISECONDS);

Nota che chiamando questo nel thread principale (AKA. UI thread) bloccherà l'esecuzione, probabilmente dovrai chiamarlo in un thread separato.

Nel caso, il tuo downloader si basi su una connessione URL, hai una serie di parametri che potrebbero aiutarti a definire un timeout senza codice complesso:

  HttpURLConnection urlc = (HttpURLConnection) url.openConnection();

  urlc.setConnectTimeout(15000);

  urlc.setReadTimeout(15000);

Se porti semplicemente questo codice nel tuo compito asincrono, va bene.

Il "Timeout di lettura" consiste nel testare una rete difettosa lungo tutto il trasferimento.

'Timeout connessione' viene chiamato solo all'inizio per verificare se il server è attivo o meno.

Utilizzare la classe CountDownTimer a fianco della classe estesa per AsyncTask nel metodo onPreExecute ():

Vantaggio principale, il monitoraggio Async eseguito internamente nella classe.

public class YouExtendedClass extends AsyncTask<String,Integer,String> {
...
public YouExtendedClass asyncObject;   // as CountDownTimer has similar method -> to prevent shadowing
...
@Override
protected void onPreExecute() {
    asyncObject = this;
    new CountDownTimer(7000, 7000) {
        public void onTick(long millisUntilFinished) {
            // You can monitor the progress here as well by changing the onTick() time
        }
        public void onFinish() {
            // stop async task if not in progress
            if (asyncObject.getStatus() == AsyncTask.Status.RUNNING) {
                asyncObject.cancel(false);
                // Add any specific task you wish to do as your extended class variable works here as well.
            }
        }
    }.start();
...

cambia CountDownTimer (7000, 7000) -> CountDownTimer (7000, 1000) per esempio e chiamerà onTick () 6 volte prima di chiamare onFinish (). Questo è utile se si desidera aggiungere un po 'di monitoraggio.

Grazie per tutti i buoni consigli che ho ricevuto in questa pagina :-)

Non credo che ci sia qualcosa di simile incorporato in AsyncTask. Il tuo approccio sembra essere buono. Assicurati di controllare periodicamente il valore di isCancelled () nel metodo doInBackground del tuo AsyncTask per terminare questo metodo una volta che il thread dell'interfaccia utente lo annulla.

Se vuoi evitare di usare il gestore per qualche motivo, puoi controllare System.currentTimeMillis periodicamente all'interno di AsyncTask e uscire in timeout, anche se mi piace di più la tua soluzione poiché può effettivamente interrompere il thread.

         Context mContext;

         @Override
         protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
                                    mContext = this;

            //async task
            final RunTask tsk = new RunTask (); 
            tsk.execute();

            //setting timeout thread for async task
            Thread thread1 = new Thread(){
            public void run(){
                try {
                    tsk.get(30000, TimeUnit.MILLISECONDS);  //set time in milisecond(in this timeout is 30 seconds

                } catch (Exception e) {
                    tsk.cancel(true);                           
                    ((Activity) mContext).runOnUiThread(new Runnable()
                    {
                         @SuppressLint("ShowToast")
                        public void run()
                         {
                            Toast.makeText(mContext, "Time Out.", Toast.LENGTH_LONG).show();
                            finish(); //will close the current activity comment if you don't want to close current activity.                                
                         }
                    });
                }
            }
        };
        thread1.start();

         }

Puoi aggiungere un'altra condizione per rendere la cancellazione più solida. per esempio,

 if (downloader.getStatus() == AsyncTask.Status.RUNNING || downloader.getStatus() == AsyncTask.Status.PENDING)
     downloader.cancel(true);

Ispirandomi alla domanda, ho scritto un metodo che esegue alcune attività in background tramite AsyncTask e se l'elaborazione richiede più di LOADING_TIMEOUT, verrà visualizzata una finestra di avviso per riprovare.

public void loadData()
    {
        final Load loadUserList=new Load();
        loadUserList.execute();
        Handler handler = new Handler();
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                if (loadUserList.getStatus() == AsyncTask.Status.RUNNING) {
                    loadUserList.cancel(true);
                    pDialog.cancel();
                    new AlertDialog.Builder(UserList.this)
                            .setTitle("Error..!")
                            .setMessage("Sorry you dont have proper net connectivity..!\nCheck your internet settings or retry.")
                            .setCancelable(false)
                            .setPositiveButton("Retry", new DialogInterface.OnClickListener() {
                                @Override
                                public void onClick(DialogInterface dialogInterface, int i) {
                                    loadData();
                                }
                            })
                            .setNegativeButton("Exit", new DialogInterface.OnClickListener() {
                                @Override


                      public void onClick(DialogInterface dialogInterface, int i) {
                                System.exit(0);
                            }
                        })
                        .show();
            }
        }
    }, LOADING_TIMEOUT);
    return;
}