Android AsyncTaskの実現原理と使用テクニックの共有

private class DemoAsyncTask extends AsyncTask {
    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }

    @Override
    protected Void doInBackground(String... params) {
        return null;
    }   

    @Override
    protected void onPostExecute(Void aVoid) {
        super.onPostExecute(aVoid);
    }

    @Override
    protected void onProgressUpdate(Void... values) {
        super.onProgressUpdate(values);
    }

    @Override
    protected void onCancelled(Void aVoid) {
        super.onCancelled(aVoid);
    }

    @Override
    protected void onCancelled() {
        super.onCancelled();
    }
}

DemoAsyncTask task = new DemoAsyncTask();
task.execute("demo test AsyncTask");
//task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, "test");
//myTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "test");

public final AsyncTask execute(Params... params) {
  return executeOnExecutor(sDefaultExecutor, params);
}
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

public abstract class AsyncTask {
....
}

private final WorkerRunnable mWorker;
private final FutureTask mFuture;
    mWorker = new WorkerRunnable() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);

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

    mFuture = new FutureTask(mWorker) {
        @Override
        protected void done() {
            try {
                postResultIfNotInvoked(get());
            } 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);
            }
        }
    };

public interface Callable {
/**
 * Computes a result, or throws an exception if unable to do so.
 *
 * @return computed result
 * @throws Exception if unable to compute a result
 */
V call() throws Exception;
}

public final AsyncTask     execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}
public final AsyncTask    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;
}

private Result postResult(Result result) {
    @SuppressWarnings("unchecked")
    Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
            new AsyncTaskResult(this, result));
    message.sendToTarget();
    return result;
}
private static final InternalHandler sHandler = new InternalHandler();
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 void finish(Result result) {
    if (isCancelled()) {
        onCancelled(result);
    } else {
        onPostExecute(result);
    }
    mStatus = Status.FINISHED;
}

  @Override
  protected void onPreExecute() {
      super.onPreExecute();
      mDialog.show();

  }

  @Override
  protected void onPostExecute(String aVoid) {
      super.onPostExecute(aVoid);
      dismissDialog();
  }

  @Override
  protected void onProgressUpdate(Integer... values) {
      super.onProgressUpdate(values);

      mNumberProgressBar.setProgress(values[0]);
  }

  @Override
  protected void onCancelled(String aVoid) {
      super.onCancelled(aVoid);
      dismissDialog();
  }

  @Override
  protected void onCancelled() {
      super.onCancelled();
      dismissDialog();
  }

  @Override
  protected String doInBackground(String... params) {
      String urlStr = params[0];
      FileOutputStream output = null;
      try {
          URL url = new URL(urlStr);
          HttpURLConnection connection = (HttpURLConnection)url.openConnection();
          String qqApkFile = "qqApkFile";
          File file = new File(Environment.getExternalStorageDirectory() + "/" + qqApkFile);
          if (file.exists()) {
              file.delete();
          }
          file.createNewFile();
          InputStream input = connection.getInputStream();
          output = new FileOutputStream(file);
          int total = connection.getContentLength();
          if (total <= 0) {
              return null;
          }
          int plus = 0;
          int totalRead = 0;
          byte[] buffer = new byte[4*1024];
          while((plus = input.read(buffer)) != -1){
              output.write(buffer);
              totalRead += plus;
              publishProgress(totalRead * 100 / total);
              if (isCancelled()) {
                  break;
              }
          }
          output.flush();
      } catch (MalformedURLException e) {
          e.printStackTrace();
          if (output != null) {
              try {
                  output.close();
              } catch (IOException e2) {
                  e2.printStackTrace();
              }
          }
      } catch (IOException e) {
          e.printStackTrace();
          if (output != null) {
              try {
                  output.close();
              } catch (IOException e2) {
                  e2.printStackTrace();
              }
          }
      } finally {
          if (output != null) {
              try {
                  output.close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      }
      return null;
  }