AsyncTask e gestione degli errori su Android

Sto convertendo il mio codice dall'uso Handlera AsyncTask. Quest'ultimo è eccezionale in ciò che fa: aggiornamenti asincroni e gestione dei risultati nel thread dell'interfaccia utente principale. Ciò che non è chiaro per me è come gestire le eccezioni se qualcosa va in tilt AsyncTask#doInBackground.

Il modo in cui lo faccio è avere un gestore degli errori e inviare messaggi ad esso. Funziona bene, ma è l'approccio "giusto" o esiste un'alternativa migliore?

Inoltre capisco che se definisco l'errore Handler come campo Activity, dovrebbe essere eseguito nel thread dell'interfaccia utente. Tuttavia, a volte (molto imprevedibilmente) riceverò un'eccezione che dice che il codice attivato da Handler#handleMessageviene eseguito sul thread errato. Dovrei invece inizializzare Error Handler in Activity#onCreate? La collocazione runOnUiThreadin Handler#handleMessagesembra ridondante ma si esegue in modo molto affidabile.

Funziona bene ma è l'approccio "giusto" e c'è un'alternativa migliore?

Ho tenere sul Throwableo Exceptionnel AsyncTaskistanza stessa e poi fare qualcosa con esso in onPostExecute(), quindi la mia gestione degli errori ha la possibilità di visualizzare una finestra sullo schermo.

Crea un oggetto AsyncResult (che puoi usare anche in altri progetti)

public class AsyncTaskResult<T> {
    private T result;
    private Exception error;

    public T getResult() {
        return result;
    }

    public Exception getError() {
        return error;
    }

    public AsyncTaskResult(T result) {
        super();
        this.result = result;
    }

    public AsyncTaskResult(Exception error) {
        super();
        this.error = error;
    }
}

Restituisci questo oggetto dai tuoi metodi doInBackground di AsyncTask e controllalo in postExecute. (Puoi usare questa classe come classe base per le altre tue attività asincrone)

Di seguito è riportato un mockup di un'attività che ottiene una risposta JSON dal server Web.

AsyncTask<Object,String,AsyncTaskResult<JSONObject>> jsonLoader = new AsyncTask<Object, String, AsyncTaskResult<JSONObject>>() {

        @Override
        protected AsyncTaskResult<JSONObject> doInBackground(
                Object... params) {
            try {
                // get your JSONObject from the server
                return new AsyncTaskResult<JSONObject>(your json object);
            } catch ( Exception anyError) {
                return new AsyncTaskResult<JSONObject>(anyError);
            }
        }

        protected void onPostExecute(AsyncTaskResult<JSONObject> result) {
            if ( result.getError() != null ) {
                // error handling here
            }  else if ( isCancelled()) {
                // cancel handling here
            } else {

                JSONObject realResult = result.getResult();
                // result handling here
            }
        };

    }

Quando sento la necessità di gestire AsyncTaskcorrettamente le eccezioni , lo uso come superclasse:

public abstract class ExceptionAsyncTask<Params, Progress, Result> extends AsyncTask<Params, Progress, Result> {

    private Exception exception=null;
    private Params[] params;

    @Override
    final protected Result doInBackground(Params... params) {
        try {
            this.params = params; 
            return doInBackground();
        }
        catch (Exception e) {
            exception = e;
            return null;
        }
    }

    abstract protected Result doInBackground() throws Exception;

    @Override
    final protected void onPostExecute(Result result) {
        super.onPostExecute(result);
        onPostExecute(exception, result);
    }

    abstract protected void onPostExecute(Exception exception, Result result);

    public Params[] getParams() {
        return params;
    }

}

Come di consueto, si doInBackgroundesegue l' override nella sottoclasse per eseguire il lavoro in background, generando felicemente Eccezioni dove necessario. Sei quindi costretto a implementare onPostExecute(perché è astratto) e questo ti ricorda delicatamente di gestire tutti i tipi di Exception, che vengono passati come parametro. Nella maggior parte dei casi, le eccezioni portano a un qualche tipo di output dell'interfaccia utente, quindi onPostExecuteè un posto perfetto per farlo.

Se si desidera utilizzare il framework RoboGuice che offre altri vantaggi, è possibile provare RoboAsyncTask che ha un ulteriore Callback onException (). Funziona davvero bene e lo uso. http://code.google.com/p/roboguice/wiki/RoboAsyncTask

Ho creato la mia sottoclasse AsyncTask con un'interfaccia che definisce i callback per esito positivo o negativo. Pertanto, se viene generata un'eccezione in AsyncTask, la funzione onFailure viene superata, altrimenti il ​​callback onSuccess viene superato il risultato. Perché Android non abbia qualcosa di meglio disponibile è oltre me.

public class SafeAsyncTask<inBackgroundType, progressType, resultType>
extends AsyncTask<inBackgroundType, progressType, resultType>  {
    protected Exception cancelledForEx = null;
    protected SafeAsyncTaskInterface callbackInterface;

    public interface SafeAsyncTaskInterface <cbInBackgroundType, cbResultType> {
        public Object backgroundTask(cbInBackgroundType[] params) throws Exception;
        public void onCancel(cbResultType result);
        public void onFailure(Exception ex);
        public void onSuccess(cbResultType result);
    }

    @Override
    protected void onPreExecute() {
        this.callbackInterface = (SafeAsyncTaskInterface) this;
    }

    @Override
    protected resultType doInBackground(inBackgroundType... params) {
        try {
            return (resultType) this.callbackInterface.backgroundTask(params);
        } catch (Exception ex) {
            this.cancelledForEx = ex;
            this.cancel(false);
            return null;
        }
    }

    @Override
    protected void onCancelled(resultType result) {
        if(this.cancelledForEx != null) {
            this.callbackInterface.onFailure(this.cancelledForEx);
        } else {
            this.callbackInterface.onCancel(result);
        }
    }

    @Override
    protected void onPostExecute(resultType result) {
        this.callbackInterface.onSuccess(result);
    }
}

Una soluzione più completa per Cagatay Kalan seguito viene mostrata :

AsyncTaskResult

public class AsyncTaskResult<T> 
{
    private T result;
    private Exception error;

    public T getResult() 
    {
        return result;
    }

    public Exception getError() 
    {
        return error;
    }

    public AsyncTaskResult(T result) 
    {
        super();
        this.result = result;
    }

    public AsyncTaskResult(Exception error) {
        super();
        this.error = error;
    }
}

ExceptionHandlingAsyncTask

public abstract class ExceptionHandlingAsyncTask<Params, Progress, Result> extends AsyncTask<Params, Progress, AsyncTaskResult<Result>>
{
    private Context context;

    public ExceptionHandlingAsyncTask(Context context)
    {
        this.context = context;
    }

    public Context getContext()
    {
        return context;
    }

    @Override
    protected AsyncTaskResult<Result> doInBackground(Params... params)
    {
        try
        {
            return new AsyncTaskResult<Result>(doInBackground2(params));
        }
        catch (Exception e)
        {
            return new AsyncTaskResult<Result>(e);
        }
    }

    @Override
    protected void onPostExecute(AsyncTaskResult<Result> result)
    {
        if (result.getError() != null)
        {
            onPostException(result.getError());
        }
        else
        {
            onPostExecute2(result.getResult());
        }
        super.onPostExecute(result);
    }

    protected abstract Result doInBackground2(Params... params);

    protected abstract void onPostExecute2(Result result);

    protected void onPostException(Exception exception)
    {
                        new AlertDialog.Builder(context).setTitle(R.string.dialog_title_generic_error).setMessage(exception.getMessage())
                .setIcon(android.R.drawable.ic_dialog_alert).setPositiveButton(R.string.alert_dialog_ok, new DialogInterface.OnClickListener()
                {
                    public void onClick(DialogInterface dialog, int which)
                    {
                        //Nothing to do
                    }
                }).show();
    }
}

Esempio di attività

public class ExampleTask extends ExceptionHandlingAsyncTask<String, Void, Result>
{
    private ProgressDialog  dialog;

    public ExampleTask(Context ctx)
    {
        super(ctx);
        dialog = new ProgressDialog(ctx);
    }

    @Override
    protected void onPreExecute()
    {
        dialog.setMessage(getResources().getString(R.string.dialog_logging_in));
        dialog.show();
    }

    @Override
    protected Result doInBackground2(String... params)
    {
        return new Result();
    }

    @Override
    protected void onPostExecute2(Result result)
    {
        if (dialog.isShowing())
            dialog.dismiss();
        //handle result
    }

    @Override
    protected void onPostException(Exception exception)
    {
        if (dialog.isShowing())
            dialog.dismiss();
        super.onPostException(exception);
    }
}

Questa semplice lezione può aiutarti

public abstract class ExceptionAsyncTask<Param, Progress, Result, Except extends Throwable> extends AsyncTask<Param, Progress, Result> {
    private Except thrown;

    @SuppressWarnings("unchecked")
    @Override
    /**
     * Do not override this method, override doInBackgroundWithException instead
     */
    protected Result doInBackground(Param... params) {
        Result res = null;
        try {
            res = doInBackgroundWithException(params);
        } catch (Throwable e) {
            thrown = (Except) e;
        }
        return res;
    }

    protected abstract Result doInBackgroundWithException(Param... params) throws Except;

    @Override
    /**
     * Don not override this method, override void onPostExecute(Result result, Except exception) instead
     */
    protected void onPostExecute(Result result) {
        onPostExecute(result, thrown);
        super.onPostExecute(result);
    }

    protected abstract void onPostExecute(Result result, Except exception);
}

Un altro modo che non dipende dalla condivisione dei membri variabili è utilizzare Annulla.

Questo proviene da documenti Android:

annullo booleano finale pubblico (booleano mayInterruptIfRunning)

Tenta di annullare l'esecuzione di questa attività. Questo tentativo fallirà se l'attività è già stata completata, è già stata annullata o non può essere annullata per qualche altro motivo. Se ha esito positivo e questa attività non è stata avviata quando viene chiamato Annulla, questa attività non dovrebbe mai essere eseguita. Se l'attività è già stata avviata, il parametro mayInterruptIfRunning determina se il thread che esegue questa attività deve essere interrotto nel tentativo di arrestare l'attività.

La chiamata a questo metodo comporterà l'invocazione di onCancelled (Object) sul thread dell'interfaccia utente dopo la restituzione di doInBackground (Object []). La chiamata a questo metodo garantisce che onPostExecute (Object) non venga mai richiamato. Dopo aver richiamato questo metodo, è necessario controllare periodicamente il valore restituito da isCancelled () da doInBackground (Object []) per completare l'attività il prima possibile.

Quindi puoi chiamare Annulla nell'istruzione catch e assicurarti che onPostExcute non venga mai chiamato, ma invece OnCancelled viene invocato sul thread dell'interfaccia utente. Quindi puoi mostrare il messaggio di errore.

In realtà, AsyncTask usa FutureTask & Executor, FutureTask supporta la catena di eccezioni Prima di tutto definiamo una classe helper

public static class AsyncFutureTask<T> extends FutureTask<T> {

    public AsyncFutureTask(@NonNull Callable<T> callable) {
        super(callable);
    }

    public AsyncFutureTask<T> execute(@NonNull Executor executor) {
        executor.execute(this);
        return this;
    }

    public AsyncFutureTask<T> execute() {
        return execute(AsyncTask.THREAD_POOL_EXECUTOR);
    }

    @Override
    protected void done() {
        super.done();
        //work done, complete or abort or any exception happen
    }
}

Secondo, usiamo

    try {
        Log.d(TAG, new AsyncFutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                //throw Exception in worker thread
                throw new Exception("TEST");
            }
        }).execute().get());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        //catch the exception throw by worker thread in main thread
        e.printStackTrace();
    }

Personalmente, userò questo approccio. Puoi semplicemente catturare le eccezioni e stampare la traccia dello stack se hai bisogno delle informazioni.

rendere l'attività in background restituire un valore booleano.

è così:

    @Override
                protected Boolean doInBackground(String... params) {
                    return readXmlFromWeb(params[0]);
         }

        @Override
                protected void onPostExecute(Boolean result) {

              if(result){
              // no error
               }
              else{
                // error handling
               }
}

Un'altra possibilità sarebbe quella di utilizzare Objectcome tipo restituito e sotto onPostExecute()controllo per il tipo di oggetto. È corto.

class MyAsyncTask extends AsyncTask<MyInObject, Void, Object> {

    @Override
    protected AsyncTaskResult<JSONObject> doInBackground(MyInObject... myInObjects) {
        try {
            MyOutObject result;
            // ... do something that produces the result
            return result;
        } catch (Exception e) {
            return e;
        }
    }

    protected void onPostExecute(AsyncTaskResult<JSONObject> outcome) {
        if (outcome instanceof MyOutObject) {
            MyOutObject result = (MyOutObject) outcome;
            // use the result
        } else if (outcome instanceof Exception) {
            Exception e = (Exception) outcome;
            // show error message
        } else throw new IllegalStateException();
    }
}

Se conosci l'eccezione corretta, puoi chiamare il

Exception e = null;

publishProgress(int ...);

per esempio:

@Override
protected Object doInBackground(final String... params) {

    // TODO Auto-generated method stub
    try {
        return mClient.call(params[0], params[1]);
    } catch(final XMLRPCException e) {

        // TODO Auto-generated catch block
        this.e = e;
        publishProgress(0);
        return null;
    }
}

e vai su "onProgressUpdate" e fai il folowing

@Override
protected void onProgressUpdate(final Integer... values) {

    // TODO Auto-generated method stub
    super.onProgressUpdate(values);
    mDialog.dismiss();
    OptionPane.showMessage(mActivity, "Connection error", e.getMessage());
}

Questo sarà utile solo in alcuni casi. Inoltre puoi mantenere una Global Exceptionvariabile e accedere all'eccezione.