android-openrat

Unnamed repository; edit this file 'description' to name the repository.
git clone http://git.code.weiherhei.de/android-openrat.git
Log | Files | Refs

OpenRatClientAsyncTask.java (3560B)

      1 /**
      2  * 
      3  */
      4 package de.openrat.android.client.util;
      5 
      6 import java.io.IOException;
      7 
      8 import android.app.AlertDialog;
      9 import android.app.ProgressDialog;
     10 import android.app.AlertDialog.Builder;
     11 import android.content.Context;
     12 import android.os.AsyncTask;
     13 import android.util.Log;
     14 
     15 /**
     16  * Ein asynchroner Task für den Zugriff auf den OpenRat-CMS-Server. Der Aufruf
     17  * des Servers muss in der zu überschreibenden Methode {@link #callServer()}
     18  * durchgeführt werden.<br>
     19  * <br>
     20  * <br>
     21  * Während der Serverabfrage wird ein {@link ProgressDialog} angezeigt. Falls
     22  * die Abfrage nicht erfolgreich ist, wird automatisch ein {@link AlertDialog}
     23  * mit einer Fehlermeldung angezeigt.<br>
     24  * <br>
     25  * <br>
     26  * Durch überschreiben von {@link #doOnError(IOException)} kann selber auf einen
     27  * Fehler reagiert werden. Durch Überschreiben von {@link #doOnSuccess()} kann
     28  * eine Aktion nach erfolgreicher Serveranfrage ausgeführt werden. <br>
     29  * 
     30  * @author dankert
     31  * 
     32  */
     33 public abstract class OpenRatClientAsyncTask extends
     34 		AsyncTask<Void, Void, Void>
     35 {
     36 	private ProgressDialog progressDialog;
     37 	private Context context;
     38 	private AlertDialog alertDialog;
     39 	private IOException error;
     40 
     41 	/**
     42 	 * @param context
     43 	 *            Context des Aufrufers
     44 	 * @param message
     45 	 *            Resource-Id für den Text im {@link ProgressDialog}.
     46 	 */
     47 	public OpenRatClientAsyncTask(Context context, int message)
     48 	{
     49 		this.context = context;
     50 
     51 		this.progressDialog = new ProgressDialog(context);
     52 		// progressDialog.setTitle(R.string.loading);
     53 		progressDialog.setMessage(context.getResources().getString(message));
     54 	}
     55 
     56 	@Override
     57 	final protected void onPreExecute()
     58 	{
     59 		progressDialog.show();
     60 	}
     61 
     62 	/**
     63 	 * {@inheritDoc}
     64 	 * 
     65 	 * @see android.os.AsyncTask#onPostExecute(java.lang.Object)
     66 	 */
     67 	@Override
     68 	final protected void onPostExecute(Void result)
     69 	{
     70 		progressDialog.dismiss();
     71 
     72 		if (error != null)
     73 		{
     74 			doOnError(error);
     75 		}
     76 		else
     77 		{
     78 			doOnSuccess();
     79 		}
     80 	}
     81 
     82 	/**
     83 	 * Wird aufgerufen, falls die Serveranfrage nicht durchgeführt werden
     84 	 * konnte. Läuft im UI-Thread.
     85 	 * 
     86 	 * @param error
     87 	 *            Exception, die aufgetreten ist.
     88 	 */
     89 	protected void doOnError(IOException error)
     90 	{
     91 		final Builder builder = new AlertDialog.Builder(this.context);
     92 		alertDialog = builder.setCancelable(true).create();
     93 		final int causeRId = ExceptionUtils.getResourceStringId(error);
     94 		String msg = // this.context.getResources().getString(R.string.reason)
     95 		// + ":\n\n" +
     96 		error.getMessage();
     97 
     98 		Throwable t = error;
     99 		while (t.getCause() != null)
    100 		{
    101 			t = t.getCause();
    102 			msg += ": " + t.getMessage();
    103 		}
    104 
    105 		alertDialog.setTitle(causeRId);
    106 		alertDialog.setIcon(android.R.drawable.ic_menu_close_clear_cancel);
    107 		alertDialog.setMessage(msg);
    108 		alertDialog.show();
    109 
    110 	}
    111 
    112 	/**
    113 	 * Wird aufgerufen, falls die Serveranfrage erfolgreich durchgeführt werden
    114 	 * konnte. Läuft im UI-Thread.
    115 	 */
    116 	protected void doOnSuccess()
    117 	{
    118 	}
    119 
    120 	/**
    121 	 * Startet die Serveranfrage und fängt auftretene Fehler.
    122 	 * 
    123 	 * @see android.os.AsyncTask#doInBackground(Params[])
    124 	 */
    125 	@Override
    126 	final protected Void doInBackground(Void... params)
    127 	{
    128 		try
    129 		{
    130 			callServer();
    131 		}
    132 		catch (IOException e)
    133 		{
    134 			Log.e(this.getClass().getName(), e.getMessage(), e);
    135 			error = e;
    136 		}
    137 
    138 		return null;
    139 	}
    140 
    141 	/**
    142 	 * Ausführen der Serveranfrage. Auftretene {@link IOException} sollte
    143 	 * weitergeworfen werden, da daraus ein {@link AlertDialog} erzeugt wird.
    144 	 * 
    145 	 * @throws IOException
    146 	 *             Vom Server erzeugte Fehler
    147 	 */
    148 	protected abstract void callServer() throws IOException;
    149 }