Source code
package android.support.v4.content;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.Process;
import android.util.Log;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
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;
abstract class ModernAsyncTask<Params, Progress, Result> {
private static final int CORE_POOL_SIZE = 5;
private static final int KEEP_ALIVE = 1;
private static final String LOG_TAG = "AsyncTask";
private static final int MAXIMUM_POOL_SIZE = 128;
private static final int MESSAGE_POST_PROGRESS = 2;
private static final int MESSAGE_POST_RESULT = 1;
public static final Executor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(5, 128, 1, TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
private static volatile Executor sDefaultExecutor = THREAD_POOL_EXECUTOR;
private static InternalHandler sHandler;
private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue(10);
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "ModernAsyncTask #" + this.mCount.getAndIncrement());
}
};
private final FutureTask<Result> mFuture = new FutureTask<Result>(this.mWorker) {
protected void done() {
try {
ModernAsyncTask.this.postResultIfNotInvoked(get());
} catch (InterruptedException e) {
Log.w(ModernAsyncTask.LOG_TAG, e);
} catch (ExecutionException e2) {
throw new RuntimeException("An error occurred while executing doInBackground()", e2.getCause());
} catch (CancellationException e3) {
ModernAsyncTask.this.postResultIfNotInvoked(null);
} catch (Throwable t) {
RuntimeException runtimeException = new RuntimeException("An error occurred while executing doInBackground()", t);
}
}
};
private volatile Status mStatus = Status.PENDING;
private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
private final WorkerRunnable<Params, Result> mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
ModernAsyncTask.this.mTaskInvoked.set(true);
Process.setThreadPriority(10);
return ModernAsyncTask.this.postResult(ModernAsyncTask.this.doInBackground(this.mParams));
}
};
private static class AsyncTaskResult<Data> {
final Data[] mData;
final ModernAsyncTask mTask;
AsyncTaskResult(ModernAsyncTask task, Data... data) {
this.mTask = task;
this.mData = data;
}
}
private static class InternalHandler extends Handler {
public InternalHandler() {
super(Looper.getMainLooper());
}
public void handleMessage(Message msg) {
AsyncTaskResult result = msg.obj;
switch (msg.what) {
case 1:
result.mTask.finish(result.mData[0]);
return;
case 2:
result.mTask.onProgressUpdate(result.mData);
return;
default:
return;
}
}
}
public enum Status {
PENDING,
RUNNING,
FINISHED
}
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
private WorkerRunnable() {
}
}
protected abstract Result doInBackground(Params... paramsArr);
private static Handler getHandler() {
Handler handler;
synchronized (ModernAsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
handler = sHandler;
}
return handler;
}
public static void setDefaultExecutor(Executor exec) {
sDefaultExecutor = exec;
}
private void postResultIfNotInvoked(Result result) {
if (!this.mTaskInvoked.get()) {
postResult(result);
}
}
private Result postResult(Result result) {
getHandler().obtainMessage(1, new AsyncTaskResult(this, result)).sendToTarget();
return result;
}
public final Status getStatus() {
return this.mStatus;
}
protected void onPreExecute() {
}
protected void onPostExecute(Result result) {
}
protected void onProgressUpdate(Progress... progressArr) {
}
protected void onCancelled(Result result) {
onCancelled();
}
protected void onCancelled() {
}
public final boolean isCancelled() {
return this.mFuture.isCancelled();
}
public final boolean cancel(boolean mayInterruptIfRunning) {
return this.mFuture.cancel(mayInterruptIfRunning);
}
public final Result get() throws InterruptedException, ExecutionException {
return this.mFuture.get();
}
public final Result get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
return this.mFuture.get(timeout, unit);
}
public final ModernAsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
public final ModernAsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec, Params... params) {
if (this.mStatus != Status.PENDING) {
switch (this.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)");
}
}
this.mStatus = Status.RUNNING;
onPreExecute();
this.mWorker.mParams = params;
exec.execute(this.mFuture);
return this;
}
public static void execute(Runnable runnable) {
sDefaultExecutor.execute(runnable);
}
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(2, new AsyncTaskResult(this, values)).sendToTarget();
}
}
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
this.mStatus = Status.FINISHED;
}
}