接下来我们再看看应用程序的配置文件AndroidManifest.xml:
  1. <?xml version="1.0" encoding="utf-8"?>   
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"   
  3.       package="shy.luo.counter"   
  4.       android:versionCode="1"   
  5.       android:versionName="1.0">   
  6.     <application android:icon="@drawable/icon" android:label="@string/app_name">   
  7.         <activity android:name=".Counter"   
  8.                   android:label="@string/app_name">   
  9.             <intent-filter>   
  10.                 <action android:name="android.intent.action.MAIN" />   
  11.                 <category android:name="android.intent.category.LAUNCHER" />   
  12.             </intent-filter>   
  13.         </activity>   
  14.     </application>   
  15. </manifest>   
这个配置文件很简单,我们就不介绍了。
 
再来看应用程序的界面文件,它定义在res/layout/main.xml文件中:
  1. <?xml version="1.0" encoding="utf-8"?>     
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"     
  3.     android:orientation="vertical"     
  4.     android:layout_width="fill_parent"     
  5.     android:layout_height="fill_parent"      
  6.     android:gravity="center">     
  7.     <LinearLayout     
  8.         android:layout_width="fill_parent"     
  9.         android:layout_height="wrap_content"     
  10.         android:layout_marginBottom="10px"     
  11.         android:orientation="horizontal"      
  12.         android:gravity="center">     
  13.         <TextView       
  14.         android:layout_width="wrap_content"      
  15.             android:layout_height="wrap_content"      
  16.             android:layout_marginRight="4px"     
  17.             android:gravity="center"     
  18.             android:text="@string/counter">     
  19.         </TextView>     
  20.         <TextView       
  21.             android:id="@+id/textview_counter"     
  22.         android:layout_width="wrap_content"      
  23.             android:layout_height="wrap_content"      
  24.             android:gravity="center"     
  25.             android:text="0">     
  26.         </TextView>     
  27.     </LinearLayout>     
  28.     <LinearLayout     
  29.         android:layout_width="fill_parent"     
  30.         android:layout_height="wrap_content"     
  31.         android:orientation="horizontal"      
  32.         android:gravity="center">     
  33.         <Button      
  34.             android:id="@+id/button_start"     
  35.             android:layout_width="wrap_content"     
  36.             android:layout_height="wrap_content"     
  37.             android:gravity="center"     
  38.             android:text="@string/start">     
  39.         </Button>     
  40.         <Button      
  41.             android:id="@+id/button_stop"     
  42.             android:layout_width="wrap_content"     
  43.             android:layout_height="wrap_content"     
  44.             android:gravity="center"     
  45.             android:text="@string/stop" >     
  46.         </Button>     
  47.      </LinearLayout>       
  48. </LinearLayout>    
这个界面配置文件也很简单,等一下我们在模拟器把这个应用程序启动起来后,就可以看到它的截图了。应用程序用到的字符串资源文件位于res/values/strings.xml文件中:
  1. <?xml version="1.0" encoding="utf-8"?>     
  2. <resources>     
  3.     <string name="app_name">Counter</string>     
  4.     <string name="counter">Counter: </string>     
  5.     <string name="start">Start Counter</string>     
  6.     <string name="stop">Stop Counter</string>     
  7. </resources>    
最后,我们还要在工程目录下放置一个编译脚本文件Android.mk:
  1. LOCAL_PATH:= $(call my-dir)           
  2. include $(CLEAR_VARS)           
  3.            
  4. LOCAL_MODULE_TAGS :optional           
  5.            
  6. LOCAL_SRC_FILES := $(call all-subdir-java-files)           
  7.            
  8. LOCAL_PACKAGE_NAME :Counter           
  9.            
  10. include $(BUILD_PACKAGE)     
接下来就要编译了。有关如何单独编译Android源代码工程的模块,以及如何打包system.img,请参考如何单独编译Android源代码中的模块一文。
执行以下命令进行编译和打包:
  1. USER-NAME@MACHINE-NAME:~/Android$ mmm packages/experimental/Counter             
  2. USER-NAME@MACHINE-NAME:~/Android$ make snod   
这样,打包好的Android系统镜像文件system.img就包含我们前面创建的Counter应用程序了。
       再接下来,就是运行模拟器来运行我们的例子了。关于如何在Android源代码工程中运行模拟器,请参考
在Ubuntu上下载、编译和安装Android最新源代码一文。
       执行以下命令启动模拟器:
  1. USER-NAME@MACHINE-NAME:~/Android$ emulator    
 最后我们就可以在Launcher中找到Counter应用程序图标,把它启动起来,点击Start按钮,就会看到应用程序界面上的计数器跑起来了:
 这样,使用AsyncTask的例子就介绍完了,下面,我们就要根据上面对AsyncTask的使用情况来重点分析它的实现了。
AsyncTask类定义在frameworks/base/core/java/android/os/AsyncTask.java文件中:
  1. public abstract class AsyncTask<Params, Progress, Result> {   
  2.     ......   
  3.    
  4.     private static final BlockingQueue<Runnable> sWorkQueue =   
  5.             new LinkedBlockingQueue<Runnable>(10);   
  6.    
  7.     private static final ThreadFactory sThreadFactory = new ThreadFactory() {   
  8.         private final AtomicInteger mCount = new AtomicInteger(1);   
  9.    
  10.         public Thread newThread(Runnable r) {   
  11.             return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());   
  12.         }   
  13.     };   
  14.    
  15.     ......   
  16.    
  17.     private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,   
  18.         MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory);   
  19.    
  20.     private static final int MESSAGE_POST_RESULT = 0x1;   
  21.     private static final int MESSAGE_POST_PROGRESS = 0x2;   
  22.     private static final int MESSAGE_POST_CANCEL = 0x3;   
  23.    
  24.     private static final InternalHandler sHandler = new InternalHandler();   
  25.    
  26.     private final WorkerRunnable<Params, Result> mWorker;   
  27.     private final FutureTask<Result> mFuture;   
  28.    
  29.     ......   
  30.    
  31.     public AsyncTask() {   
  32.         mWorker = new WorkerRunnable<Params, Result>() {   
  33.             public Result call() throws Exception {   
  34.                 ......   
  35.                 return doInBackground(mParams);   
  36.             }   
  37.         };   
  38.    
  39.         mFuture = new FutureTask<Result>(mWorker) {   
  40.             @Override   
  41.             protected void done() {   
  42.                 Message message;   
  43.                 Result result = null;   
  44.    
  45.                 try {   
  46.                     result = get();   
  47.                 } catch (InterruptedException e) {   
  48.                     android.util.Log.w(LOG_TAG, e);   
  49.                 } catch (ExecutionException e) {   
  50.                     throw new RuntimeException("An error occured while executing doInBackground()",   
  51.                         e.getCause());   
  52.                 } catch (CancellationException e) {   
  53.                     message = sHandler.obtainMessage(MESSAGE_POST_CANCEL,   
  54.                         new AsyncTaskResult<Result>(AsyncTask.this, (Result[]) null));   
  55.                     message.sendToTarget();   
  56.                     return;   
  57.                 } catch (Throwable t) {   
  58.                     throw new RuntimeException("An error occured while executing "   
  59.                         + "doInBackground()", t);   
  60.                 }   
  61.    
  62.                 message = sHandler.obtainMessage(MESSAGE_POST_RESULT,   
  63.                     new AsyncTaskResult<Result>(AsyncTask.this, result));   
  64.                 message.sendToTarget();   
  65.             }   
  66.         };   
  67.     }   
  68.    
  69.     ......   
  70.    
  71.     public final Result get() throws InterruptedException, ExecutionException {   
  72.         return mFuture.get();   
  73.     }   
  74.    
  75.     ......   
  76.    
  77.     public final AsyncTask<Params, Progress, Result> execute(Params... params) {   
  78.         ......   
  79.    
  80.         mWorker.mParams = params;   
  81.         sExecutor.execute(mFuture);   
  82.    
  83.         return this;   
  84.     }   
  85.    
  86.     ......   
  87.    
  88.     protected final void publishProgress(Progress... values) {   
  89.         sHandler.obtainMessage(MESSAGE_POST_PROGRESS,   
  90.             new AsyncTaskResult<Progress>(this, values)).sendToTarget();   
  91.     }   
  92.    
  93.         private void finish(Result result) {   
  94.                 ......   
  95.                 onPostExecute(result);   
  96.                 ......   
  97.         }   
  98.    
  99.     ......   
  100.    
  101.     private static class InternalHandler extends Handler {   
  102.         @SuppressWarnings({"unchecked""RawUseOfParameterizedType"})   
  103.         @Override   
  104.         public void handleMessage(Message msg) {   
  105.             AsyncTaskResult result = (AsyncTaskResult) msg.obj;   
  106.             switch (msg.what) {   
  107.                 case MESSAGE_POST_RESULT:   
  108.                  // There is only one result   
  109.                  result.mTask.finish(result.mData[0]);   
  110.                  break;   
  111.                 case MESSAGE_POST_PROGRESS:   
  112.                  result.mTask.onProgressUpdate(result.mData);   
  113.                  break;   
  114.                 case MESSAGE_POST_CANCEL:   
  115.                  result.mTask.onCancelled();   
  116.                  break;   
  117.             }   
  118.         }   
  119.     }   
  120.    
  121.     private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {   
  122.         Params[] mParams;   
  123.     }   
  124.    
  125.     private static class AsyncTaskResult<Data> {   
  126.         final AsyncTask mTask;   
  127.         final Data[] mData;   
  128.    
  129.         AsyncTaskResult(AsyncTask task, Data... data) {   
  130.             mTask = task;   
  131.             mData = data;   
  132.         }   
  133.     }   
  134. }