Friday, February 7, 2014

A custom incorporated ProgressDialog and AsyncTask with abstract call back for result and exection

ok,,, Since i am little bit low on readers and subscribers i haven't got any comments on zombie apocalypse caused by the usage of an abstract class to wrap things. So am planning to wrap a ProgressDialog and AsyncTask inside an abstract class this time.
The reason behind this one is quite simple, i was working on the usual android stuff and got tired of implementing and writing progress bar loader each time when i use a network connection or some other asynchronous task. Please do share your thoughts about this one.

Anyhow, during execution, it will show a ProgressDialog window and a callback is made to onPreExecution() and awaits the task in doInAyncTask() to complete, then window will be hidden and a callback to  onPostExecution() is made. 



Usage (Inside an activity) : 

ProgressAsync progressWindow=new ProgressAsync(this,"Loading...") {

 public void onPreExecution(Context cxt) {
 // TODO Auto-generated method stub
 Log.e("Test.Dummy",  "inside onPreExecution");
 }
   
   
     @Override
     public String doInAyncTask(Object... pd) {
     // TODO Auto-generated method stub
      
 //code Some network connection or other aync functions as you require
    
 Log.e("Test.Dummy",  "inside doInAyncTask");

     return null;
     } 
   
   
 @Override
     public void onPostExecution(Object result,Context cxt) {
     // TODO Auto-generated method stub
    
 /* 
  runOnUiThread(new Runnable() {
        
      @Override
      public void run() {
      Toast.makeText(getApplicationContext(), "Task Complete !", Toast.LENGTH_SHORT).show();
      }
      });
 */

         Log.e("Test.Dummy",  "inside onPostExecution");
      }
      
     };
      
     progressWindow.execute(null);




Class : ProgressAsync.java

package com.example.android;

import android.app.ProgressDialog;
import android.content.Context;


public abstract class  ProgressAsync extends AsyncTask<Object, Void, Object>
 {
 ProgressDialog pd;
 Context context;
 
 public ProgressWindow(Context cxt,String msg)
 {
  context=cxt;
   pd=ProgressDialog.show(cxt,"",msg,true);
 }
 
 
 
 @Override
 protected void onPreExecute() {

  super.onPreExecute();
  onPreExecution(context);
 }
 
 
  @Override
  protected Object doInBackground(Object... pd) {
   return doInAyncTask(pd);
  }
  
  
  
  @Override
  protected void onPostExecute(Object result) {
   // TODO Auto-generated method stub
   
   pd.dismiss();
   
   super.onPostExecute(result);
   onPostExecution(result,context);
   
  }
  
  
 public abstract void onPreExecution(Context context);
 public abstract void onPostExecution(Object result,Context context);
 public abstract String doInAyncTask(Object... pd);
  
}

Thursday, February 6, 2014

Custom List Dialog with Abstract callbacks for Android

ok this time I have decided to customize a List View Selection Prompt Dialog using an abstract class with two abstract functions which are invoked on selection event or on cancel event respectively. This method will simplifies the list view dialog to a level in which all you have to do is just to create an object for the class in the activity with necessary parameters and define actions what action to be taken when a callback is made to the abstract functions, I am not sure about the underlying faults that may can occur, please do share your thought on this.


Usage (inside an activity) : 

new ListDialogCustom(this,arrayAdapter,"Select A Table : ") {
   
 @Override
 public void onSelect(DialogInterface dialog,String text, int which) {
    // TODO Auto-generated method stub

      dialog.dismiss();
 }
   
 @Override
 public void onCancel(DialogInterface dialog) {
    
     dialog.dismiss();
    
 }
};


If you want to change a UI or Activity component inside the abstract method please don't forget to use :
   //to Update UI Componenets
    runOnUiThread(new Runnable() {
     
     @Override
     public void run() {
    // TODO Auto-generated method stub
      
     }
    });



Class ListDialogCustom.java

basically this class creates a normal list view dialog and populate items in it with the help of a string based ArrayAdapter :

package com.example.android;

import java.util.ArrayList;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.SharedPreferences;
import android.content.DialogInterface.OnClickListener;
import android.content.SharedPreferences.Editor;
import android.util.Log;
import android.widget.ArrayAdapter;

public abstract class ListDialogCustom {



public ListDialogCustom(Context context,final ArrayAdapter<String> arrayAdapter,String prompt)
{
 
AlertDialog.Builder builderSingle = new AlertDialog.Builder(context);
    builderSingle.setIcon(R.drawable.ic_launcher);
    builderSingle.setTitle(prompt);
    
   // final ArrayAdapter<String> arrayAdapter = new ArrayAdapter<String>(context,android.R.layout.select_dialog_singlechoice);
    

    builderSingle.setNegativeButton("cancel",
            new DialogInterface.OnClickListener() {

                @Override
                public void onClick(DialogInterface dialog, int which) {
                 onCancel(dialog);
                   // dialog.dismiss();
                }
            });

    builderSingle.setAdapter(arrayAdapter,
            new DialogInterface.OnClickListener() {

                @Override
                public void onClick(DialogInterface dialog, int which) {
                    
                 
                 final String name_id= arrayAdapter.getItem(which);
              
                 onSelect(dialog,name_id,which);
                 dialog.dismiss();

                   
                }
            });
    builderSingle.show();
}



public abstract void onSelect(DialogInterface dialog,String text,int which);
public abstract void onCancel(DialogInterface dialog);
 
}

Tuesday, February 4, 2014

A CustomConfirmDialog for android using AlertDialog and Abstract Class

Some of these days while i was working on some android project which uses a hell lot of confirmations, i got tired of using the actual implementation of AlertDialog and decided to write an abstract class to simplify the AlertDialog for confirmation dialog usage, Please do share your thoughts on this concept, Here is what i came up with : 

Usage : 

//Parms : Context,title,prompt text,yes button caption,no button caption
new CustomConfirmDialog(this,"title","prompt","yes","no") {
      
      @Override
      public void onPositiveResult(DialogInterface dialog) {
       // TODO Auto-generated method stub
      
       
       //to Update UI Componenets
       runOnUiThread(new Runnable() {
     
     @Override
     public void run() {
    // TODO Auto-generated method stub
      
     }
    });
       
       
       //for Normal Operations
       dialog.dismiss();
       
      }
      
      @Override
      public void onNegativeResult(DialogInterface dialog) {
       // TODO Auto-generated method stub
       dialog.dismiss();
      }
     };






Class File : CustomConfirmDialog

/* 
http://www.apkman.blogspot.com
*/

import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;

public abstract class CustomConfirmDialog {



public CustomConfirmDialog(Context context,String title,String prompt,String positiveButton,String negativeButton)
{
  AlertDialog.Builder builderInner = new AlertDialog.Builder(context);
     builderInner.setMessage(prompt);
     builderInner.setTitle(title);
     builderInner.setPositiveButton(positiveButton,
             new DialogInterface.OnClickListener() {

      
      
                 @Override
                 public void onClick(
                         DialogInterface dialog,
                         int which) {

               onPositiveResult(dialog);
                 }
                 
                 
                 
                 
             }).setNegativeButton(negativeButton, new OnClickListener() {
     
     @Override
     public void onClick(DialogInterface dialog, int which) {
      // TODO Auto-generated method stub
           
      onNegativeResult(dialog);
     }
    });
     
     
   
     builderInner.show();
 

}





public abstract void onPositiveResult(DialogInterface dialog);
public abstract void onNegativeResult(DialogInterface dialog);
 
}

KitKat 4.4.2 Experimental Version for Lg Optimus P-500

hmmm, i was looking around the net for something interesting and a thread in xda suddenly struct me! A KitKat upgrade for my old legendary LG Optimus One (or P500, or whatever...).

To install this upgrade you have to update the Recovery to CWM Recovery v6.0.4.5.
If you don't know how to do it read this thread :
 http://forum.xda-developers.com/showthread.php?t=2589303

To get latest version of the ROM from Hephappy, or jenkins go to this thread 
http://forum.xda-developers.com/showthread.php?t=2572199

Anyways its fun to play around with our old ones, right ? ;D

Android AsyncTask Parallel Thread Execution Limit and Workarounds

I was working on a custom android based project for a closed environment and during the development I noticed some of the threads i wrote using the async-task awaits for the others to start execution, and bla bla bla long story... so i started digging for answers through the net,,,, and surprise ! I wasn't the only one !,,,
The Core Points : 

  • ThreadPoolExecutor will wait for a future ready state and executes the task when an execute() call made from an AsyncTask.
  • The ready state is determined using core pool size and maximum pool size.
  • If new task comes in and the number of current threads in active execution are less than core pool size, the task will executed immediately, else it will wait for a thread to finish execution and starts a new thread for executing the new task.


Ever Since Android 1.6
  • core pool size = 5,
  • maximum pool size = 128 
  • size of the queue = 10
  • keep-alive timeout  = 10 seconds before 2.3, and 1 second since then.

So the thing is we have a core pool size of 5 and only 5 tasks gets executed in parallel,
to work this around somebody with a slight above IQ (not me :D) than others searching for it (thankyou batman), wrote a custom async-task with custom core-pool size and maximum pool size. All the credits goes to the author of the class,,, am just sharing the code below :

package net.technobeans.fingo.restaurant.background.General;

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

//import java.util.ArrayDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

import android.os.Handler;
import android.os.Message;
import android.os.Process;

/**
 * ### I delete this comments as it make the answer too long to submit ###
 */
public abstract class CustomAsync<Params, Progress, Result> {
    private static final String LOG_TAG = "AsyncTask";

    private static final int CORE_POOL_SIZE = 10;
    private static final int MAXIMUM_POOL_SIZE = 128;
    private static final int KEEP_ALIVE = 1;

    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };

    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(10);

    /**
     * An {@link Executor} that can be used to execute tasks in parallel.
     */
    public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

    /**
     * An {@link Executor} that executes tasks one at a time in serial
     * order.  This serialization is global to a particular process.
     */
//    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

    private static final int MESSAGE_POST_RESULT = 0x1;
    private static final int MESSAGE_POST_PROGRESS = 0x2;

    private static final InternalHandler sHandler = new InternalHandler();

//    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    private static volatile Executor sDefaultExecutor = THREAD_POOL_EXECUTOR;
    private final WorkerRunnable<Params, Result> mWorker;
    private final FutureTask<Result> mFuture;

    private volatile Status mStatus = Status.PENDING;

    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

//    private static class SerialExecutor implements Executor {
//        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
//        Runnable mActive;
//
//        public synchronized void execute(final Runnable r) {
//            mTasks.offer(new Runnable() {
//                public void run() {
//                    try {
//                        r.run();
//                    } finally {
//                        scheduleNext();
//                    }
//                }
//            });
//            if (mActive == null) {
//                scheduleNext();
//            }
//        }
//
//        protected synchronized void scheduleNext() {
//            if ((mActive = mTasks.poll()) != null) {
//                THREAD_POOL_EXECUTOR.execute(mActive);
//            }
//        }
//    }

    /**
     * Indicates the current status of the task. Each status will be set only once
     * during the lifetime of a task.
     */
    public enum Status {
        /**
         * Indicates that the task has not been executed yet.
         */
        PENDING,
        /**
         * Indicates that the task is running.
         */
        RUNNING,
        /**
         * Indicates that {@link CustomAsync#onPostExecute} has finished.
         */
        FINISHED,
    }

    /** @hide Used to force static handler to be created. */
    public static void init() {
        sHandler.getLooper();
    }

    /** @hide */
    public static void setDefaultExecutor(Executor exec) {
        sDefaultExecutor = exec;
    }

    /**
     * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
     */
    public CustomAsync() {
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);

                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                return postResult(doInBackground(mParams));
            }
        };

        mFuture = new FutureTask<Result>(mWorker) {
            @Override
            protected void done() {
                try {
                    final Result result = get();

                    postResultIfNotInvoked(result);
                } catch (InterruptedException e) {
                    android.util.Log.w(LOG_TAG, e);
                } catch (ExecutionException e) {
                    throw new RuntimeException("An error occured while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    postResultIfNotInvoked(null);
                } catch (Throwable t) {
                    throw new RuntimeException("An error occured while executing "
                            + "doInBackground()", t);
                }
            }
        };
    }

    private void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        if (!wasTaskInvoked) {
            postResult(result);
        }
    }

    private Result postResult(Result result) {
        Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

    /**
     * Returns the current status of this task.
     *
     * @return The current status.
     */
    public final Status getStatus() {
        return mStatus;
    }

    /**
     * Override this method to perform a computation on a background thread. The
     * specified parameters are the parameters passed to {@link #execute}
     * by the caller of this task.
     *
     * This method can call {@link #publishProgress} to publish updates
     * on the UI thread.
     *
     * @param params The parameters of the task.
     *
     * @return A result, defined by the subclass of this task.
     *
     * @see #onPreExecute()
     * @see #onPostExecute
     * @see #publishProgress
     */
    protected abstract Result doInBackground(Params... params);

    /**
     * Runs on the UI thread before {@link #doInBackground}.
     *
     * @see #onPostExecute
     * @see #doInBackground
     */
    protected void onPreExecute() {
    }

    /**
     * <p>Runs on the UI thread after {@link #doInBackground}. The
     * specified result is the value returned by {@link #doInBackground}.</p>
     * 
     * <p>This method won't be invoked if the task was cancelled.</p>
     *
     * @param result The result of the operation computed by {@link #doInBackground}.
     *
     * @see #onPreExecute
     * @see #doInBackground
     * @see #onCancelled(Object) 
     */
    @SuppressWarnings({"UnusedDeclaration"})
    protected void onPostExecute(Result result) {
    }

    /**
     * Runs on the UI thread after {@link #publishProgress} is invoked.
     * The specified values are the values passed to {@link #publishProgress}.
     *
     * @param values The values indicating progress.
     *
     * @see #publishProgress
     * @see #doInBackground
     */
    @SuppressWarnings({"UnusedDeclaration"})
    protected void onProgressUpdate(Progress... values) {
    }

    /**
     * <p>Runs on the UI thread after {@link #cancel(boolean)} is invoked and
     * {@link #doInBackground(Object[])} has finished.</p>
     * 
     * <p>The default implementation simply invokes {@link #onCancelled()} and
     * ignores the result. If you write your own implementation, do not call
     * <code>super.onCancelled(result)</code>.</p>
     *
     * @param result The result, if any, computed in
     *               {@link #doInBackground(Object[])}, can be null
     * 
     * @see #cancel(boolean)
     * @see #isCancelled()
     */
    @SuppressWarnings({"UnusedParameters"})
    protected void onCancelled(Result result) {
        onCancelled();
    }    

    /**
     * <p>Applications should preferably override {@link #onCancelled(Object)}.
     * This method is invoked by the default implementation of
     * {@link #onCancelled(Object)}.</p>
     * 
     * <p>Runs on the UI thread after {@link #cancel(boolean)} is invoked and
     * {@link #doInBackground(Object[])} has finished.</p>
     *
     * @see #onCancelled(Object) 
     * @see #cancel(boolean)
     * @see #isCancelled()
     */
    protected void onCancelled() {
    }

    /**
     * Returns <tt>true</tt> if this task was cancelled before it completed
     * normally. If you are calling {@link #cancel(boolean)} on the task,
     * the value returned by this method should be checked periodically from
     * {@link #doInBackground(Object[])} to end the task as soon as possible.
     *
     * @return <tt>true</tt> if task was cancelled before it completed
     *
     * @see #cancel(boolean)
     */
    public final boolean isCancelled() {
        return mFuture.isCancelled();
    }

    /**
     * <p>Attempts to cancel execution of this task.  This attempt will
     * fail if the task has already completed, already been cancelled,
     * or could not be cancelled for some other reason. If successful,
     * and this task has not started when <tt>cancel</tt> is called,
     * this task should never run. If the task has already started,
     * then the <tt>mayInterruptIfRunning</tt> parameter determines
     * whether the thread executing this task should be interrupted in
     * an attempt to stop the task.</p>
     * 
     * <p>Calling this method will result in {@link #onCancelled(Object)} being
     * invoked on the UI thread after {@link #doInBackground(Object[])}
     * returns. Calling this method guarantees that {@link #onPostExecute(Object)}
     * is never invoked. After invoking this method, you should check the
     * value returned by {@link #isCancelled()} periodically from
     * {@link #doInBackground(Object[])} to finish the task as early as
     * possible.</p>
     *
     * @param mayInterruptIfRunning <tt>true</tt> if the thread executing this
     *        task should be interrupted; otherwise, in-progress tasks are allowed
     *        to complete.
     *
     * @return <tt>false</tt> if the task could not be cancelled,
     *         typically because it has already completed normally;
     *         <tt>true</tt> otherwise
     *
     * @see #isCancelled()
     * @see #onCancelled(Object)
     */
    public final boolean cancel(boolean mayInterruptIfRunning) {
        return mFuture.cancel(mayInterruptIfRunning);
    }

    /**
     * Waits if necessary for the computation to complete, and then
     * retrieves its result.
     *
     * @return The computed result.
     *
     * @throws CancellationException If the computation was cancelled.
     * @throws ExecutionException If the computation threw an exception.
     * @throws InterruptedException If the current thread was interrupted
     *         while waiting.
     */
    public final Result get() throws InterruptedException, ExecutionException {
        return mFuture.get();
    }

    /**
     * Waits if necessary for at most the given time for the computation
     * to complete, and then retrieves its result.
     *
     * @param timeout Time to wait before cancelling the operation.
     * @param unit The time unit for the timeout.
     *
     * @return The computed result.
     *
     * @throws CancellationException If the computation was cancelled.
     * @throws ExecutionException If the computation threw an exception.
     * @throws InterruptedException If the current thread was interrupted
     *         while waiting.
     * @throws TimeoutException If the wait timed out.
     */
    public final Result get(long timeout, TimeUnit unit) throws InterruptedException,
            ExecutionException, TimeoutException {
        return mFuture.get(timeout, unit);
    }

    /**
     * Executes the task with the specified parameters. The task returns
     * itself (this) so that the caller can keep a reference to it.
     * 
     * <p>Note: this function schedules the task on a queue for a single background
     * thread or pool of threads depending on the platform version.  When first
     * introduced, AsyncTasks were executed serially on a single background thread.
     * Starting with {@link android.os.Build.VERSION_CODES#DONUT}, this was changed
     * to a pool of threads allowing multiple tasks to operate in parallel.  After
     * {@link android.os.Build.VERSION_CODES#HONEYCOMB}, it is planned to change this
     * back to a single thread to avoid common application errors caused
     * by parallel execution.  If you truly want parallel execution, you can use
     * the {@link #executeOnExecutor} version of this method
     * with {@link #THREAD_POOL_EXECUTOR}; however, see commentary there for warnings on
     * its use.
     *
     * <p>This method must be invoked on the UI thread.
     *
     * @param params The parameters of the task.
     *
     * @return This instance of AsyncTask.
     *
     * @throws IllegalStateException If {@link #getStatus()} returns either
     *         {@link CustomAsync.Status#RUNNING} or {@link CustomAsync.Status#FINISHED}.
     */
    public final CustomAsync<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }

    /**
     * Executes the task with the specified parameters. The task returns
     * itself (this) so that the caller can keep a reference to it.
     * 
     * <p>This method is typically used with {@link #THREAD_POOL_EXECUTOR} to
     * allow multiple tasks to run in parallel on a pool of threads managed by
     * AsyncTask, however you can also use your own {@link Executor} for custom
     * behavior.
     * 
     * <p><em>Warning:</em> Allowing multiple tasks to run in parallel from
     * a thread pool is generally <em>not</em> what one wants, because the order
     * of their operation is not defined.  For example, if these tasks are used
     * to modify any state in common (such as writing a file due to a button click),
     * there are no guarantees on the order of the modifications.
     * Without careful work it is possible in rare cases for the newer version
     * of the data to be over-written by an older one, leading to obscure data
     * loss and stability issues.  Such changes are best
     * executed in serial; to guarantee such work is serialized regardless of
     * platform version you can use this function with {@link #SERIAL_EXECUTOR}.
     *
     * <p>This method must be invoked on the UI thread.
     *
     * @param exec The executor to use.  {@link #THREAD_POOL_EXECUTOR} is available as a
     *              convenient process-wide thread pool for tasks that are loosely coupled.
     * @param params The parameters of the task.
     *
     * @return This instance of AsyncTask.
     *
     * @throws IllegalStateException If {@link #getStatus()} returns either
     *         {@link CustomAsync.Status#RUNNING} or {@link CustomAsync.Status#FINISHED}.
     */
    public final CustomAsync<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
        if (mStatus != Status.PENDING) {
            switch (mStatus) {
                case RUNNING:
                    throw new IllegalStateException("Cannot execute task:"
                            + " the task is already running.");
                case FINISHED:
                    throw new IllegalStateException("Cannot execute task:"
                            + " the task has already been executed "
                            + "(a task can be executed only once)");
            }
        }

        mStatus = Status.RUNNING;

        onPreExecute();

        mWorker.mParams = params;
        exec.execute(mFuture);

        return this;
    }

    /**
     * Convenience version of {@link #execute(Object...)} for use with
     * a simple Runnable object.
     */
    public static void execute(Runnable runnable) {
        sDefaultExecutor.execute(runnable);
    }

    /**
     * This method can be invoked from {@link #doInBackground} to
     * publish updates on the UI thread while the background computation is
     * still running. Each call to this method will trigger the execution of
     * {@link #onProgressUpdate} on the UI thread.
     *
     * {@link #onProgressUpdate} will note be called if the task has been
     * canceled.
     *
     * @param values The progress values to update the UI with.
     *
     * @see #onProgressUpdate
     * @see #doInBackground
     */
    protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }

    private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }

    private static class InternalHandler extends Handler {
        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
        @Override
        public void handleMessage(Message msg) {
            AsyncTaskResult result = (AsyncTaskResult) msg.obj;
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    // There is only one result
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }

    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }

    @SuppressWarnings({"RawUseOfParameterizedType"})
    private static class AsyncTaskResult<Data> {
        final CustomAsync mTask;
        final Data[] mData;

        AsyncTaskResult(CustomAsync task, Data... data) {
            mTask = task;
            mData = data;
        }
    }
}

Followers