AsyncTask et la gestion des erreurs sur Android

Créer un AsyncResult objet ( que vous pouvez également l'utiliser dans d'autres projets)

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

Retour cet objet à partir de votre AsyncTask doInBackground méthodes et vérifier dans le postExecute. ( Vous pouvez utiliser cette classe comme une classe de base pour vos autres tâches asynchrones )

Ci-dessous est une maquette d'une tâche qui obtient une réponse JSON à partir du serveur 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
            }
        };

    }

Si vous souhaitez utiliser le RoboGuice cadre qui vous apporte d'autres avantages, vous pouvez essayer le RoboAsyncTask qui a un supplément de Rappel onException(). Fonctionne vraiment bien et je l'utilise.
http://code.google.com/p/roboguice/wiki/RoboAsyncTask

Une solution plus complète Cagatay Kalan's solution est indiquée ci-dessous:

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

Exemple De Tâche

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

Une autre façon, qui ne dépend pas de la variable membre partage, c'est l'utilisation de l'annuler.

C'est à partir d'android docs:

public final boolean annuler (boolean mayInterruptIfRunning)

Tente d'annuler l'exécution de cette tâche. Cette
tentative échouera si la tâche est déjà terminée, déjà été
annulé, ou ne peut pas être annulée pour une autre raison. Si
couronnée de succès, et cette tâche n'a pas commencé lors de l'annulation est appelée, ce
la tâche ne doit jamais fonctionner. Si la tâche a déjà commencé, alors le
mayInterruptIfRunning paramètre détermine si le thread
l'exécution de cette tâche doit être interrompu dans une tentative pour arrêter le
de la tâche.

L'appel de cette méthode entraînera onCancelled(Objet) invoquée
sur le thread de l'INTERFACE utilisateur après doInBackground(Object[]) renvoie la. L'appel de cette
méthode garantit que onPostExecute(Objet) n'est jamais appelée. Après
l'invocation de cette méthode, vous devez vérifier la valeur retournée par
isCancelled() afin de doInBackground(Object[]) pour terminer le
la tâche dès que possible.

De sorte que vous pouvez appeler annuler dans l'instruction catch et assurez-vous que onPostExcute n'est jamais appelée, mais au lieu onCancelled est appelée sur le thread de l'INTERFACE utilisateur. Ainsi, vous pouvez afficher le message d'erreur.

Personnellement, je vais utiliser cette approche.
Vous pouvez juste attraper les exceptions et imprimer la trace de la pile si vous avez besoin de l'info.

rendre votre tâche en arrière-plan de renvoyer une valeur booléenne.

c'est comme ça:

    @Override
protected Boolean doInBackground(String... params) {
return readXmlFromWeb(params[0]);
}
@Override
protected void onPostExecute(Boolean result) {
if(result){
//no error
}
else{
//error handling
}
}

Si vous connaissez l'exception correcte, vous pouvez appeler le

Exception e = null;
publishProgress(int ...);

par exemple:

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

et aller à "onProgressUpdate" et de faire ce qui suit

@Override
protected void onProgressUpdate(final Integer... values) {
//TODO Auto-generated method stub
super.onProgressUpdate(values);
mDialog.dismiss();
OptionPane.showMessage(mActivity, "Connection error", e.getMessage());
}

Que ce sera utile dans certains cas seulement. Aussi, vous pouvez conserver une Global Exception variable et l'accès de l'exception.