为了简化理解难度，本文代码进行了简化处理。代码以API26为准。
目录
（2）mStackSupervisor.attachApplicationLocked(app)
一、App启动流程图
总结：APP启动流程：
手机启动之后，Linux的内核加载完成之后就会启动一个叫“init“的进程。init进程会创建ZygoteProcess。Zygote进程会启动Dalvik虚拟机和孵化SystemServer。SystemServer是Zygote孵化的第一个进程，SystemServer负责启动和管理整个Java FrameWork，包含ActivityManagerService， WorkManagerService，PagerManagerService，PowerManagerService等服务。然后启动Launcher，这是用户看到的桌面App。安装APP的时候，PackaManagerService会对AndroidManifest.xml文件进行解析，获取到四大组件相关信息。LauncherActivity继承ListActivity。通过pmg获取设备的应用信息，展示在ListView上。点击应用图标，会获取当前应用的启动信息，调用Activity的startActivity方法。之后会调用startActivityForResult，如果requestCode为-1，表示不需要返回结果。之后调用Instrumentation的execStartActivity方法。Instrumentation管理activity的一个工具类，activity的生命周期方法都是由Instrumentation来控制的。之后会调用ActivityManagerService的startActivity方法。之后会在ActivityStarter根据intent在系统中找到目标activity，对参数进行校验设置intent信息、flag标识和启动模式等。然后在在ActivityStack获取mResumedActivity。当前的mResumedActivity就是launcher，然后调用launcher的pause方法。之后判断目标activity是否启动和目标activity的进程是否启动，如果没有会创建进程。调用Process的start方法，接下来调用ZygoteProcess的start方法。然后连接socket，ZygoteConnection类接收到socket发送的创建进程的指令，会调用 Zygote的native方法fork一个新的进程，进程名就是传入的pkgName。然后通过反射调用ActivityThread的main函数。main方法中，会开启主线程的looper进行主线程消息循环，调用attach方法，在里面调用ActivityManagerService的attachApplication方法，并把ApplicationThread传入到ams中，进行通信。ActivityManagerService会调用ApplicationThread的bindApplication方法（创建LoadedApk，初始化ContentProvider，通过LoadedApk的makeApplication创建application，然后调用application的onCreate方法。）和启动activity的realStartActivityLocked方法。之后会调用ActivityThread.scheduleLaunchActivity，发送handler信息LAUNCH_ACTIVITY,在handler的handleMessage方法中执行performLaunchActivity。调用Instrumentation的newActivity方法，通过反射创建activity，最终执行到activity的onCreate等生命周期方法。
二、LauncherActivity
手机桌面是LauncherActivity。LauncherActivity继承ListActivity。我们的应用布局在ListView上。点击应用图标item，会调用
protected void onListItemClick() {
Intent intent = intentForPosition(position);
startActivity(intent);
}
intentForPosition会返回当前待启动activity的intent。
我们安装APP的时候，系统会启动PackaManagerService，pms会对AndroidManifest.xml文件进行解析，获取到四大组件相关信息和应用的启动Activity。
/**
* 1、获取清单文件设置启动的Activity的intent
* 2、mActivitiesList从PackageManagerService获取当前设备的应用信息，也就是展示在Launcher上的应用。
*/
public Intent intentForPosition(int position) {
Intent intent = new Intent(mIntent);
ListItem item = mActivitiesList.get(position);
intent.setClassName(item.packageName, item.className);
return intent;
}
Next=>调用Acitivity的startActivity方法。
三、Activity
startActivity-> startActivityForResult(intent, -1, options)
public void startActivityForResult() {
Instrumentation.ActivityResult ar =mInstrumentation.execStartActivity();
}
startActivityForResult()方法是有返回结果的，所以系统就直接给-1，表示不需要返回结果。
Next**=>调用Instrumentation的execStartActivity**方法。
四、Instrumentation
Instrumentation管理activity的一个工具类，activity的生命周期方法都是由Instrumentation来控制，一个进程中只用一个Instrumentation实例。
public ActivityResult execStartActivity(){
//调用ActivityManagerService的startActivity方法。
int result =ActivityManager.getService().startActivity();
//检查启动Activity的结果（抛出异常，例如清单文件未注册Activity）
checkStartActivityResult(result, intent);
}
Next=>调用ActivityManagerService的startActivity方法
五、ActivityManagerService
ActivityManagerService负责系统中所有Activity的生命周期。在Android系统中，任何一个Activity的启动都是由AMS和应用程序进程（主要是ActivityThread）相互配合来完成的。
startActivity-> startActivityAsUser -> mActivityStarter.startActivityMayWait()
Next=>调用ActivityStarter的startActivityMayWait方法
六、ActivityStarter
startActivityMayWait（根据intent在系统中找到目标activity）
-> startActivityLocked-> startActivity（对传过来的参数做一些校验，然后创建ActivityRecord对象）
-> startActivityUnchecked（设置启动模式）
Next=>调用ActivitySta**ckSuperviso**r的re**sumeFocusedStackTopActivity**Locked方法
七、ActivityStackSupervisor
->resumeFocusedStackTopActivityLocked->ActivityStack 的 resumeTopActivityUncheckedLocked
Next=>调用ActivityStack 的 resumeTopActivityUncheckedLocked
八、ActivityStack
resumeTopActivityUncheckedLocked()-> resumeTopActivityInnerLocked()
void resumeTopActivityInnerLocked(){
//mResumedActivity指向上一次启动的Activity(Launcher)
if (mResumedActivity != null) {
//通知Launcher进入pause状态
pausing |= startPausingLocked();
}
//判断Activity是否已经启动过
if (next.app != null && next.app.thread != null) {
//如果Intent不为空，调用NewIntent方法传入Intent
next.app.thread.scheduleNewIntent();
//假设我的的App已经启动，点击Home键返回到Launcher,再次从Launcher启动我们的APP
next.app.thread.scheduleResumeActivity();
} else {
//创建进程，冷启动Activity。或者已启动App，重新启动Activity
mStackSupervisor.startSpecificActivityLocked(next, true, true);
}
}
这里我们走else创建进程
Next**=>调用mStackSupervisor的startSpecificActivityLocked**方法。
九、ActivityStackSupervisor
void startSpecificActivityLocked() {
// Is this activity's application already running?
ProcessRecord app = mService.getProcessRecordLocked();
if (app != null && app.thread != null) {
//目标Activity的App已经启动（存在ActivityThread），则重启Activity
realStartActivityLocked(r, app, andResume, checkConfig);
}
//如果进程不存在，则通过zygote创建应用进程。
mService.startProcessLocked();
}
Next=>调用Activi**tyManagerServi**ce的start**Process**Locked方法。
十、ActivityManagerService
startProcessLocked->Process的start方法
Next=>调用Process的start方法
十一、Process
Next=>调用ZygoteProcess的start方法。
十二、ZygoteProcess
//ZygoteProcess孵化出新的应用进程，然后通过反射调用ActivityThread的main函数
Next=>调用ActivityThread的main函数
十三、ActivityThread
ActivityThread并不是一个线程Thread，它是final类并且无继承或者实现其它类，它的作用就是在main方法内消息循环，处理主线程事务。
public static void main(String[] args) {
//准备主线程的Looper
Looper.prepareMainLooper();
//创建当前进程的ActivityThread
ActivityThread thread = new ActivityThread();
//将该进程绑定到AMS
thread.attach(false);
//进入主线程的消息循环
Looper.loop();
}
接下来看thread.attach(false);
private void attach(boolean system) {
//获取ActivityManagerService
final IActivityManager mgr = ActivityManager.getService();
final ApplicationThread mAppThread = new ApplicationThread();
mgr.attachApplication(mAppThread);
}
Next=>调用ActivityManagerService的attachApplication。
十四、ActivityManagerService
->attachApplication
public final void attachApplication(IApplicationThread thread) {
synchronized (this) {
//获取applicationThread的进程id(也就是我们的应用进程)
int callingPid = Binder.getCallingPid();
attachApplicationLocked(thread, callingPid);
}
}
->attachApplicationLocked()
void attachApplicationLocked(){
thread.bindApplication（）
mStackSupervisor.attachApplicationLocked(app)
}
（1）thread.bindApplication（）
=>调用ActivityThread的内部类ApplicationThread的bindApplication方法。
（2）mStackSupervisor.attachApplicationLocked(app)
在ApplicationThread绑定了application之后，对application进行初始化，接下来就启动我们的activity。
=>调用ActivityStackSupervisor的attachApplicationLocked方法
十五、ApplicationThread
ApplicationThread是ActivityThread的内部类。
作用：创建进程对应的ContextImpl、LoadedApk、Application等对象，同时加载Application中的ContentProvider，并初始化Application。
private class ApplicationThread{
public final void bindApplication(.) {
AppBindData data = new AppBindData();
//给data设置参数，ApplicationThread通过H(Handler)与ActivityThread通讯，处理Activity事务。
sendMessage(H.BIND_APPLICATION, data);
}
}
=>调用Handler来处理BIND_APPLICATION消息
private class H extends Handler {
public void handleMessage(Message msg) {
//绑定application
case BIND_APPLICATION:
AppBindData data = (AppBindData)msg.obj;
handleBindApplication(data);
break;
}}
=>调用handleBindApplication
private void handleBindApplication(AppBindData data) {
//根据传递过来的ApplicationInfo创建一个对应的LoadedApk对象
data.info = getPackageInfoNoCheck(data.appInfo,data.compatInfo);
//7.0引入Fileprovide
if (data.appInfo.targetSdkVersion >= Build.VERSION_CODES.N) {
StrictMode.enableDeathOnFileUriExposure();
}
//创建进程对应的Android运行环境ContextImpl
final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
//加载进程对应Package中携带的ContentProvider
installContentProviders(app, data.providers);
//调用Application的onCreate方法
//故此Applcation对象的onCreate方法会比ActivityThread的main方法后调用，但是会比这个应用的所有activity先调用
mInstrumentation = new Instrumentation();
mInstrumentation.callApplicationOnCreate(app);
}
十六、ActivityStackSupervisor
ActivityStackSupervisor维护着终端中所有ActivityStack
booleanattachApplicationLocked(){
//通过轮询，找出前台栈顶端的待启动Activity
//前台待启动的Activity与当前新建的进程一致时，启动这个Activity
realStartActivityLocked()
}
realStartActivityLocked->ActivityThread.scheduleLaunchActivity
Next=>调用ActivityThread.scheduleLaunchActivity
十七、ActivityThread
->scheduleLaunchActivity
->sendMessage(H.LAUNCH_ACTIVITY, r)
->handleLaunchActivity(r, null, “LAUNCH_ACTIVITY”)
->performLaunchActivity
->activity.attach()
->mInstrumentation.callActivityOnCreate(activity, r.state);
private void handleLaunchActivity() {
//会调用Activity的onCreate,onStart,onResotreInstanceState方法,完成了Activity对象的创建和启动
performLaunchActivity(r, customIntent);
//会调用Activity的onResume方法.
handleResumeActivity();
}
=>performLaunchActivity
private Activity performLaunchActivity() {
//1、从ActivityClientRecord中获取待启动的Activity的组件信息。给r赋值packageInfo、component，然后创建appContext
//2、创建ContextImpl对象
ContextImpl appContext = createBaseContextForActivity(r);
//3、通过Instrumentation的newActivity方法使用类加载器创建Activity对象。
java.lang.ClassLoader cl = appContext.getClassLoader();
Activity activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
//4、通过Activity的attach方法来完成一些重要数据的初始化。
activity.attach()
//5、调用mInstrumentation.callActivityOnCreate()方法，会调用
Activity的onCreate方法。
mInstrumentation.callActivityOnCreate(activity, r.state);
mInstrumentation.callActivityOnRestoreInstanceState()
mInstrumentation.callActivityOnPostCreate()
}
Next=>调用mInstrumentation.callActivityOnCreate
十八、Instrumentation
callActivityOnCreate()->Activity.performCreate方法。
十九、Activity
->Activity.performCreate->onCreate(icicle)
Finlay=>至此完成了activity的启动过程，调用了activity的onCreate方法。
问题一：
App和AMS(SystemServer进程)还有zygote进程分属于三个独立的进程，他们之间如何通信呢？
App与AMS通过Binder进行IPC通信，AMS(SystemServer进程)与zygote通过Socket进行IPC通信。
扫一扫
2008
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
