AsyncTask Wiederholen

Können Sie nicht wiederholen AsyncTask aber könnten Sie wiederholen die Operationen, die Sie führt.

Habe ich dieses kleine Helfer-Klasse, die Sie vielleicht zu erweitern, statt der AsyncTask, der einzige, große Unterschied ist, dass Sie repeatInBackground statt doInBackground und onPostExecute wird einen neuen parameter, der eventuellen Ausnahme geworfen.

Alles, was in repeatInBackground wird automatisch wiederholt, bis das Ergebnis unterscheidet sich von null /exception wird nicht geworfen und es sind weniger als maxTries.

Die Letzte Ausnahme innerhalb der Schleife wird wieder in der onPostExecute(Result, Ausnahme).

Können Sie einstellen, max versucht mit dem RepeatableAsyncTask(int retries) - Konstruktor.

public abstract class RepeatableAsyncTask<A, B, C> extends AsyncTask<A, B, C> {
    private static final String TAG = "RepeatableAsyncTask";
    public static final int DEFAULT_MAX_RETRY = 5;

    private int mMaxRetries = DEFAULT_MAX_RETRY;
    private Exception mException = null;

    /**
     * Default constructor
     */
    public RepeatableAsyncTask() {
        super();
    }

    /**
     * Constructs an AsyncTask that will repeate itself for max Retries
     * @param retries Max Retries.
     */
    public RepeatableAsyncTask(int retries) {
        super();
        mMaxRetries = retries;
    }

    /**
     * Will be repeated for max retries while the result is null or an exception is thrown.
     * @param inputs Same as AsyncTask's
     * @return Same as AsyncTask's
     */
    protected abstract C repeatInBackground(A...inputs);

    @Override
    protected final C doInBackground(A...inputs) {
        int tries = 0;
        C result = null;

        /* This is the main loop, repeatInBackground will be repeated until result will not be null */
        while(tries++ < mMaxRetries && result == null) {
            try {
                result = repeatInBackground(inputs);
            } catch (Exception exception) {
                /* You might want to log the exception everytime, do it here. */
                mException = exception;
            }
        }
        return result;
    }

    /**
     * Like onPostExecute but will return an eventual Exception
     * @param c Result same as AsyncTask
     * @param exception Exception thrown in the loop, even if the result is not null.
     */
    protected abstract void onPostExecute(C c, Exception exception);

    @Override
    protected final void onPostExecute(C c) {
        super.onPostExecute(c);
        onPostExecute(c, mException);
    }
}

Ich es auch so gemacht hat. Kann es versuchen und versuchen, bis (versucht == MAX_RETRY) oder das Ergebnis nicht null ist. Ein leicht modifizierter code von akzeptierten Antworten, besser für mich.

private class RssReaderTask extends AsyncTask<String, Void, ArrayList<RssItem>> {

    //max number of tries when something is wrong
    private static final int MAX_RETRY = 3;

    @Override
    protected ArrayList<RssItem> doInBackground(String... params) {

        ArrayList<RssItem> result = null;
        int tries = 0;

        while(tries++ < MAX_RETRY && result == null) {
            try {
                Log.i("RssReaderTask", "********** doInBackground: Processing... Trial: " + tries);
                URL url = new URL(params[0]);
                RssFeed feed = RssReader.read(url);
                result = feed.getRssItems();
            } catch (Exception ex) {
                Log.i("RssReaderTask", "********** doInBackground: Feed error!");
            }
        }

        return result;
    }

    @Override
    protected void onPostExecute(ArrayList<RssItem> result) {
        //deal with result
    }

}