Android AsyncTask

相較於 HandlerThread 和 Android Worker Thread(Message+Handler+Looper) 這類比較底層的實作，確實可以掌控訊息傳遞機制的流程。
但在目的比較簡單的情況下，Android也有提供使用上較為方便的類別，AsyncTask。
事實上 AsyncTask 較廣為人知，在UI Thread 上的工作幾乎都可以勝任，其source code註解也有提到

AsyncTask enables proper and easy use of the UI thread.
This class allows to perform background operations and publish results on the UI thread
without having to manipulate threads and/or handlers

簡單的說 AsyncTask 讓你不需要操作 thread 和 handler 就能完成 UI thread 的工作。
但在註解第2段也有提到AsyncTask比較適合短時間的操作（幾秒鐘），長時間的操作請考慮使用 java.util.concurrent 套件。

AsyncTask is designed to be a helper class around Thread and Handler and does not constitute a generic threading framework.
AsyncTasks should ideally be used for short operations (a few seconds at the most.)
If you need to keep threads running for long periods of time, it is highly recommended youuse the various APIs provided by the java.util.concurrent package such as Executor, ThreadPoolExecutor and FutureTask.

首先 AsyncTask 提供4個方法可以複寫，每個方法對應不同的目的。

onPreExecute() :

大多數的初始化工作都可以寫在這裡。除了建構式之外，onPreExecute是第一個被呼叫的。

doInBackground() :

需時操作，可以有參數以及返回值，參數型態必須在定義類別時決定，並在呼叫execute方法時傳入。
返回值也必須在定義類別時決定型態，該型態會相等於onPostExecute()的參數型態。

onProgressUpdate() :

可搭配呼叫 publishProgress方法，由於在doInBackground中不可對 UI thread 的 UI widget 作動作（會產生RuntimeException），若有需要在每次循環中更新UI，
可寫在onProgressUpdate()中。

onCancelled() :

當AsyncTask運行時可以中斷該AsyncTask，而中斷AsyncTask的後續處理，就寫在本方法中。
可以有參數，該參數型態也必須和doInBackground方法的參數型態相同。

onPostExecuted() :

doInBackground()完成的後續處理，當doInBackground完成後會回傳數值，其數值會被傳入onPostExecuted()方法中。
這裡通常放置需時工作完成後，更新UI的動作。

其中 onPreExecute , onPostExecute , onCancelled , onProgressUpdate 都是 run on ui thread ,

也就是說可以在這4個方法中調整 UI 。

首先是外部呼叫範例

package com.foxx.basic.asyctask;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
import com.example.asyctask.R;
public class MainActivity extends Activity implements OnClickListener
{
    public static final String TAG = "asyctask";
    private TextView mTextView;
    private Button mStartButton;
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = (TextView) findViewById(R.id.timeshower);
        mStartButton = (Button) findViewById(R.id.startbutton);
        mStartButton.setOnClickListener(this);
        mStartButton.setText("start a count time dialog");
    }
    @Override
    public void onClick(View view)
    {
        int resId = view.getId();
        switch (resId) {
            case R.id.startbutton:
                executeCountTimerTask();
                break;
        }
    }
    private void executeCountTimeTask()
    {
        SimpleCountTimer countTimer = new SimpleCountTimer(this);
        countTimer.execute(10d);
    }
    public TextView getTextView(){
        return mTextView;
    }
}

只需要注意第40行的 executeCountTimerTask 方法，該方法會在按鈕被按下時被呼叫，其中 10d 為計算秒數的結束時間。
以下是SimpleCountTimer.java

package com.foxx.basic.asyctask;
import android.app.ProgressDialog;
import android.content.DialogInterface;
import android.os.AsyncTask;
import android.util.Log;
public class SimpleCountTimer extends AsyncTask<Double, Integer, String>
{
    protected static final String TAG = "SimpleCountTimer";
    private static final long TIME_SLEEP_INTERVAL = 1000;
    private int mCountTime;
    private ProgressDialog mProgressDialog;
    private MainActivity mMainActivity;
    private Double mCountMax;
    public SimpleCountTimer(MainActivity activity) {
        Log.d(TAG, "in consturctor");
        mMainActivity = activity;
    }
    @Override
    protected String doInBackground(Double... params)
    {
        Log.d(TAG, "in doInBackground");
        mCountMax = params[0];
        while (!isCancelled() && mCountTime < mCountMax) {
            mCountTime++;
            publishProgress(mCountTime);
            threadSleep();
        }
        return "" + mCountTime;
    }
    private void threadSleep()
    {
        try {
            Thread.sleep(TIME_SLEEP_INTERVAL);
        } catch (InterruptedException e) {
            Log.d(TAG, "InterruptedException from threadSleep");
        }
    }
    @Override
    protected void onPreExecute()
    {
        Log.d(TAG, "onPreExecute");
        super.onPreExecute();
        mProgressDialog = new ProgressDialog(mMainActivity);
        mProgressDialog.setCanceledOnTouchOutside(false);
        mProgressDialog.setButton(DialogInterface.BUTTON_POSITIVE, "Cancel Count",
                new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which)
                    {
                        mProgressDialog.dismiss();
                        cancel(true);
                    }
                });
        mProgressDialog.show();
    }
    @Override
    protected void onProgressUpdate(Integer... values)
    {
        Log.d(TAG, "onProgressUpdate");
        mProgressDialog.setMessage("count time :" + values[0]);
    }
    @Override
    protected void onCancelled(String result)
    {
        Log.d(TAG, "onCancelled");
        mMainActivity.getTextView().setText("AsyncTask canceled!! count time at:" + result);
    }
    @Override
    protected void onPostExecute(String result)
    {
        Log.d(TAG, "onPostExecute");
        mProgressDialog.dismiss();
        mMainActivity.getTextView().setText("final time is: " + result);
    }
}

SimpleCountTimer 的工作相當簡單，從外部被呼叫以後，會產生一個Progress Dialog，並在其中顯示計算秒數，計算的時間取決於外部呼叫時傳入的參數而定。
第8行 extends AsyncTask<Double, Integer, String> , 如果沒有傳入參數的需要，可以設定為Void，以下說明各數值影響的方法

Double 為外部呼叫 execute 方法時傳入的參數型態定義，以及doInackground的參數

    private void executeCountTimeTask()
    {
        ...
        countTimer.execute(10d);
    }

此數值會被傳入到doInBackground方法中。

    @Override
    protected String doInBackground(Double... params)
    {
      ...
    }

Integer 會影響publishProgress傳入的參數，

    private int mCountTime;
    @Override
    protected String doInBackground(Double... params)
    {
        ...
        publishProgress(mCountTime);
        ...
    }

也會影響onProgressUpdate方法的參數

    @Override
    protected void onProgressUpdate(Integer... values)
    {
        ...
    }

String 影響 doInBackground 的回傳值，

    @Override
    protected String doInBackground(Double... params)
    {
        ...
    }

以及onCancelled 和 onPostExecute 的參數

    @Override
    protected void onCancelled(String result)
    {
     ...
    }
    @Override
    protected void onPostExecute(String result)
    {
     ...
    }

接著看看個別方法中的內容
第23行 doInBackground 取得外部傳入的數值，並設定為結束值，在while迴圈中遞增計算秒數，當秒數超過最大值或是有中斷發生，即會結束迴圈。
第45行 onPreExecute 方法初始化了 mProgressDialog，並在 mProgressDialog 設定了一個 Button,
button 被按下會中斷 doInBackground 方法，當 cancell(false) , 會讓 isCancelled() 回傳 true，但這種作法對被 block 住的 doInBackground 是沒有效果的，
為了保證被中斷，這裡使用 cancell(true)，當 cancell(true)，除了讓 isCancelled() 回傳 true 以外，還會丟出 InterruptedException ,
InterruptedException 會被 threadSleep 捕捉, 捕捉之後便會呼叫 onCancelled 方法。
第65行更新數值並顯示在 mProgressDialog中
第72行為中斷後的 UI 更新動作。
第79行為完成 doInBackground方法的 UI 更新動作。
接著來看看正常完成的log內容

07-10 17:07:40.535: D/SimpleCountTimer(11457): in consturctor
07-10 17:07:40.535: D/SimpleCountTimer(11457): onPreExecute
07-10 17:07:40.635: D/SimpleCountTimer(11457): in doInBackground
07-10 17:07:40.725: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:07:41.635: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:07:42.635: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:07:43.635: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:07:44.635: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:07:45.645: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:07:46.645: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:07:47.645: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:07:48.645: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:07:49.645: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:07:50.645: D/SimpleCountTimer(11457): onPostExecute

順序為 consturctor -> onPreExecute -> doInBackground -> onProgressUpdate(重複) -> onPostExecute

發生中斷的log內容

07-10 17:10:36.685: D/SimpleCountTimer(11457): in consturctor
07-10 17:10:36.685: D/SimpleCountTimer(11457): onPreExecute
07-10 17:10:36.765: D/SimpleCountTimer(11457): in doInBackground
07-10 17:10:36.855: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:10:37.765: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:10:38.765: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:10:39.765: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:10:40.765: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:10:41.775: D/SimpleCountTimer(11457): onProgressUpdate
07-10 17:10:41.775: D/SimpleCountTimer(11457): InterruptedException from threadSleep
07-10 17:10:41.805: D/SimpleCountTimer(11457): onCancelled

順序為 consturctor -> onPreExecute -> doInBackground -> onProgressUpdate(重複) -> onCancelled

What you think is what you get