对AsyncTask进行封装，简化繁琐的异步操作

对于android的异步操作，往往有二种方法给予我们选择。

     一：Thread+Handler

     二:  AsyncTask

     对于二者的相同与异同点，这里并不去进行比较。这里提供一种简化异步操作的方法，供大家参考学习。   

     代码参考自AndEngine，不过我对它做了一定的修改，让它更适合自己目前项目的开发，感谢open source 能够让我们去学习和阅读那么多优秀的代码。

     废话不多说，代码如下：

     CallEarliest<T>:

Java代码  

1. /** 
2.  *  
3.  * 回调接口,回调方法运行于主线程 
4.  * @ClassName: CallEarliest    
5.  * @author 姜涛 
6.  * @version 1.0 2012-1-16 下午11:23:41    
7.  * @param <T> 
8.  */  
9. public interface CallEarliest<T> {  
10.       
11.     public void onCallEarliest() throws Exception;  
12. }  

 

    Callable<T>:

    /**

Java代码  

1.  * 回调接口,回调方法运行于异步线程  
2.  * @ClassName: Callable     
3.  * @author 姜涛  
4.  * @version 1.0 2012-1-16 下午5:56:42     
5.  * @param <T>  
6.  */  
7. public interface Callable<T> {  
8.       
9.     public T call() throws Exception;  
10. }  

   Callback<T>:

   /**

Java代码  

1.  * 回调接口,回调方法运行于主线程  
2.  * @ClassName: Callback     
3.  * @author 姜涛  
4.  * @version 1.0 2012-1-16 下午5:58:16     
5.  * @param <T>  
6.  */  
7. public interface Callback<T> {  
8.       
9.     public void onCallback(final T pCallbackValue);  
10. }  

   IProgressListener:

   /**

Java代码  

1. * 观察者  
2. * @ClassName: IProgressListener     
3. * @author 姜涛  
4. * @version 1.0 2012-1-16 下午11:08:40  
5. */  
6. ublic interface IProgressListener {  
7.   
8. /** 
9.  * 进度发生改变的时候调用 
10.  * @param pProgress 
11.  */  
12. public void onProgressChanged(final int pProgress);  

 

    ProgressCallable<T>:

Java代码  

1. /** 
2.  * 被观察者 
3.  * @ClassName: ProgressCallable 
4.  * @author 姜涛 
5.  * @version 1.0 2012-1-16 下午11:08:52 
6.  * @param <T> 
7.  */  
8. public interface ProgressCallable<T> {  
9.   
10.     /** 
11.      * 注册观察者对象 
12.      * @param pProgressListener 
13.      * @return 
14.      * @throws Exception 
15.      */  
16.     public T call(final IProgressListener pProgressListener) throws Exception;  
17. }  

    AsyncTaskUtils:

Java代码  

1. /** 
2.  * 异步操作工具类 
3.  * @ClassName: ActivityUtils 
4.  * @author 姜涛 
5.  * @version 1.0 2012-1-16 下午11:02:26 
6.  */  
7. public class AsyncTaskUtils {  
8.   
9.     /** 
10.      * 封装的asynctask方法，此方法没有进度框. 
11.      *  
12.      * @param pCallEarliest 
13.      *            运行于主线程，最先执行此方法. 
14.      * @param mCallable 
15.      *            运行于异步线程,第二执行此方法. 
16.      * @param mCallback 
17.      *            运行于主线程,最后执行此方法. 
18.      */  
19.     public static <T> void doAsync(final CallEarliest<T> pCallEarliest,  
20.             final Callable<T> pCallable, final Callback<T> pCallback) {  
21.   
22.         new AsyncTask<Void, Void, T>() {  
23.   
24.             /** 
25.              * 首先运行此方法,运行于主线程 
26.              */  
27.             @Override  
28.             protected void onPreExecute() {  
29.                 super.onPreExecute();  
30.                 try {  
31.                     pCallEarliest.onCallEarliest();  
32.                 } catch (Exception e) {  
33.                     Log.e("error", e.toString());  
34.                 }  
35.             }  
36.   
37.             /** 
38.              * 第二步执行这个方法，这个方法运行在异步线程中 
39.              */  
40.             @Override  
41.             protected T doInBackground(Void... params) {  
42.   
43.                 try {  
44.                     return pCallable.call();  
45.                 } catch (Exception e) {  
46.                     Log.e("error", e.toString());  
47.                 }  
48.                 return null;  
49.             }  
50.   
51.             /** 
52.              * 第三步执行这个方法，运行于主线程 
53.              */  
54.             protected void onPostExecute(T result) {  
55.                 pCallback.onCallback(result);  
56.             }  
57.         }.execute((Void[]) null);  
58.     }  
59.   
60.     /** 
61.      * 封装的asynctask方法，此方法拥有进度对话框，并支持定义样式. 
62.      *  
63.      * @param pContext 
64.      *            上下文 
65.      * @param styleID 
66.      *            对话框样式 
67.      *            ProgressDialog.STYLE_HORIZONTAL|ProgressDialog.STYLE_SPINNER 
68.      * @param pTitle 
69.      *            标题 
70.      * @param pMessage 
71.      *            内容 
72.      * @param pCallEarliest 
73.      *            运行于主线程，最先执行此方法. 
74.      * @param progressCallable 
75.      *            运行于异步线程,用于传递对话框进度. 
76.      * @param pCallback 
77.      *            运行于主线程,最后执行此方法. 
78.      */  
79.     public static <T> void doProgressAsync(final Context pContext,  
80.             final int styleID, final String pTitle, final String pMessage,  
81.             final CallEarliest<T> pCallEarliest,  
82.             final ProgressCallable<T> progressCallable,  
83.             final Callback<T> pCallback) {  
84.   
85.         new AsyncTask<Void, Void, T>() {  
86.   
87.             private ProgressDialog mProgressDialog;  
88.   
89.             /** 
90.              * 首先运行此方法,运行于主线程 
91.              */  
92.             @Override  
93.             protected void onPreExecute() {  
94.                 super.onPreExecute();  
95.   
96.                 mProgressDialog = new ProgressDialog(pContext);  
97.                 mProgressDialog.setProgressStyle(styleID);  
98.                 mProgressDialog.setTitle(pTitle);  
99.                 mProgressDialog.setMessage(pMessage);  
100.                 mProgressDialog.setIndeterminate(false);  
101.                 mProgressDialog.show();  
102.                 try {  
103.                     pCallEarliest.onCallEarliest();  
104.                 } catch (Exception e) {  
105.                     Log.e("error", e.toString());  
106.                 }  
107.             }  
108.   
109.             /** 
110.              * 第二步执行这个方法，这个方法运行在异步线程中 
111.              */  
112.             @Override  
113.             protected T doInBackground(Void... params) {  
114.                 try {  
115.                     return progressCallable.call(new IProgressListener() {  
116.   
117.                         @Override  
118.                         public void onProgressChanged(int pProgress) {  
119.                             // TODO Auto-generated method stub  
120.                             onProgressUpdate(pProgress);  
121.                         }  
122.                     });  
123.                 } catch (Exception e) {  
124.                     Log.e("error", e.toString());  
125.                 }  
126.   
127.                 return null;  
128.             }  
129.   
130.             /** 
131.              * 更新进度框 
132.              */  
133.             protected void onProgressUpdate(final Integer... values) {  
134.                 mProgressDialog.setProgress(values[0]);  
135.             };  
136.   
137.             /** 
138.              * 第三步执行这个方法，运行于主线程 
139.              */  
140.             protected void onPostExecute(T result) {  
141.                 if (mProgressDialog != null)  
142.                     mProgressDialog.dismiss();  
143.                 pCallback.onCallback(result);  
144.   
145.             }  
146.   
147.         }.execute((Void[]) null);  
148.   
149.     }  
150.   
151.     /** 
152.      * 封装的asynctask方法，此方法拥有进度对话框，并支持定义样式. 
153.      *  
154.      * @param pContext 
155.      *            上下文 
156.      * @param styleID 
157.      *            对话框样式 
158.      *            ProgressDialog.STYLE_HORIZONTAL|ProgressDialog.STYLE_SPINNER 
159.      * @param pTitle 
160.      *            标题,资源id 
161.      * @param pMessage 
162.      *            内容,资源id 
163.      * @param pCallEarliest 
164.      *            运行于主线程，最先执行此方法. 
165.      * @param progressCallable 
166.      *            运行于异步线程,用于传递对话框进度. 
167.      * @param pCallback 
168.      *            运行于主线程,最后执行此方法. 
169.      */  
170.     public static <T> void doProgressAsync(final Context pContext,  
171.             final int styleID, final int pTitleResId, final int pMessageResId,  
172.             final CallEarliest<T> pCallEarliest,  
173.             final ProgressCallable<T> progressCallable,  
174.             final Callback<T> pCallback) {  
175.         AsyncTaskUtils.doProgressAsync(pContext, styleID,  
176.                 pContext.getString(pTitleResId),  
177.                 pContext.getString(pMessageResId), pCallEarliest,  
178.                 progressCallable, pCallback);  
179.     }  
180.   
181. }  

     BaseActivity:

Java代码  

1. /** 
2.  * 公用Activity,用于存放与业务无关的公用方法 
3.  *  
4.  * @ClassName: BaseActivity 
5.  * @author 姜涛 
6.  * @version 1.0 2011-12-11 下午7:03:18 
7.  */  
8. public abstract class BaseActivity extends Activity {  
9.   
10.     /** 
11.      * 封装的asynctask方法，此方法没有进度框. 
12.      *  
13.      * @param pCallEarliest 运行于主线程，最先执行此方法. 
14.      * @param mCallable 运行于异步线程,第二执行此方法. 
15.      * @param mCallback 运行于主线程,最后执行此方法. 
16.      */  
17.     public <T> void doAsync(final CallEarliest<T> pCallEarliest,  
18.             final Callable<T> mCallable, final Callback<T> mCallback) {  
19.         AsyncTaskUtils.doAsync(pCallEarliest, mCallable, mCallback);  
20.     }  
21.   
22.     /** 
23.      * 封装的asynctask方法，此方法拥有进度对话框，并支持定义样式. 
24.      * @param pContext  上下文 
25.      * @param styleID   对话框样式 ProgressDialog.STYLE_HORIZONTAL|ProgressDialog.STYLE_SPINNER 
26.      * @param pTitle    标题 
27.      * @param pMessage  内容 
28.      * @param pCallEarliest  运行于主线程，最先执行此方法. 
29.      * @param progressCallable 运行于异步线程,用于传递对话框进度. 
30.      * @param pCallback  运行于主线程,最后执行此方法. 
31.      */  
32.     public <T> void doProgressAsync(final Context pContext, final int styleID,  
33.             final String pTitleResID, final String pMessageResID,  
34.             final CallEarliest<T> pCallEarliest, final ProgressCallable<T> pCallable,  
35.             final Callback<T> pCallback) {  
36.   
37.         AsyncTaskUtils.doProgressAsync(pContext, styleID, pTitleResID,  
38.                 pMessageResID, pCallEarliest, pCallable, pCallback);  
39.     }  
40.       
41.       
42.     /** 
43.      * 封装的asynctask方法，此方法拥有进度对话框，并支持定义样式. 
44.      * @param pContext  上下文 
45.      * @param styleID   对话框样式 ProgressDialog.STYLE_HORIZONTAL|ProgressDialog.STYLE_SPINNER 
46.      * @param pTitle    标题,资源id 
47.      * @param pMessage  内容,资源id 
48.      * @param pCallEarliest  运行于主线程，最先执行此方法. 
49.      * @param progressCallable 运行于异步线程,用于传递对话框进度. 
50.      * @param pCallback  运行于主线程,最后执行此方法. 
51.      */  
52.     public <T> void doProgressAsync(final Context pContext, final int styleID,  
53.             final int pTitleResID, final int pMessageResID,  
54.             final CallEarliest<T> pCallEarliest, final ProgressCallable<T> pCallable,  
55.             final Callback<T> pCallback) {  
56.   
57.         AsyncTaskUtils.doProgressAsync(pContext, styleID, pTitleResID,  
58.                 pMessageResID, pCallEarliest, pCallable, pCallback);  
59.     }  
60.   
61.       
62. }  

 

    SimpleAsyncTaskActivity:

Java代码  

1. public class SimpleAsyncTaskActivity extends BaseActivity {  
2.     /** Called when the activity is first created. */  
3.     @Override  
4.     public void onCreate(Bundle savedInstanceState) {  
5.         super.onCreate(savedInstanceState);  
6.   
7.         this.doProgressAsync(this, ProgressDialog.STYLE_HORIZONTAL,  
8.                 R.string.app_name, R.string.app_name, new CallEarliest<Void>() {  
9.   
10.                     @Override  
11.                     public void onCallEarliest() throws Exception {  
12.                         // TODO Auto-generated method stub  
13.   
14.                     }  
15.   
16.                 }, new ProgressCallable<Void>() {  
17.   
18.                     @Override  
19.                     public Void call(IProgressListener pProgressListener)  
20.                             throws Exception {  
21.                         // TODO Auto-generated method stub  
22.                         for (int i = 0; i < 100; i++) {  
23.                             Thread.sleep(200);  
24.                             pProgressListener.onProgressChanged(i);  
25.                         }  
26.                         return null;  
27.                     }  
28.   
29.                 }, new Callback<Void>() {  
30.   
31.                     @Override  
32.                     public void onCallback(Void pCallbackValue) {  
33.                         // TODO Auto-generated method stub  
34.   
35.                     }  
36.                 });  
37.     }  
38. }  

    效果图:

   示例可参见附件.

• SimpleAsyncTask.zip (58.5 KB)