Android应用程序线程消息循环模型分析（4）

2017-11-06 564 收藏

接下来我们再看看应用程序的配置文件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. }   

 

本文转自 Luoshengyang 51CTO博客，原文链接：http://blog.51cto.com/shyluo/966885，如需转载请自行联系原作者

上一篇 下一篇

微信关注我们

原文链接：https://yq.aliyun.com/articles/407187

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Android系统匿名共享内存（Anonymous Shared Memory）C++调用接口分析（2）

回到前面MemoryHeapBase类的构造函数中，将匿名共享内存映射到本进程的地址空间去后，还看继续设置这块匿名共享内存的读写属性： if(fd>=0){ if(mapfd(fd,size)==NO_ERROR){ if(flags&READ_ONLY){ ashmem_set_prot_region(fd,PROT_READ); } } } 上面调用mapfd函数来映射匿名共享内存时，指定这块内存是可读写的，但是如果传进来的参数flags设置了只读属性，那么还需要调用系统运行时库存层的ashmem_set_prot_region函数来设置这块匿名共享内存为只读，这个函数定义在system/core/libcutils/ashmem-dev.c文件，有兴趣的读者可以自己去研究一下。 这样，通过这个构造函数，一块匿名共享内存就建立好了，其余的三个成员函数getHeapID、getBase和getSize就简单了： intMemoryHeapBase::getHeapID()const{ returnmFD; } void*MemoryHeapBase::g...

2017-11-07

540

上一篇

关于Android导入开源项目：Error:Unable to load class

'org.gradle.api.publication.maven.internal.DefaultMavenFa 在导入开源项目时，有可能会要求需要maven插件，并报出一下错误： 对于没有安装maven插件的开发者来说，要去下载一个maven插件也许不困难，但是，有时候可能会像我一样懒，不去下载插件，那么我们可以试着这样做： 我在网上找了一些资料看一看，发现很多都是说把相关maven插件的classpath删除就OK了，其实不然。我的做法是： 1、删除关module下的build.gradle文件下的：apply plugin: 'com.github.dcendents.Android-maven'； 这时候会报下面这个错误： 2、找到相关module下的build.gradle文件，删除其中的install函数； 试一下吧。 本文转自 一点点征服 博客园博客，原文链接： http://www.cnblogs.com/ldq2016/p/7239867.html ，如需转载请自行联系原作者

2017-11-07

621

下一篇

相关文章

发表评论

发表

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

时间: 2025-12-03 大小: 4.36MB 下载: 23次

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

时间: 2025-12-17 大小: 5MB 下载: 1次

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

时间: 2025-12-17 大小: 1.42GB 下载: 1次

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2025-12-03 大小: 9.84MB 下载: 39次