Android - Ein Timeout für eine AsyncTask festlegen?

ich habe ein AsyncTask Klasse, die ich ausführe und die eine große Liste von Daten von einer Website herunterlädt.

Für den Fall, dass der Endbenutzer zum Zeitpunkt der Verwendung eine sehr langsame oder fleckige Datenverbindung hat, möchte ich das AsyncTaskZeitlimit nach einer bestimmten Zeit festlegen. Mein erster Ansatz dazu ist wie folgt:

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

Nach dem Start von AsyncTaskwird ein neuer Handler gestartet, der den Vorgang AsyncTasknach 30 Sekunden abbricht, wenn er noch ausgeführt wird.

Ist das ein guter Ansatz? Oder ist etwas eingebaut AsyncTask, das für diesen Zweck besser geeignet ist?

Ja, es gibt AsyncTask.get ()

myDownloader.get(30000, TimeUnit.MILLISECONDS);

Beachten Sie, dass durch Aufrufen im Hauptthread (AKA. UI-Thread) die Ausführung blockiert wird. Sie müssen ihn wahrscheinlich in einem separaten Thread aufrufen.

In dem Fall, dass Ihr Downloader auf einer URL-Verbindung basiert, verfügen Sie über eine Reihe von Parametern, mit denen Sie ein Timeout ohne komplexen Code definieren können:

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

  urlc.setConnectTimeout(15000);

  urlc.setReadTimeout(15000);

Wenn Sie diesen Code nur in Ihre asynchrone Aufgabe einbringen, ist dies in Ordnung.

'Read Timeout' dient zum Testen eines fehlerhaften Netzwerks während der gesamten Übertragung.

'Verbindungszeitlimit' wird nur zu Beginn aufgerufen, um zu testen, ob der Server aktiv ist oder nicht.

Verwenden Sie die CountDownTimer-Klasse neben der erweiterten Klasse für AsyncTask in der onPreExecute () -Methode:

Hauptvorteil ist die Async-Überwachung, die intern in der Klasse durchgeführt wird.

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

Wenn Sie beispielsweise CountDownTimer (7000, 7000) -> CountDownTimer (7000, 1000) ändern, wird onTick () 6 Mal aufgerufen, bevor onFinish () aufgerufen wird. Dies ist gut, wenn Sie eine Überwachung hinzufügen möchten.

Danke für all die guten Ratschläge, die ich auf dieser Seite bekommen habe :-)

Ich glaube nicht, dass so etwas in AsyncTask eingebaut ist. Ihr Ansatz scheint gut zu sein. Überprüfen Sie regelmäßig den Wert von isCancelled () in der doInBackground-Methode Ihrer AsyncTask, um diese Methode zu beenden, sobald der UI-Thread sie abbricht.

Wenn Sie die Verwendung des Handlers aus irgendeinem Grund vermeiden möchten, können Sie System.currentTimeMillis regelmäßig in Ihrer AsyncTask überprüfen und bei Zeitüberschreitung beenden, obwohl mir Ihre Lösung besser gefällt, da sie den Thread tatsächlich unterbrechen kann.

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

         }

Sie können eine weitere Bedingung festlegen, um die Stornierung robuster zu gestalten. z.B,

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

Inspirierend von der Frage habe ich eine Methode geschrieben, die eine Hintergrundaufgabe über AsyncTask ausführt. Wenn die Verarbeitung länger als LOADING_TIMEOUT dauert, wird ein Warndialog zum erneuten Versuch angezeigt.

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