Activity启动过程

基本类介绍：

1.AMS提供的接口：

IActivityManager：继承了IInterface，它代表远程Service（即AMS）对外提供的服务 ActivityManagerNative：相当于Stub类，跨进程提供服务的实体，是一个抽象类 ActivityManagerService：ActivityManagerNative的实现类，跨进程提供的服务实际都由该类提供 ActivityManagerProxy：代理对象，同样实现了IActivityManager向普通进程提供AMS相同的服务

2.Client提供的接口：

ActivityThread：App启动的入口，AMS服务的Client实体 ApplicationThread：ActivityThread的内部类，继承Binder，Client通过这个对象向AMS提供接口调用 ApplicationThreadProxy：Service端Client的代理对象，service通过这个对象调用Client的方法

3.其他：

Instrumentation：负责发起Activity的启动、并具体负责Activity的创建以及Activity生命周期的回调，一个应用进程只会有一个Instrumentation对象，App内的所有Activity都持有该对象的引用。 ActivityStack：AMS通过ActivityStack管理所有的Activity ActivityRecord：AMS端ActivityStack管理的对象，每个ActivityRecord对应一个Activity，里面封装了这个Acvitity的所有信息 ActivityClientRecord： Client端管理Activity所需的对象，用来存储Activity所需的所有信息

Activity启动流程：

1.startActivity调用了startActivityForResult:

public void startActivityForResult(Intent intent, int requestCode, Bundle options) { Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity( this, mMainThread.getApplicationThread(), mToken, this, intent, requestCode, options); if (ar != null) { mMainThread.sendActivityResult( mToken, mEmbeddedID, requestCode, ar.getResultCode(), ar.getResultData()); } }

2.Instrumentation:

//Context who:发起启动Activity的Context //IBinder contextThread：当前进程的ApplicationThread //IBinder token：AMS token public ActivityResult execStartActivity( Context who, IBinder contextThread, IBinder token, Activity target, Intent intent, int requestCode, Bundle options) { ... IApplicationThread whoThread = (IApplicationThread)contextThread; //ActivityManagerNative.getDefault()以单例的形式获取当前进程的AMS代理对象 int result = ActivityManagerNative.getDefault() .startActivity(whoThread, who, intent, token, target,requestCode, 0, ....); checkStartActivityResult(result, intent); return result; }

3.开始执行AMS端的逻辑 ActivityStackSupervisor和ActivityStack的方法管理活动栈，调用链太长，略

在正式启动Activity之前，ActivityStack会检查是否有Activity处于Resume状态，有的话要先使该Activity执行Pause； 停止Activity的方法是使用ApplicationThread代理跨进程通知那个Activity停止；

//className = com.android.server.am.ActivityStack private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) { ... if (mResumedActivity != null) { pausing |= startPausingLocked(userLeaving, false, next, dontWaitForPause); } } final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping, ActivityRecord resuming, boolean dontWait) { ... //这个方法会调用ApplicationThread代理来跨进程使当前Activity停止 prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing, userLeaving, prev.configChangeFlags, dontWait); }

4.Client端Pause当前的Activity：

//className = ApplicationThread public final void schedulePauseActivity(IBinder token, boolean finished, boolean userLeaving, int configChanges, boolean dontReport) { int seq = getLifecycleSeq(); sendMessage( finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY, token, (userLeaving ? USER_LEAVING : 0) | (dontReport ? DONT_REPORT : 0), configChanges, seq); }

handler收到消息会pause当前的的Activity，并立即通知AMS，请求启动新的Acitivity：

//className = android.app.ActivityThread private void handlePauseActivity(IBinder token, boolean finished, boolean userLeaving, int configChanges, boolean dontReport, int seq) { ActivityClientRecord r = mActivities.get(token); ... if (r != null) { performPauseActivity(token, finished, r.isPreHoneycomb(), "handlePauseActivity"); //通知AMS，请求启动新的Acitivity ActivityManagerNative.getDefault().activityPaused(token); } }

5.AMS端创建一个ActivityRecord并终于向Client发起请求打开新的Activity的请求：

class ActivityStarter { private int startActivity(.....) { ... //创建ActivityRecord ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid, callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(), resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null, mSupervisor, options, sourceRecord); } } //创建ActivityRecord的时候还会new一个apptoken，这个token在AMS端和Client端都是Acitvity的唯一标识 class ActivityRecord { appToken = new Token(this); ........ }

调用ApplicationThread向Client请求开启Acitivity：

//className = com.android.server.am.ActivityStackSupervisor final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app, boolean andResume, boolean checkConfig) throws RemoteException { ... //将新建的AMS appToken传递给Client端的Activity app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken, System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration), new Configuration(task.mOverrideConfig), r.compat, r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results, newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo); return true; }

6.ApplicationThread实体在Client进程执行新建ActivityClientRecord ，并使用Handler发送了一个消息

//className = ApplicationThread public final void scheduleLaunchActivity(Intent intent，IBinder token， ...){ ActivityClientRecord r = new ActivityClinetRecord(); r.token = token; //AMS token对象的IPC代理 r.intent = intent; ... sendMessage(H.LAUNCH_ACTIVITY,r); }

7.逻辑转移到H类中，用来处理H发送的消息：

/className = H private class H extends Handler{ public static final int LAUNCH_ACTIVITY = 100; ... public void handleMessage(Message msg){ switch (msg.what){ case LAUNCH_ACTIVITY: ActivityClientRecord r = (ActivityClientRecord)msg.obj; Activity a = performLaunchActivity(r); //在这个方法中完成了Activity的创建； } } }

8.通过Instrumentation用反射创建Activity对象：

ActivityInfo info = r.activityInfo; Activity activity = null; ClassLoader c = r.packageInfo.getClassLoader(); activity = mInstrument.newActivity(c,className,r.intent) //Instrument直接用类加载器和反射创建Activity

9.获取Applicationh和Instrumentation：

public Application makeApplication(Instrumentation instrumentation) { //应用内的页面跳转就直接返回已经存在的Application if (mApplication != null) { return mApplication; } ClassLoader classLoader = getClassLoader(); //刚打开应用Application不存在，需要创建 //Application也是通过Instrumentation创建的； return mActivityThread.mInstrumentation.newApplication(classLoader, ...) }

10.创建ContextImpl，并执行attach方法：

//在执行onCreat回调之前还要为新建的activity创建一个ContextImpl //可以看到每个activity都对应一个ContextImpl Context appContext = createBaseContextForActivity(r, activity); //r是ActivityClientRecord //attach里创建了Activity对应的Window，并使得Activity与ContextImpl建立联系 activity.attach(appContext,r.token, ...);

11.执行Activity的onCreate方法：

mInstarmentation.callActivityOnCreate(activity);

Token： 一个Activity对应一个Token，一个ActivityRecord和一个ActivityClientRecord； (AMS进程端)：先有new一个token，再把token注入ActivityRecord,这里的token是提供服务的实体对象； (Client进程端)：取出AMS传递的token注入新创建的ActivityClientRecord，最后才通过反射新建Activity，这里的token是AMS端token的代理对象； Activity在通过反射创建出来之后，需要调用attach与ContextImpl进行关联，这个方法将token传递给Activity，Activity再将token传递给Window

ActivityThread：

class ActivityThread { final ApplicationThread mAppThread = new ApplicationThread(); final Looper mLooper = Looper.myLooper(); final H mH = new H(); //存储了所有的Activity,以IBinder作为key,IBinder是Activity在框架层的唯一表示 final ArrayMap mActivities = new ArrayMap<>(); //存储了所有的Service final ArrayMap mServices = new ArrayMap<>(); //ActivityThread对象，拿到这个对象，可以反射调用这个类的需要的方法 private static ActivityThread sCurrentActivityThread; public static void main(String[] args) { Looper.prepareMainLooper(); ActivityThread thread = new ActivityThread(); thread.attach(false); //系统应用为true，非系统应用为false； Looper.loop(); } }

总结：

Activity的启动涉及到多次跨进程调用过程，这里的Server端是AMS，Client端是ActivityThread(主线程)，主线程通过AMS的代理访问AMS；主线程也为AMS访问主线程提供了接口，这个接口就是ApplicationThread； 一个旧的Activity启动新的Activity时，首先会通过AMSProxy通知AMS，AMS进行一些栈操作之后，通过ApplicationThreadProxy使旧的Activity执行pause，所以Activity生命周期方法调用时都会涉及到一次IPC过程； 然后AMS会为新的Activity创建一个ActivityRecord作为新Activity在AMS端的唯一标识，然后通过ApplicationThread通知主线程 创建Activity，并把新的appToken，intent等信息传递给主线程； 主线程保存appToken，intent等信息后，通过一个Handler分发生命周期调用请求，之后Instrumentation通过反射创建新的Activity，Application(如果需要的话)，ContextImpl，并将新的Activity和ContextImpl关联起来，最后调用onCreate方法