Android異步線程AsyncTask封裝

最近工作用到很多線程，現公司代碼中用的最多的就是Thread+Handler，簡直不要再麻煩，一堆的sendMessage()和一堆的handleMessage()，每個類用到的地方都要重新複製一遍；想起前公司老大用的封裝好的AsyncTask，對比起來太舒服了，於是整理出來，順便分享給大家，合適的就拿去哦。

---

package com.test.utils;

import android.app.ProgressDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.os.AsyncTask;
import android.text.TextUtils;
import android.util.Log;


import java.util.concurrent.Callable;

/**
 * AsyncTaskUtils.java
 * @author haiphon.huang
 * @description 異步線程調用工具類,其中返回值都是泛型，所以成功和失敗想要哪種類型在調用的時候就用哪種類型。
 * @author Created by haiphon.huang 2017.5.1
 * 注意：其中Callable 是android-23裏面自帶的
 */
public class AsyncTaskUtils {
    /**
     * @param pContext 上下文
     * @param pTitleResourceID xml裏面的 R.string.* 類型的參數，顯示爲加載框標題，null則沒有加載標題提示
     * @param pMessageResourceID xml裏面的 R.string.* 類型的參數，顯示爲加載框內容，null則沒有加載內容提示
     * @param pCallable 耗時代碼寫在此
     * @param PCallBack 任務成功/失敗的回調函數，自己根據返回值進行判斷處理，自己根據返回值進行判斷處理
     * @param <T> 默認是false，代表不能取消該任務
     */
    public static <T> void doAsync(final Context pContext,
                                   final int pTitleResourceID, final int pMessageResourceID,
                                   final Callable<T> pCallable, final Callback<T> PCallBack) {
        AsyncTaskUtils.doAsync(pContext, pTitleResourceID, pMessageResourceID,
                pCallable, PCallBack, null, false);
    }

    /**
     * @param pContext 上下文
     * @param pTitle 傳遞String/CharSequence類型參數，顯示爲加載框標題，null則沒有加載標題提示
     * @param pMessage 傳遞String/CharSequence類型參數，顯示爲加載框內容，null則沒有加載內容提示
     * @param pCallable 耗時代碼寫在此
     * @param pFailedCallback 任務成功/失敗的回調函數，自己根據返回值進行判斷處理
     * @param <T> 默認是false，代表不能取消該任務
     */
    public static <T> void doAsync(final Context pContext,
                                   final CharSequence pTitle, final CharSequence pMessage,
                                   final Callable<T> pCallable, final Callback<T> pFailedCallback) {
        AsyncTaskUtils.doAsync(pContext, pTitle, pMessage, pCallable, pFailedCallback,
                null, false);
    }

    /**
     * @param pContext 上下文
     * @param pTitleResourceID xml裏面的 R.string.* 類型的參數，顯示爲加載框標題，null則沒有加載標題提示
     * @param pMessageResourceID xml裏面的 R.string.* 類型的參數，顯示爲加載框內容，null則沒有加載內容提示
     * @param pCallable 耗時代碼寫在此
     * @param pFailedCallback 任務成功/失敗的回調函數，自己根據返回值進行判斷處理
     * @param pCancelable 傳遞true代表可以取消該任務，false代表不能取消該任務
     */
    public static <T> void doAsync(final Context pContext,
                                   final int pTitleResourceID, final int pMessageResourceID,
                                   final Callable<T> pCallable, final Callback<T> pFailedCallback,
                                   final boolean pCancelable) {
        AsyncTaskUtils.doAsync(pContext, pTitleResourceID, pMessageResourceID,
                pCallable, pFailedCallback, null, pCancelable);
    }

    /**
     * @param pContext 上下文
     * @param pTitle 傳遞String/CharSequence類型參數，顯示爲加載框標題，null則沒有加載標題提示
     * @param pMessage 傳遞String/CharSequence類型參數，顯示爲加載框內容，null則沒有加載內容提示
     * @param pCallable 耗時代碼寫在此
     * @param pFailedCallback 任務成功/失敗的回調函數，自己根據返回值進行判斷處理
     * @param pCancelable 傳遞true代表可以取消該任務，false代表不能取消該任務
     */
    public static <T> void doAsync(final Context pContext,
                                   final CharSequence pTitle, final CharSequence pMessage,
                                   final Callable<T> pCallable, final Callback<T> pFailedCallback,
                                   final boolean pCancelable) {
        AsyncTaskUtils.doAsync(pContext, pTitle, pMessage, pCallable, pFailedCallback,
                null, pCancelable);
    }

    /**
     * @param pContext 上下文
     * @param pTitleResourceID xml裏面的 R.string.* 類型的參數，顯示爲加載框標題，null則沒有加載標題提示
     * @param pMessageResourceID xml裏面的 R.string.* 類型的參數，顯示爲加載框內容，null則沒有加載內容提示
     * @param pCallable 耗時代碼寫在此
     * @param pFailedCallback 任務成功/失敗的回調函數，自己根據返回值進行判斷處理
     * @param pExceptionCallback  任務參數錯誤或者其他導致的異常回調
     * @param <T> 默認是false，代表不能取消該任務
     */
    public static <T> void doAsync(final Context pContext,
                                   final int pTitleResourceID, final int pMessageResourceID,
                                   final Callable<T> pCallable, final Callback<T> pFailedCallback,
                                   final Callback<Exception> pExceptionCallback) {
        AsyncTaskUtils.doAsync(pContext, pTitleResourceID, pMessageResourceID,
                pCallable, pFailedCallback, pExceptionCallback, false);
    }

    /**
     * @param pContext 上下文
     * @param pTitle xml裏面的 R.string.* 類型的參數，顯示爲加載框標題，null則沒有加載標題提示
     * @param pMessage xml裏面的 R.string.* 類型的參數，顯示爲加載框內容，null則沒有加載內容提示
     * @param pCallable 耗時代碼寫在此
     * @param pFailedCallback 任務成功/失敗的回調函數，自己根據返回值進行判斷處理
     * @param pExceptionCallback  任務參數錯誤或者其他導致的異常回調
     * @param <T> 默認是false，代表不能取消該任務
     */
    public static <T> void doAsync(final Context pContext,
                                   final CharSequence pTitle, final CharSequence pMessage,
                                   final Callable<T> pCallable, final Callback<T> pFailedCallback,
                                   final Callback<Exception> pExceptionCallback) {
        AsyncTaskUtils.doAsync(pContext, pTitle, pMessage, pCallable, pFailedCallback,
                pExceptionCallback, false);
    }

    /**
     * @param pContext 上下文
     * @param pTitle xml裏面的 R.string.* 類型的參數，顯示爲加載框標題，null則沒有加載標題提示
     * @param pMessage xml裏面的 R.string.* 類型的參數，顯示爲加載框內容，null則沒有加載內容提示
     * @param pCallable 耗時代碼寫在此
     * @param pFailedCallback 任務成功/失敗的回調函數，自己根據返回值進行判斷處理
     * @param pExceptionCallback  任務參數錯誤或者其他導致的異常回調
     * @param pCancelable 傳遞true代表可以取消該任務，false代表不能取消該任務
     */
    public static <T> void doAsync(final Context pContext,//2 4 6
                                   final CharSequence pTitle, final CharSequence pMessage,
                                   final Callable<T> pCallable, final Callback<T> pFailedCallback,
                                   final Callback<Exception> pExceptionCallback,
                                   final boolean pCancelable) {
        if (TextUtils.isEmpty(pTitle) && TextUtils.isEmpty(pMessage)) {
            doAsync(pCallable, pFailedCallback, pExceptionCallback);
        } else {
            doAsyncTip(pContext, pTitle, pMessage, pCallable, pFailedCallback,
                    pExceptionCallback, pCancelable);
        }
    }

    /**
     * @param pContext 上下文
     * @param pTitleResourceID xml裏面的 R.string.* 類型的參數，顯示爲加載框標題，null則沒有加載標題提示
     * @param pMessageResourceID xml裏面的 R.string.* 類型的參數，顯示爲加載框內容，null則沒有加載內容提示
     * @param pCallable 耗時代碼寫在此
     * @param pFailedCallback 任務成功/失敗的回調函數，自己根據返回值進行判斷處理
     * @param pExceptionCallback  任務參數錯誤或者其他導致的異常回調
     * @param pCancelable 傳遞true代表可以取消該任務，false代表不能取消該任務
     */
    public static <T> void doAsync(final Context pContext,//1 3 5
                                   final int pTitleResourceID, final int pMessageResourceID,
                                   final Callable<T> pCallable, final Callback<T> pFailedCallback,
                                   final Callback<Exception> pExceptionCallback,
                                   final boolean pCancelable) {
        AsyncTaskUtils.doAsync(pContext, pContext.getString(pTitleResourceID),
                pContext.getString(pMessageResourceID), pCallable, pFailedCallback,
                pExceptionCallback, pCancelable);
    }

    /**
     * @param pContext 上下文
     * @param pTitle 傳遞String/CharSequence類型參數，顯示爲加載框標題，null則沒有加載標題提示
     * @param pMessage 傳遞String/CharSequence類型參數，顯示爲加載框內容，null則沒有加載內容提示
     * @param pCallable 耗時代碼寫在此
     * @param pFailedCallback 任務成功/失敗的回調函數，自己根據返回值進行判斷處理
     * @param pExceptionCallback  任務參數錯誤或者其他導致的異常回調
     * @param pCancelable 傳遞true代表可以取消該任務，false代表不能取消該任務
     */
    private static <T> void doAsyncTip(final Context pContext,
                                       final CharSequence pTitle, final CharSequence pMessage,
                                       final Callable<T> pCallable, final Callback<T> pFailedCallback,
                                       final Callback<Exception> pExceptionCallback,
                                       final boolean pCancelable) {
        final ProgressDialog mPD = new ProgressDialog(pContext);
        try {
            mPD.setMessage(pMessage);
            if (!TextUtils.isEmpty(pTitle)) {
                mPD.setTitle(pTitle);
            }
            mPD.setCancelable(pCancelable);
            mPD.setIndeterminate(true);
            mPD.show();
            if (pCancelable) {
                mPD.setOnCancelListener(new DialogInterface.OnCancelListener() {
                    @Override
                    public void onCancel(final DialogInterface pDialogInterface) {
                        pExceptionCallback.onCallback(new Exception());
                        pDialogInterface.dismiss();
                    }
                });
            }
        } catch (Exception e) {
            mPD.hide();
            mPD.cancel();
            mPD.dismiss();
            e.printStackTrace();
        }

        new AsyncTask<Void, Void, T>() {

            private Exception mException = null;

            @Override
            public T doInBackground(final Void... params) {
                try {
                    return pCallable.call();
                } catch (final Exception e) {
                    this.mException = e;
                }
                return null;
            }

            @Override
            public void onPostExecute(final T result) {
                try {
                    mPD.hide();
                    mPD.cancel();
                    mPD.dismiss();
                } catch (final Exception e) {
                    Log.e("Error", e.getMessage(), e);
                    // Debug.e("Error", e);
                }

                if (this.isCancelled()) {
                    this.mException = new Exception();
                }

                if (this.mException == null) {
                    if (pFailedCallback != null) {
                        pFailedCallback.onCallback(result);
                    }
                } else {
                    if (pExceptionCallback == null) {
                        Log.e("Error", mException.getMessage(), mException);
                        // Debug.e("Error", this.mException);
                    } else {
                        pExceptionCallback.onCallback(this.mException);
                    }
                }
            }
        }.execute((Void[]) null);

    }


    public static <T> void doAsync(final Callable<T> pCallable,
                                   final Callback<T> pFailedCallback,
                                   final Callback<Exception> pExceptionCallback) {
        new AsyncTask<Void, Integer, T>() {
            private Exception mException = null;

            @Override
            public T doInBackground(final Void... params) {
                try {
                    return pCallable.call();
                } catch (final Exception e) {
                    this.mException = e;
                }
                return null;
            }

            @Override
            public void onPostExecute(final T result) {

                if (this.isCancelled()) {
                    this.mException = new Exception();
                }

                if (this.mException == null) {
                    if (pFailedCallback != null) {
                        try {
                            pFailedCallback.onCallback(result);
                        } catch (Exception e) {
                            if (pExceptionCallback == null) {
                                Log.e("Error", e.getMessage(), e);
                                // Debug.e("Error", this.mException);
                            } else {
                                pExceptionCallback.onCallback(e);
                            }
                        }
                    }
                } else {
                    if (pExceptionCallback == null) {
                        Log.e("Error", mException.getMessage(), mException);
                        // Debug.e("Error", this.mException);
                    } else {
                        pExceptionCallback.onCallback(this.mException);
                    }
                }
            }
        }.execute((Void[]) null);
    }

    /**
     * @author jacky.huang
     * @version 2.0.2  2013-2-22
     * @name Callback.java.java
     * @description <回調>
     */
    public interface Callback<T> {

        public void onCallback(final T pCallbackValue);
    }
}

---

上面就是AsyncTaskUtils.java整個工具類的內容，可能代碼有點多，不過你仔細觀察一下他重載方法多了一點而已，Android很多源碼也這麼寫，最簡單的例子就是TextView的setText(CharSequence charSequence)和setText(int resId)，下面是調用的demo：

/**
     * 初始化或者重載數據
     **/
    private void loadData() {
        ActivityUtils.doAsync(mContext, R.string.nullvalue, R.string.loading, new Callable<ProjectModel>() {
            @Override
            public ProjectModel call() throws Exception {//這裏手動拋出異常
                ProjectModelBiz projectBiz = new ProjectModelBiz(ProjectDetailActivity.this);
                if (isLevelOne) {
                    return projectBiz.getProjectDetail(subjectID);
                } else {
                    return projectBiz.getSubProjectDetail(subjectID);
                }
            }
        }, new Callback<ProjectModel>() {
            @Override
            public void onCallback(ProjectModel model) {
                //通過這個返回值判斷成功還是失敗。
                mModel = model;
                if (model == null || StringHelper.isEmpty(model.getItem_flowto())) {
                    //失敗操作...
                } else {
                    //成功操作...
                }
            }
        }, new Callback<Exception>() {
            @Override
            public void onCallback(Exception pCallbackValue) {
                //拋出異常
                pCallbackValue.printStackTrace();
            }
        }, true);
    }

---

第一個參數要手動拋出異常

@Override
            public ProjectModel call() throws Exception {//這裏手動拋出異常
               //...
            }

因爲他原本的回調函數就是這樣的：

 */
public interface Callable<V> {
    /**
     * 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;
}