文章转载至CSDN社区罗升阳的安卓之旅，原文地址：

文章转载至CSDN社区罗升阳的安卓之旅，原文地址：http://blog.csdn.net/luoshengyang/article/details/6720261

前面我们在分析Activity启动过程的时候，看到同一个应用程序的Activity一般都是在同一个进程中启动，事实上，Activity也可 以像Service一样在新的进程中启动，这样，一个应用程序就可以跨越好几个进程了，本文就分析一下在新的进程中启动Activity的方法和过程。

在前面Android进程间通信（IPC）机制Binder简要介绍和学习计划一文中，我们提到，在Android系统中，每一个应用程序都是由一些Activity和Service组成的，一般Service运行在独立的进程中，而Activity有可能运行在同一个进程中，也有可能运行在不同的进程中。在前面Android系统在新进程中启动自定义服务过程（startService）的原理分析一文中，我们已经介绍了使用Activity.startService接口来在新进程中启动Service的过程，然后又在前面Android应用程序内部启动Activity过程（startActivity）的源代码分析一文中介绍了使用Activity.startActivity接口来在原来的进程中启动Activity的过程，现在，我们就来看一下同一个Android应用程序如何在新的进程中启动新的Activity。

老规矩，我们通过例子来介绍Android应用程序在新的进程中启动新的Activity的方法以及分析其过程。首先在Android源代码工程中创建 一个Android应用程序工程，名字就称为Process吧。关于如何获得Android源代码工程，请参考在Ubuntu上下载、编译和安装Android最新源代码一文；关于如何在Android源代码工程中创建应用程序工程，请参考在Ubuntu上为Android系统内置Java应用程序测试Application Frameworks层的硬件服务一文。这个应用程序工程定义了一个名为shy.luo.process的package，这个例子的源代码主要就是实现在这里了。下面，将会逐一介绍这个package里面的文件。

应用程序的默认Activity定义在src/shy/luo/process/MainActivity.java文件中：

[java] view plaincopy

  1. package shy.luo.process;
  2. import android.app.Activity;
  3. import android.content.Intent;
  4. import android.os.Bundle;
  5. import android.util.Log;
  6. import android.view.View;
  7. import android.view.View.OnClickListener;
  8. import android.widget.Button;
  9. public class MainActivity extends Activity  implements OnClickListener {
  10. private final static String LOG_TAG = "shy.luo.process.MainActivity";
  11. private Button startButton = null;
  12. @Override
  13. public void onCreate(Bundle savedInstanceState) {
  14. super.onCreate(savedInstanceState);
  15. setContentView(R.layout.main);
  16. startButton = (Button)findViewById(R.id.button_start);
  17. startButton.setOnClickListener(this);
  18. Log.i(LOG_TAG, "Main Activity Created.");
  19. }
  20. @Override
  21. public void onClick(View v) {
  22. if(v.equals(startButton)) {
  23. Intent intent = new Intent("shy.luo.process.subactivity");
  24. startActivity(intent);
  25. }
  26. }
  27. }

和前面文章的例子一样，它的实现很简单，当点击它上面的一个按钮的时候，就会启动另外一个名字为“shy.luo.process.subactivity”的Actvity。
        名字为“shy.luo.process.subactivity”的Actvity实现在src/shy/luo/process/SubActivity.java文件中：

[java] view plaincopy

  1. package shy.luo.process;
  2. import android.app.Activity;
  3. import android.os.Bundle;
  4. import android.util.Log;
  5. import android.view.View;
  6. import android.view.View.OnClickListener;
  7. import android.widget.Button;
  8. public class SubActivity extends Activity implements OnClickListener {
  9. private final static String LOG_TAG = "shy.luo.process.SubActivity";
  10. private Button finishButton = null;
  11. @Override
  12. public void onCreate(Bundle savedInstanceState) {
  13. super.onCreate(savedInstanceState);
  14. setContentView(R.layout.sub);
  15. finishButton = (Button)findViewById(R.id.button_finish);
  16. finishButton.setOnClickListener(this);
  17. Log.i(LOG_TAG, "Sub Activity Created.");
  18. }
  19. @Override
  20. public void onClick(View v) {
  21. if(v.equals(finishButton)) {
  22. finish();
  23. }
  24. }
  25. }

它的实现也很简单，当点击上面的一个铵钮的时候，就结束自己，回到前面一个Activity中去。
        再来重点看一下应用程序的配置文件AndroidManifest.xml：

[html] view plaincopy

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3. package="shy.luo.task"
  4. android:versionCode="1"
  5. android:versionName="1.0">
  6. <application android:icon="@drawable/icon" android:label="@string/app_name">
  7. <activity android:name=".MainActivity"
  8. android:label="@string/app_name">
  9. android:process=":shy.luo.process.main"
  10. <intent-filter>
  11. <action android:name="android.intent.action.MAIN" />
  12. <category android:name="android.intent.category.LAUNCHER" />
  13. </intent-filter>
  14. </activity>
  15. <activity android:name=".SubActivity"
  16. android:label="@string/sub_activity"
  17. android:process=":shy.luo.process.sub">
  18. <intent-filter>
  19. <action android:name="shy.luo.task.subactivity"/>
  20. <category android:name="android.intent.category.DEFAULT"/>
  21. </intent-filter>
  22. </activity>
  23. </application>
  24. </manifest>

为了使MainActivity和SubActivity在不同的进程中启动，我们分别配置了这两个Activity的android:process属性。在官方文档http://developer.android.com/guide/topics/manifest/activity-element.html中，是这样介绍Activity的android:process属性的：

The name of the process in which the activity should run.
Normally, all components of an application run in the default process
created for the application. It has the same name as the application
package. The<application> element‘s process
attribute can set a different default for all components. But each
component can override the default, allowing you to spread your
application across multiple processes.
        If the name assigned
to this attribute begins with a colon (‘:‘), a new process, private to
the application, is created when it‘s needed and the activity runs in
that process. If the process name begins with a lowercase character, the
activity will run in a global process of that name, provided that it
has permission to do so. This allows components in different
applications to share a process, reducing resource usage.
      
 大意为，一般情况下，同一个应用程序的Activity组件都是运行在同一个进程中，但是，如果Activity配置了android:process
这个属性，那么，它就会运行在自己的进程中。如果android:process属性的值以":"开头，则表示这个进程是私有的；如果
android:process属性的值以小写字母开头，则表示这是一个全局进程，允许其它应用程序组件也在这个进程中运行。

因此，这里我们以":"开头，表示创建的是私有的进程。事实上，这里我们不要前面的":"也是可以的，但是必须保证这个属性性字符串内至少有一个"."
字符，具体可以看一下解析AndroidManiefst.xml文件的源代码，在frameworks/base/core/java/android
/content/pm/PackageParser.java文件中：

[java] view plaincopy

  1. public class PackageParser {
  2. ......
  3. private boolean parseApplication(Package owner, Resources res,
  4. XmlPullParser parser, AttributeSet attrs, int flags, String[] outError)
  5. throws XmlPullParserException, IOException {
  6. final ApplicationInfo ai = owner.applicationInfo;
  7. final String pkgName = owner.applicationInfo.packageName;
  8. TypedArray sa = res.obtainAttributes(attrs,
  9. com.android.internal.R.styleable.AndroidManifestApplication);
  10. ......
  11. if (outError[0] == null) {
  12. CharSequence pname;
  13. if (owner.applicationInfo.targetSdkVersion >= Build.VERSION_CODES.FROYO) {
  14. pname = sa.getNonConfigurationString(
  15. com.android.internal.R.styleable.AndroidManifestApplication_process, 0);
  16. } else {
  17. // Some older apps have been seen to use a resource reference
  18. // here that on older builds was ignored (with a warning).  We
  19. // need to continue to do this for them so they don‘t break.
  20. pname = sa.getNonResourceString(
  21. com.android.internal.R.styleable.AndroidManifestApplication_process);
  22. }
  23. ai.processName = buildProcessName(ai.packageName, null, pname,
  24. flags, mSeparateProcesses, outError);
  25. ......
  26. }
  27. ......
  28. }
  29. private static String buildProcessName(String pkg, String defProc,
  30. CharSequence procSeq, int flags, String[] separateProcesses,
  31. String[] outError) {
  32. if ((flags&PARSE_IGNORE_PROCESSES) != 0 && !"system".equals(procSeq)) {
  33. return defProc != null ? defProc : pkg;
  34. }
  35. if (separateProcesses != null) {
  36. for (int i=separateProcesses.length-1; i>=0; i--) {
  37. String sp = separateProcesses[i];
  38. if (sp.equals(pkg) || sp.equals(defProc) || sp.equals(procSeq)) {
  39. return pkg;
  40. }
  41. }
  42. }
  43. if (procSeq == null || procSeq.length() <= 0) {
  44. return defProc;
  45. }
  46. return buildCompoundName(pkg, procSeq, "process", outError);
  47. }
  48. private static String buildCompoundName(String pkg,
  49. CharSequence procSeq, String type, String[] outError) {
  50. String proc = procSeq.toString();
  51. char c = proc.charAt(0);
  52. if (pkg != null && c == ‘:‘) {
  53. if (proc.length() < 2) {
  54. outError[0] = "Bad " + type + " name " + proc + " in package " + pkg
  55. + ": must be at least two characters";
  56. return null;
  57. }
  58. String subName = proc.substring(1);
  59. String nameError = validateName(subName, false);
  60. if (nameError != null) {
  61. outError[0] = "Invalid " + type + " name " + proc + " in package "
  62. + pkg + ": " + nameError;
  63. return null;
  64. }
  65. return (pkg + proc).intern();
  66. }
  67. String nameError = validateName(proc, true);
  68. if (nameError != null && !"system".equals(proc)) {
  69. outError[0] = "Invalid " + type + " name " + proc + " in package "
  70. + pkg + ": " + nameError;
  71. return null;
  72. }
  73. return proc.intern();
  74. }
  75. private static String validateName(String name, boolean requiresSeparator) {
  76. final int N = name.length();
  77. boolean hasSep = false;
  78. boolean front = true;
  79. for (int i=0; i<N; i++) {
  80. final char c = name.charAt(i);
  81. if ((c >= ‘a‘ && c <= ‘z‘) || (c >= ‘A‘ && c <= ‘Z‘)) {
  82. front = false;
  83. continue;
  84. }
  85. if (!front) {
  86. if ((c >= ‘0‘ && c <= ‘9‘) || c == ‘_‘) {
  87. continue;
  88. }
  89. }
  90. if (c == ‘.‘) {
  91. hasSep = true;
  92. front = true;
  93. continue;
  94. }
  95. return "bad character ‘" + c + "‘";
  96. }
  97. return hasSep || !requiresSeparator
  98. ? null : "must have at least one ‘.‘ separator";
  99. }
  100. ......
  101. }

从调用parseApplication函数解析application标签开始，通过调用buildProcessName函数对
android:process属性进解析，接着又会调用buildCompoundName进一步解析，这里传进来的参数pkg就
为"shy.luo.process"，参数procSeq为MainActivity的属性android:process的
值":shy.luo.process.main"，进一步将这个字符串保存在本地变量proc中。如果proc的第一个字符是":"，则只需要调用
validateName函数来验证proc字符串里面的字符都是合法组成就可以了，即以大小写字母或者"."开头，后面可以跟数字或者"_"字符；如果
proc的第一个字符不是":"，除了保证proc字符里面的字符都是合法组成外，还要求至少有一个"."字符。

MainActivity和SubActivity的android:process属性配置就介绍到这里了，其它更多的信息读者可以参考官方文档http://developer.android.com/guide/topics/manifest/activity-element.html或者源代码文件frameworks/base/core/java/android/content/pm/PackageParser.java。

再来看界面配置文件，它们定义在res/layout目录中，main.xml文件对应MainActivity的界面：

[html] view plaincopy

  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. <Button
  8. android:id="@+id/button_start"
  9. android:layout_width="wrap_content"
  10. android:layout_height="wrap_content"
  11. android:gravity="center"
  12. android:text="@string/start" >
  13. </Button>
  14. </LinearLayout>

而sub.xml对应SubActivity的界面：

[html] view plaincopy

  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. <Button
  8. android:id="@+id/button_finish"
  9. android:layout_width="wrap_content"
  10. android:layout_height="wrap_content"
  11. android:gravity="center"
  12. android:text="@string/finish" >
  13. </Button>
  14. </LinearLayout>

字符串文件位于res/values/strings.xml文件中：

[html] view plaincopy

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <resources>
  3. <string name="app_name">Process</string>
  4. <string name="sub_activity">Sub Activity</string>
  5. <string name="start">Start activity in new process</string>
  6. <string name="finish">Finish activity</string>
  7. </resources>

最后，我们还要在工程目录下放置一个编译脚本文件Android.mk：

[html] view plaincopy

  1. LOCAL_PATH:= $(call my-dir)
  2. include $(CLEAR_VARS)
  3. LOCAL_MODULE_TAGS := optional
  4. LOCAL_SRC_FILES := $(call all-subdir-java-files)
  5. LOCAL_PACKAGE_NAME := Process
  6. include $(BUILD_PACKAGE)

接下来就要编译了。有关如何单独编译Android源代码工程的模块，以及如何打包system.img，请参考如何单独编译Android源代码中的模块一文。
       执行以下命令进行编译和打包：

[html] view plaincopy

  1. [email protected]:~/Android$ mmm packages/experimental/Process
  2. [email protected]:~/Android$ make snod

这样，打包好的Android系统镜像文件system.img就包含我们前面创建的Process应用程序了。
       再接下来，就是运行模拟器来运行我们的例子了。关于如何在Android源代码工程中运行模拟器，请参考在Ubuntu上下载、编译和安装Android最新源代码一文。
       执行以下命令启动模拟器：

[html] view plaincopy

  1. [email protected]:~/Android$ emulator

模拟器启动起，就可以App Launcher中找到Process应用程序图标，接着把它启动起来：

点击中间的按钮，就会在新的进程中启动SubActivity：

现在，我们如何来确认SubActivity是不是在新的进程中启动呢？Android源代码工程为我们准备了adb工具，可以查看模拟器上系统运行的状况，执行下面的命令查看：

[html] view plaincopy

  1. [email protected]:~/Android$ adb shell dumpsys activity

这个命令输出的内容比较多，这里我们只关心系统中的任务和进程部分：

[html] view plaincopy

  1. ......
  2. Running activities (most recent first):
  3. TaskRecord{40770440 #3 A shy.luo.process}
  4. Run #2: HistoryRecord{406d4b20 shy.luo.process/.SubActivity}
  5. Run #1: HistoryRecord{40662bd8 shy.luo.process/.MainActivity}
  6. TaskRecord{40679eb8 #2 A com.android.launcher}
  7. Run #0: HistoryRecord{40677570 com.android.launcher/com.android.launcher2.Launcher}
  8. ......
  9. PID mappings:
  10. ......
  11. PID #416: ProcessRecord{4064b720 416:shy.luo.process:shy.luo.process.main/10037}
  12. PID #425: ProcessRecord{406ddc30 425:shy.luo.process:shy.luo.process.sub/10037}
  13. ......

这里我们看到，虽然MainActivity和SubActivity都是在同一个应用程序并且运行在同一个任务中，然而，它们却是运行在两个不同的进
程中，这就可以看到Android系统中任务这个概念的强大之处了，它使得我们在开发应用程序的时候，可以把相对独立的模块放在独立的进程中运行，以降低
模块之间的耦合性，同时，我们又不必去考虑一个应用程序在两个进程中运行的细节的问题，Android系统中的任务会为我们打点好一切。

在启动Activity的时候，系统是如何做到在新的进程中来启动这个Activity的呢？在前面两篇文章Android应用程序启动过程源代码分析和Android应用程序内部启动Activity过程（startActivity）的源代码分析中，
分别在Step 22和Step
21中分析了Activity在启动过程中与进程相关的函数ActivityStack.startSpecificActivityLocked函数
中，它定义在frameworks/base/services/java/com/android/server/am
/ActivityStack.java文件中：

[java] view plaincopy

  1. public class ActivityStack {
  2. ......
  3. private final void startSpecificActivityLocked(ActivityRecord r,
  4. boolean andResume, boolean checkConfig) {
  5. // Is this activity‘s application already running?
  6. ProcessRecord app = mService.getProcessRecordLocked(r.processName,
  7. r.info.applicationInfo.uid);
  8. ......
  9. if (app != null && app.thread != null) {
  10. try {
  11. realStartActivityLocked(r, app, andResume, checkConfig);
  12. return;
  13. } catch (RemoteException e) {
  14. ......
  15. }
  16. }
  17. mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
  18. "activity", r.intent.getComponent(), false);
  19. }
  20. ......
  21. }

从这个函数可以看出，决定一个Activity是在新的进程中启动还是在原有的进程中启动的因素有两个，一个是看这个Activity的process
属性的值，另一个是这个Activity所在的应用程序的uid。应用程序的UID是由系统分配的，而Activity的process属性值，如前所
述，是可以在AndroidManifest.xml文件中进行配置的，如果没有配置，它默认就为application标签的process属性值，如
果application标签的process属性值也没有配置，那么，它们就默认为应用程序的package名。这里就是根据processName和
uid在系统查找是否已有相应的进程存在，如果已经有了，就会调用realStartActivityLocked来直接启动Activity，否则的
话，就要通过调用ActivityManagerService.startProcessLocked函数来创建一个新的进程，然后在新进程中启动这个
Activity了。对于前者，可以参考Android应用程序内部启动Activity过程（startActivity）的源代码分析一文，而后者，可以参考Android应用程序启动过程源代码分析一文。

至此，Android应用程序在新的进程中启动新的Activity的方法和过程分析就结束了。在实际开发中，一个应用程序一般很少会在一个新的进程中
启动另外一个Activity，如果真的需要这样做，还要考虑如何与应用程序中其它进程的Activity进行通信，这时候不妨考虑使用Binder进程间通信机制。写这篇文章的目的，更多是让我们去了解Android应用程序的架构，这种架构可以使得应用程序组件以松耦合的方式组合在一起，便于后续的扩展和维护，这是非常值得我们学习的。

老罗的新浪微博：http://weibo.com/shengyangluo，欢迎关注！

时间： 2024-10-12 23:32:25

文章转载至CSDN社区罗升阳的安卓之旅，原文地址：的相关文章

【转载】10年的程序员生涯（附带原文地址）

内容是转载自别人的博客,而且被这么多人转了的文章,竟然都没有附上原文地址,真是心寒.在cnds被转了不下几十篇竟然都没有原文地址,在里面搜索也没有搜索到,然后到百度搜索也毫无头绪,然后在必应上面按照时间来找,最终发现这篇文章最早出现的地方,我想这应该是原文的出处了吧!我把地址贴出来以此来感谢博主的好文! http://www.cnblogs.com/jirigala/archive/2009/08/03/1537874.html 展望未来,总结过去10年的程序员生涯,给程序员小弟弟小妹妹们的一些

关注CSDN社区微信，更多精彩等你来

CSDN社区微信公众号"程序人生"(微信ID)来了,每天我们会将CSDN社区中大量的优质内容浓缩成1~3篇文章,推送到您的手机中,让您无论何时何地都能感受到知识的精彩.技术的力量. 扫描二维码关注: 关注后的精彩: CSDN博客平台中最优质的博文(也许就有您的文章) CSDN论坛平台中最火热的讨论(精彩不容错过) CSDN下载平台中最实用的开发资源(让开发事半功倍) CSDN社区最新的有奖活动(奖品拿到手软) 最大机会免费获得CSDN的各种福利(技术大会门票.<程序员>杂志

[转载]关于CSDN, cnblog, iteye和51cto四个博客网站的比较与分析

CSDN:http://blog.csdn.net/ cnblog: http://www.cnblogs.com/ iteye: http://www.iteye.com/blogs/ 51cto: http://blog.51cto.com/ 1. 基本功能 博客(又名网络日志),顾名思义,最早的基本功能就是支持用户在网站上写日志,并进行修改.删除.分类管理,以及对他人博客的阅读和评论等.以上功能所有的博客网站都必须具备,为了更好地完成以上功能,这里对更细致的条目进行了比较:   csdn

小道消息：CSDN社区产品重大更新

Hi,小伙伴们: 悄悄给大家透露个消息:CSDN社区将要有重大更新. 都有哪些呢?分别是:新极客头条.Ink.博乐 是不是后面两个比较眼生?不要着急,那可是我们的重中之重,我来给大家一一道来-- 先来说说我们已经上线的:新极客头条 过去,只有少数"主编"能直接在"极客头条"发表内容.但是,好线索可能来自任何人.现在,是否能直接发表,将由所有成员共同决定--只要达到一定"贡献值",每个人都能行使主编的权利. 在新极客头条,阅读和讨论更有效率.你可以

[活动已结束]《深入理解Android：Wi-Fi、NFC和GPS卷》CSDN社区活动

今天有一个CSDN社区活动,解答关于Android系统的学习.认识.开发等方面的问题,并就<深入理解Android:Wi-Fi.NFC和GPS卷>一书为大家答疑解惑,了解Android Framework的实现原理.活动链接:http://bbs.csdn.net/topics/390765275?page=1#post-397228045 此次活动已经完结,谢谢各位的支持.获奖的三位兄弟是: 以下欢迎大家踊跃提问,在本帖回复就可以,參与活动并提出问题就可以获得100可用分.在大家的积极參与下

Java版本发展历史(转载自CSDN)

几年前,Java将死的话题被传得沸沸扬扬,特别是在甲骨文公司收购SUN公司后,几乎全世界的Java程序员都皱起了眉头.但随着Google Android平台的崛起以及大数据时代的来临,Java似乎又重新焕发了光芒. 2014年1月份,CSDN携手<程序员>杂志发起了"2013年中国软件开发者薪资大调查"在线调查活动,通过调查发现,使用Java的开发者高达45.39%,位居第一.而使用C#和C++的开发者仅为17.63%和13.37%. Java语言的开发性.兼容性和扩展性使

dedecms5.7文章页的标签随机插入到内容中并且标签的地址为其标签关联的其他文章地址

dedecms5.7文章页的标签随机插入到内容中并且标签的地址为其他标签关联的文章地址 1 添加2个自定义函数 在dede/include/extend.func.php底部 添加如下代码 //根据文章ID 获取文章的标签 然后根据标签随机获取不是本地址的文章地址 function gettaglink($aid) { global $lit_imglist,$dsql; //思路整理 先根据文章ID 找标签ID 然后根据标签ID 找到不包括自己的文章ID 然后随机获取一个文章ID $dsql-

[转载自CSDN] 帧锁定同步算法

原贴地址 http://blog.csdn.net/skywind/article/details/6179506,原作者 skywind,首先向原作者表示感谢,非常好的一篇文章. --------------------------------- 网络游戏同步算法,大量应用于RTS游戏,Xbox360 Arcade游戏,模拟器对战平台. http://blog.csdn.net/skywind 算法概念 该算法普遍要求网速RTT要在100ms以内,一般人数不超过8人,在这样的情况下,可以像单机

[转载][来自csdn]RTS和CTS是什么意思?

原文链接: http://blog.csdn.net/zmq5411/article/details/6280332 这篇文章看着挺好,明白易懂,顺手转过来 34RTS和CTS是什么意思? 解释一:RTS:终端我准备发数据给你,快用CTS应答,准备好没? CTS:好了,来吧 解释二:CTS:主机,我有数据,请求接收 RTS:我是主机,就绪,请求发送. SIMCOM公司的解释,RTS和CTS似乎是独立的RTS是模块的输入端,用于MCU通知模块,MCU是否准备好,模块是否可向MCU发送信息,RTS的