Android 应用点击图标到Activity界面显示的过程分析
分析这个过程不是单纯为走一遍函数调用的流程，而是更好的理解平常用到的一些方法、
对象的初始化时间，对象创建的个数，方法的先后顺序，以及每个类，
方法背后的作用和目的。主要是一下几个问题：
- Application是什么时候创建的，每个应用程序有几个Application
- 应用的资源路径什么时候初始化的
- 应用中ContextImpl的个数
- Application.attach(),Activity.attach()的调用时机及作用
- Instrumentation的重要性及具体作用
- 点击Launcher启动Activity和应用内部启动Activity的区别
1. 应用的安装过程
应用安装的时候,通过PMS解析apk的AndroidManifest.xml文件,
提取出这个apk的信息写入到packages.xml文件中，
这些信息包括：权限、应用包名、icon、APK的安装位置、版本、userID等等。
packages.xml文件位于系统目录下/data/system/packages.xml。
2. 系统启动开启的服务
系统的会在启动时也可以认为开机时启动常用的服务,
如ActivityManagerService(AMS),
PackageManagerService(PMS),
WindowManagerService(WMS),
以及ServiceManager(SM),
用于管理各种服务,详细的管理方式见理解Binder框架。
同时桌面Launcher会为安装过的应用生成不同的应用入口,对应桌面上的应用图标，
下面分析点击应用图标的到应用启动的过程。
这里主要是应用端的过程,服务端也就是AMS少量涉及,
同时以大体框架为主,不深入代码细节。主要分为Launcher进程，AMS进程，应用程序进程。
- Instrumentation： 用于管理应用程序和系统（主要与应用程序内的Activity）的交互过程，Instrumentation将在任何应用程序运行前初始化，每个进程只会存在一个Instrumentation对象，且每个Activity都有此对象的引用，可以通过它监测系统与应用程序之间的所有交互，主要是内部交互。
- **ActivityThread: **App的真正入口,通过调用main()App开始真正运行，同时开启消息循环队列，虽然不是一个真正的线程,但一般所在的线程被称为UI线程或主线程。ActivityThread就是专门与AMS的进行外部交互。
- ApplicationThread: 应用需要和远程服务AMS等通信,而Binder只能单项通信,而AMS等服务想控制应用需要应用程序提供一个Binder接口,ApplicationThread就是这个Binder接口,用于通过远程服务调用本地的方法。
- ActivityManagerProxy: AMS远程服务在本地的代理。
- ApplicationThreadProxy: ApplicationThread在远程服务AMS的代理。
其实Launcher本身也是一个Activity，我们不考虑Launcher的创建过程，只分析用户的应用程序的从点击到Activity启动的过程。上面的这些每个进程只存在一个，如果应用存在多个进程，就会有多个实例。
Launcher所在进程，Launcher通过Binder与ActivityManagerService与通信。
Launcher.startActivitySafely
|
Launcher.startActivity
|
Activity.startActivity
|
Activity.startActivityForResult
|
Instrumentation.execStartActivity
|
ActivityManagerNative.getDefault().startActivity
|
ActivityManagerProxy.startActivity
上面的这些都是在一条调用链上，ActivityManagerProxy是AMS的本地代理，实际的工作是在远程AMS完成的，下面是AMS进程。
借助binder驱动
ActivityManagerService.startActivity-> (AMS)
...
//一系类AMS的调用链和一些与Launcher通过Binder的互相调用过程，此时仍然未创建应用程序的进程。
...
* AMS创建一个新的进程，用来启动一个ActivityThread实例，
* 即将要启动的Activity就是在这个ActivityThread实例中运行
Process.start("android.app.ActivityThread",...)->
// 通过zygote机制创建一个新的进程
Process.startViaZygote->调用新进程的main()
ActivityThread.main->
创建新进程的时候，AMS会保存一个ProcessRecord信息，Activity应用程序中的AndroidManifest.xml配置文件中，我们没有指定Application标签的process属性，系统就会默认使用package的名称。每一个应用程序都有自己的uid，因此，这里uid + process的组合就可以为每一个应用程序创建一个ProcessRecord。每次在新建新进程前的时候会先判断这个ProcessRecord是否已存在，如果已经存在就不会新建进程了,这就属于应用内打开Activity的过程了。
AMS通过开启新的进程并调用ActivityThread.main后，接下来就是应用程序进程了。
public static void main(String[] args) {
Looper.prepareMainLooper();
//又新建一个ActivityThread并调用attach(false)
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
}
thread.attach(false)主要是为了将ApplicationThread通过Binder驱动"传递"到远程AMS,也就是绑定，主要
是为了让AMS能通过ApplicationThread的代理ApplicationThreadProxy来调用ApplicationThread的方法，而本地应用程序通过ActivityManagerProxy来调用远程ActivityManagerService的方法，相当于应用程序与
AMS的通信窗口。
注意此时只创建了应用程序的ActivityThread和ApplicationThread,和开启了Handler消息循环机制，其他的都还未创建, ActivityThread.attach(false)又会最终到AMS的attachApplication，这个工程其实是将本地的ApplicationThread传递到AMS。然后AMS就可以通过ApplicationThread的代理ApplicationThreadProxy来调用应用程序ApplicationThread.bindApplication，通知应用程序的ApplicationThread已和AMS绑定，可以不借助其他进程帮助直接通信了。此时Launcher的任务也算是完成了。过程如下：
应用进程：
ActivityThread.attach
|
IActivityManager.attachApplication(mAppThread)
|
ActivityManagerProxy.attachApplication(mAppThread)
AMS进程:
ActivityManagerService.attachApplication
|
ApplicationThreadProxy.bindApplication
应用进程：
ApplicationThread.bindApplication
| Handler通信
AplicationThread.handlerBindApplication
ApplicationThreadProxy.bindApplication(...)会传来这个应用的一些信息，如ApplicationInfo，Configuration等,在ApplicationThread.bindApplication里会待信息封装成'AppBindData',通过
sendMessage(H.BIND_APPLICATION, data)
将信息放到应用里的消息队列里，通过Handler消息机制，在ActivityThread.handleMeaasge里处理H.BIND_APPLICATION的信息，调用AplicationThread.handleBindApplication。
handleBindApplication(AppBindData data) {
Process.setArgV0(data.processName);//设置进程名
...
//初始化mInstrumentation
if(data.mInstrumentation!=null) {
mInstrumentation = (Instrumentation) cl.loadClass(data.instrumentationName.getClassName()).newInstance();
}else {
mInstrumentation = new Instrumentation();
}
//创建Application，data.info是个LoadedApk对象。
Application app = data.info.makeApplication(data.restrictedBackupMode, null);
mInitialApplication = app;
//调用Application的onCreate()方法。
mInstrumentation.callApplicationOnCreate(app);
}
LoadedApk类：
public Application makeApplication(boolean forceDefaultAppClass,Instrumentation instrumentation) {
if (mApplication != null) {
return mApplication;
}
String appClass = mApplicationInfo.className;
java.lang.ClassLoader cl = getClassLoader();
//此时新建一个Application的ContextImpl对象，
ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
//通过在handleBindApplication创建的mInstrumentation对象新建一个Application对象，同时进行attach。
app = mActivityThread.mInstrumentation.newApplication(cl, appClass, appContext);
appContext.setOuterContext(app);
}
Instrumentation类：
public Application newApplication(ClassLoader cl, String className, Context context) {
return newApplication(cl.loadClass(className), context);
}
Instrumentation类：
static public Application newApplication(Class<?> clazz, Context context) {
//实例化Application
Application app = (Application)clazz.newInstance();
// Application和context绑定
app.attach(context);
return app;
}
//attach就是将新建的ContextImpl赋值到mBase,这个ContextImpl对象就是所有Application内Context的具体
//实现，同时赋值一些其他的信息如mLoadedApk。
final void attach(Context context) {
mBase = base;
mLoadedApk = ContextImpl.getImpl(context).mPackageInfo;
}
这时Application就创建好了，这点很重要，很多博客里说Application是在performLaunchActivity里创建的，因为performLaunchActivity也有mInstrumentation.newApplication这个调用,newApplication函数中可看出会先判断是否以及创建了Application，如果之前已经创建，就返回已创建的Application对象。
ApplicationThreadProxy.bindApplication完成后，同时在AMS进程，调用realStartActivityLocked，接着就通过ApplicationThreadProxy调用到应用程序进程
//AMS进程：
ActivityManagerService.realStartActivityLocked
|
ApplicationThreadProxy.scheduleLaunchActivity
//应用程序进程
ApplicationThread.scheduleLaunchActivity
| Handler通信
sendMessage(H.LAUNCH_ACTIVITY, r);
| handleMassage
ActivityThread.handleLaunchActivity
|
ActivityThread.performLaunchActivity {
//类似Application的创建过程，通过classLoader加载到activity.
activity = mInstrumentation.newActivity(classLoader,
component.getClassName(), r.intent);
//因为Activity有界面，所以其Context是ContextThemeWrapper类型，但实现类仍是ContextImpl.
Context appContext = createBaseContextForActivity(r, activity);
activity.attach(context,mInstrumentation,application,...);
//attach后调用activity的activity方法。
mInstrumentation.callActivityOnCreate(activity,...)
}
在ActivityThread.handleLaunchActivity里，接着调用
|
ActivityThread.performResumeActivity
|
activity.performResume
|
mInstrumentation.callActivityOnResume(this);
|
this.onResume;
activity.onResume就是和Window，View之类的绑定相关了，此时界面就显示出来了。
3. 总结
-
Application是在ActivityThread.handleBindApplication中创建的，一个线程只会创建一个Application，但一个应用程序如果有多个进程将会创建多个Application对象。
-
应用资源是在Application初始化的时候,也就是创建Application ContextImpl的时候，ContextImpl就包含这个路径，主要就是对就是ResourcesManager这个单例的引用。
-
可以看出每次创建Application和Acitvity以及Service时就会有一个ContextImpl实例，ContentProvider和BroadcastReceiver的Context是其他地方传入的。所以Context数量=Application数量+Activity数量+Service数量，单进程情况下Application数量就是1。
-
attach是依附、贴上的意思，可以理解为将两种事物联系在一起，上面分析的过程主要涉及3个attach，ActivityThread.attach可以理解为将应用程序进程的ApplicationThread依附到AMS，和AMS联系起来，用于整个AMS和应用程序的通信，Application.attach和Activity.attach主要是将新创建的ContextImpl对象与Application，Activity，Service等组件联系起来，对组件中其中的Context mBase变量赋值，以及一些初始化工作，比如MainHandler的赋值，mWindow的初始化（如果存在）等。
-
ContextImpl包含资源信息、对Context的一些函数的实现等。 可以很好的理解，attach需要在Application，Activity等组件调用onCreat之前调用，因为需要先完成组件的初始化工作。
-
管理着组件Application,Activity，Service等的创建，生命周期调用，很重要的一个类。例如：
//创建Application
mActivityThread.mInstrumentation.newApplication(cl, appClass, appContext);
//调用Application的onCreate()方法。
mInstrumentation.callApplicationOnCreate(app);//创建Activity,实际生命周期的管理。 mInstrumentation.newActivity(classLoader, component.getClassName(), r.intent); mInstrumentation.callActivityOnCreate(activity); mInstrumentation.callActivityOnOnResume(activity); ... -
点击Launcher时会创建一个新进程来开启Activity，而应用内打开Activity,如果Activity不指定新进程，将在原来进程打开，是否开启新进程实在AMS进行控制的，上面分析得到，每次开启新进程时会保存进程信息，默认为应用包名+应用UID,打开Activity时会检查请求方的信息来判断是否需要新开进程。Launcher打开Activity默认ACTIVITY_NEW_TASK，新开一个Activity栈来保存Activity的信息。
