Beispiel #1
0
 public DoProgressAsync_AsyncTask(BaseActivity _this, int pTitleResID, andengine.util.progress.ProgressCallable <T> pCallable,
                                  andengine.util.Callback <T> pCallback, andengine.util.Callback <Exception> pExceptionCallback)
 {
     this._this              = _this;
     this.pTitleResID        = pTitleResID;
     this.pCallable          = pCallable;
     this.pCallback          = pCallback;
     this.pExceptionCallback = pExceptionCallback;
 }
Beispiel #2
0
 /**
  * Performs a task in the background, showing a {@link ProgressDialog} with a ProgressBar,
  * while the {@link AsyncCallable} is being processed.
  *
  * @param <T>
  * @param pTitleResID
  * @param pMessageResID
  * @param pErrorMessageResID
  * @param pAsyncCallable
  * @param pCallback
  * @param pExceptionCallback
  */
 protected void DoProgressAsync <T>(int pTitleResID, andengine.util.progress.ProgressCallable <T> pCallable, andengine.util.Callback <T> pCallback, andengine.util.Callback <Exception> pExceptionCallback)
 {
     /* Moved into new inner class: DoProssAsync_AsyncTask
      *      new AsyncTask<Void, Integer, T>() {
      *          private ProgressDialog mPD;
      *          private Exception mException = null;
      *
      *          @Override
      *          public void onPreExecute() {
      *                  this.mPD = new ProgressDialog(BaseActivity.this);
      *                  this.mPD.setTitle(pTitleResID);
      *                  this.mPD.setIcon(android.R.drawable.ic_menu_save);
      *                  this.mPD.setIndeterminate(false);
      *                  this.mPD.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
      *                  this.mPD.show();
      *                  super.onPreExecute();
      *          }
      *
      *          @Override
      *          public T doInBackground(final Void... params) {
      *                  try {
      *                          return pCallable.call(new IProgressListener() {
      *                                  @Override
      *                                  public void onProgressChanged(final int pProgress) {
      *                                          onProgressUpdate(pProgress);
      *                                  }
      *                          });
      *                  } catch (final Exception e) {
      *                          this.mException = e;
      *                  }
      *                  return null;
      *          }
      *
      *          @Override
      *          public void onProgressUpdate(final Integer... values) {
      *                  this.mPD.setProgress(values[0]);
      *          }
      *
      *          @Override
      *          public void onPostExecute(final T result) {
      *                  try {
      *                          this.mPD.dismiss();
      *                  } catch (final Exception e) {
      *                          Debug.e("Error", e);
      *                          /* Nothing. * /
      *                  }
      *
      *                  if(this.isCancelled()) {
      *                          this.mException = new CancelledException();
      *                  }
      *
      *                  if(this.mException == null) {
      *                          pCallback.onCallback(result);
      *                  } else {
      *                          if(pExceptionCallback == null) {
      *                                  Debug.e("Error", this.mException);
      *                          } else {
      *                                  pExceptionCallback.onCallback(this.mException);
      *                          }
      *                  }
      *
      *                  super.onPostExecute(result);
      *          }
      *      }.execute((Void[]) null);
      */
     new DoProgressAsync_AsyncTask <T>(this, pTitleResID, pCallable, pCallback, pExceptionCallback).Execute();
 }
Beispiel #3
0
 /**
  * Performs a task in the background, showing a {@link ProgressDialog} with an ProgressBar,
  * while the {@link AsyncCallable} is being processed.
  *
  * @param <T>
  * @param pTitleResID
  * @param pMessageResID
  * @param pErrorMessageResID
  * @param pAsyncCallable
  * @param pCallback
  */
 protected void DoProgressAsync <T>(int pTitleResID, andengine.util.progress.ProgressCallable <T> pCallable, andengine.util.Callback <T> pCallback)
 {
     this.DoProgressAsync <T>(pTitleResID, pCallable, pCallback, null);
 }