[关闭]
@universal 2018-09-26T05:35:08.000000Z 字数 13556 阅读 350

启动Activity的那点事儿

源码分析 android

前言

这次主要是从源码角度和IPC角度分析下Activity的启动流程，基于Android 8.0，估计知识点比较多0.0，而且需要提前了解下一丢丢IPC的东西。

铺垫

首先，从用户点击APP图标开始走起。既然是启动一个APP，那必然需要启动一个进程来执行App。因为Android是基于Linux的，所有的进程都是由init进程fork出来的。所以（1）当手机系统启动的时候，init进程会创建一个Zygote进程，后面我们所有app的进程都是由这个Zygote进程fork出来的；（2）当有app启动时，ActivityManagerService会通过socket通知Zygote进程fork一个新进程。在这里额外说明一哈，其实这个AMS也是通过Zygote创建的，Zygote进程创建后首先会创建一个SystemServer进程，在这个SS进程中会启动像AMS、PMS这样的服务，有的都是IPC中关键的服务端程序。所以Zygote进程和SystemServer进程是Android Framework中非常重要的两大进程。

上面说到了app的进程是由Zygote孵化出来的，那么究竟是哪个进程去通知孵化的。其实很简单，如果是从其他app中启动的，就是那个app所在的进程；如果是从桌面启动的就是launcher进程，Launcher其实也是继承自Activity，所以我们也可以把桌面当作一个app，两种启动的方式都是调用startActivity()发送intent请求。

那么......敌军还有5秒到达战场......重要的来了

Activity（C端）

我们通常调用的startActivity的几种重载方法最终都会调用startActivityForResult()方法

  1. public void startActivityForResult(@RequiresPermission Intent intent, int requestCode, 
  2.           @Nullable Bundle options) 
  3. {
  4.     if (mParent == null) {
  5.         options = transferSpringboardActivityOptions(options);
  6.         Instrumentation.ActivityResult ar =mInstrumentation.execStartActivity(
  7.             this, mMainThread.getApplicationThread(), mToken, this,intent, requestCode, options);
  8.         if (ar != null) {
  9.             mMainThread.sendActivityResult(
  10.                 mToken, mEmbeddedID, requestCode, ar.getResultCode(),
  11.                 ar.getResultData());
  12.         }
  13.         cancelInputsAndStartExitTransition(options);
  14.     } else {
  15.         if (options != null) {
  16.             mParent.startActivityFromChild(this, intent, requestCode, options);
  17.         } else {
  18.             mParent.startActivityFromChild(this, intent, requestCode);
  19.         }
  20.     }
  21. }

主要看当mParent为null时，这个mParent指的是ActivityGroup，用来嵌套多个Activity，不过这个现在已经被废弃了，都用fragment来代替了，这里提主要是为了提醒下startActivityFromChild()这个方法，也能启动activity（记得在笔试题见到过 = =、）。好了回归主线，启动Activity的任务会交给Instrumention的execStartActivity()方法，注意这里的一个参数 mMainThread.getApplicationThread()，很重要，先记住。

  1. //Instrumention.java
  2.     public ActivityResult execStartActivity(Context who, IBinder contextThread, 
  3.                IBinder token,Activity target,Intent intent, int requestCode, Bundle options) {
  4.         IApplicationThread whoThread = (IApplicationThread) contextThread;
  5.         .......
  6.         try {
  7.             intent.migrateExtraStreamToClipData();
  8.             intent.prepareToLeaveProcess(who);
  9.             int result = ActivityManager.getService()
  10.                 .startActivity(whoThread, who.getBasePackageName(), intent,
  11.                         intent.resolveTypeIfNeeded(who.getContentResolver()),
  12.                         token, target != null ? target.mEmbeddedID : null,
  13.                         requestCode, 0, null, options);
  14.             checkStartActivityResult(result, intent);
  15.         } catch (RemoteException e) {
  16.             throw new RuntimeException("Failure from system", e);
  17.         }
  18.         return null;
  19.     }
  20.     //上面是8.0的源码，和8.0之前有差别，但是原理都是一样的，具体的区别有兴趣的可以自行查看
  22. //ActivityManager.java
  23.     public static IActivityManager getService() {
  24.         return IActivityManagerSingleton.get();
  25.     }
  26.     private static final Singleton<IActivityManager> IActivityManagerSingleton =
  27.             new Singleton<IActivityManager>() {
  28.                 @Override
  29.                 protected IActivityManager create() {
  30.                     final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
  31.                     final IActivityManager am = IActivityManager.Stub.asInterface(b);
  32.                     return am;
  33.                 }
  34.     };

首先来说说Instrumention这个类，每个Activity都持有Instrumentation对象的一个引用，但是整个进程只会存在一个Instrumentation对象,Instrumentation充当着一个管家的作用，任何和activity生命周期包括创建相关的方法都是通过它来具体实现的,这些后面再说它。

在execStartActivity()中，通过ActivityManager启动activity，ActivityManager.getService()返回的是一个单例，这个单例通过 asInterface()方法返回了一个Proxy对象，Proxy对象实现了IActivityManager接口，里面保存着服务端的binder对象（这个对象是通过ServiceManager拿到服务端的AMS binder对象），所以最后会通过Binder跨进程去调用服务端AMS中的方法启动activity。这其实就是个aidl的模板，可以自己敲一个aidl的实例对照着分析。

注意： 在8.0的时候，这里直接采用了aidl进行cs通信，所以8.0以前的ActivityManagerNative（服务端）、ActivityManagerProxy(客户端)已经被废弃，没有之前那么复杂了,但是原理都是一样的，最后都会跨进程去通知服务端的AMS启动activity。只不过8.0之前是通过binder（ActivityManagerNative）的transact()方法将数据打包成Parcel对象传给服务端,具体的流程大家可以自己去查阅，现在市面上的分析大部分都是8.0之前的版本。

AMS(S端)

现在启动任务交给了核心服务AMS处理：

  1. //ActivityManagerService.java
  2.     @Override
  3.     public final int startActivity( .......) {
  4.         return startActivityAsUser(........);
  5.     }
  7.     @Override
  8.     public final int startActivityAsUser(........);
  9.         userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
  10.                 userId, false, ALLOW_FULL_ONLY, "startActivity", null);
  11.         return mActivityStarter.startActivityMayWait(.......);
  12.     }

为了方便看到流程，我把详细参数都省略掉了，可以看到最后会交给ActivityStarter去启动：

  1. //ActivityStarter.java
  2. final int startActivityMayWait(IApplicationThread caller, int callingUid,String callingPackage, Intent intent, .....){
  3.         ....
  4.         final ActivityRecord[] outRecord = new ActivityRecord[1];
  5.         int res = startActivityLocked(caller, intent, ephemeralIntent, resolvedType,
  6.                 aInfo, rInfo, voiceSession, voiceInteractor,
  7.                 resultTo, resultWho, requestCode, callingPid,
  8.                 callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
  9.                 options, ignoreTargetSecurity, componentSpecified, outRecord, inTask,
  10.                 reason);
  11.         ....
  12.         return res;
  13. }
  14. //验证intent、Class、Permission等
  15. int startActivityLocked(IApplicationThread caller, Intent intent, Intent ephemeralIntent,....){
  16.         ....
  17.         mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
  18.                 aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
  19.                 callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
  20.                 options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
  21.                 inTask);
  22.         ....
  23.         return mLastStartActivityResult != START_ABORTED ? mLastStartActivityResult : START_SUCCESS;
  24. }
  26. private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,.....){
  27.         .....
  28.         //这里会去调用另外一个重载的startActivity()方法，具体的我就不贴了，下面是最后的出口
  29.         result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
  30.                     startFlags, doResume, options, inTask, outActivity);
  31.         return result;
  32. }
  34. private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
  35.             IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
  36.             int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
  37.             ActivityRecord[] outActivity) {
  38.         ....
  39.         //检查栈顶活动是否是我们要启动的activity
  40.         final boolean dontStart = top != null && mStartActivity.resultTo == null
  41.                 && top.realActivity.equals(mStartActivity.realActivity)
  42.                 && top.userId == mStartActivity.userId
  43.                 && top.app != null && top.app.thread != null
  44.                 && ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0
  45.                 || mLaunchSingleTop || mLaunchSingleTask);
  46.         //准备工作已经完成
  47.         if (dontStart) {
  48.             topStack.mLastPausedActivity = null;
  49.             if (mDoResume) {
  50.                 mSupervisor.resumeFocusedStackTopActivityLocked();
  51.             }
  52.             ....
  53.         }    
  54. }

其实，ActivityStarter类中的逻辑像是在做战斗前的准备工作，比如确认战斗的双方、战斗的目标和战斗时间等等。在startActivityMayWait()方法中主要获取调用者的uid和pid，并且通过resolveIntent和resolveActivity获取ActivityInfo信息，确定要启动的Activity组件；在startActivityLocked()方法中去调用startActivity()创建ActivityRecord，记录activity的核心状态信息；在startActivityUnchecked()方法中根据intent的Flag信息、activity的启动模式分配或者创建任务栈,设置TaskRecord。最后去调用ActivityStackSupervisor和ActivityStack中的相关方法：

  1. //ActivityStackSupervisor.java
  2. boolean resumeFocusedStackTopActivityLocked(
  3.             ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
  4.         if (targetStack != null && isFocusedStack(targetStack)) {
  5.             return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
  6.         }
  7.         final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
  8.         if (r == null || r.state != RESUMED) {
  9.             mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
  10.         } else if (r.state == RESUMED) {
  11.             // Kick off any lingering app transitions form the MoveTaskToFront operation.
  12.             mFocusedStack.executeAppTransition(targetOptions);
  13.         }
  14.         return false;
  15. }
  17. //ActivityStack.java
  18. boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
  19.         if (mStackSupervisor.inResumeTopActivity) {
  20.             // Don't even start recursing.
  21.             return false;
  22.         }
  23.         boolean result = false;
  24.         try {
  25.             // Protect against recursion.
  26.             mStackSupervisor.inResumeTopActivity = true;
  27.             result = resumeTopActivityInnerLocked(prev, options);
  28.         } finally {
  29.             mStackSupervisor.inResumeTopActivity = false;
  30.         }
  31.         final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
  32.         if (next == null || !next.canTurnScreenOn()) {
  33.             checkReadyForSleep();
  34.         }
  35.         return result;
  36.     }
  38. //这里主要是判断需要启动的Activity所在进程和app是否存在，不存在的话去孵化进程，存在的话直接启动activity
  39. private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
  40.         if (next.app != null && next.app.thread != null) {
  41.             ........
  42.         }else {
  43.             .......
  44.             mStackSupervisor.startSpecificActivityLocked(next, true, true);
  45.         }
  46.         return true;
  47. }
  49. //ActivityStackSupervisor.java
  50. void startSpecificActivityLocked(ActivityRecord r,boolean andResume, boolean checkConfig) {
  51.     ProcessRecord app = 
  52.                 mService.getProcessRecordLocked(r.processName,r.info.applicationInfo.uid, true);
  53.     r.getStack().setLaunchTime(r);
  54.     if (app != null && app.thread != null) {
  55.         try {
  56.             if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
  57.                     || !"android".equals(r.info.packageName)) {
  58.                 app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
  59.                         mService.mProcessStats);
  60.             }
  61.             realStartActivityLocked(r, app, andResume, checkConfig);
  62.             return;
  63.         } catch (RemoteException e) {
  64.             Slog.w(TAG, "Exception when starting activity "
  65.                     + r.intent.getComponent().flattenToShortString(), e);
  66.         }
  67.     }
  68. }
  69. final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
  70.             boolean andResume, boolean checkConfig) throws RemoteException {
  71.     ......
  72.     app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
  73.         System.identityHashCode(r), r.info,
  74.         mergedConfiguration.getGlobalConfiguration(),
  75.         mergedConfiguration.getOverrideConfiguration(), r.compat,
  76.         r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
  77.         r.persistentState, results, newIntents, !andResume,
  78.         mService.isNextTransitionForward(), profilerInfo);
  79. }

可以看到上面的代码是绕来绕去，= =、我们知道activity都是通过任务栈来进行管理的，所以stackSupervisor就是服务端统一管理这些任务栈的地方，而ActivityStack就是用来管理当前任务栈中的activity，所以服务端干的事简单来说就是完成activity的切换、将要启动的activity移至栈顶，然后通知客户端去渲染ui。但是实际上里面的逻辑很复杂，比如说不同启动模式下，栈中的activity如何操作，以及我们常见的为什么是firstActivity onPause之后secondActivity 才开始创建等等，这些和任务栈相关的都是在服务端控制。
里面具体的逻辑这里就不分析了，我们主要分析这个启动流程，参考下图了解下即可。
此处输入图片的描述
重点是最后这个realstart方法中的这句scheduleLaunchActivity，其他之前的包括starter中的逻辑都是在铺垫。。这个app.thread其实是保存在ProcessRecord中的一个IApplicationThread对象，是不是感觉这个对象名字很熟悉，它其实就是客户端中的ApplicationThread，因为从AMS开始，方法的执行都是在服务端执行，所以服务端的工作做完了，就需要去通知客户端去操作了，那么通知的桥梁就是这个ApplicationThread对象，它继承自IApplicationThread.Stub，是一个binder对象，其实这里跟上面和AMS的通信一样，在8.0之后，统一采用aidl方式，放弃了像ApplicationThreadNative+ApplicationThreadProxy的方式，但是它们的作用和aidl生成的java类中的逻辑是一样的，这个大家手动敲一个aidl的例子对比一哈就能看出来。

回到主线程

下面我们就具体看看客户端后续在干什么：

  1. //ActivityThread.ApplicationThread.java
  2.  @Override
  3. public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
  4.         ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
  5.         CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
  6.         int procState, Bundle state, PersistableBundle persistentState,
  7.         List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
  8.         boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {
  10.     updateProcessState(procState, false);
  11.     //创建ActivityClientRecord
  12.     ActivityClientRecord r = new ActivityClientRecord();
  13.     r.token = token;
  14.     r.ident = ident;
  15.     r.intent = intent;
  16.     r.referrer = referrer;
  17.     r.voiceInteractor = voiceInteractor;
  18.     r.activityInfo = info;
  19.     r.compatInfo = compatInfo;
  20.     r.state = state;
  21.     r.persistentState = persistentState;
  22.     r.pendingResults = pendingResults;
  23.     r.pendingIntents = pendingNewIntents;
  25.     r.startsNotResumed = notResumed;
  26.     r.isForward = isForward;
  28.     r.profilerInfo = profilerInfo;
  30.     r.overrideConfig = overrideConfig;
  31.     updatePendingConfiguration(curConfig);
  32.     //将消息传给handler处理
  33.     sendMessage(H.LAUNCH_ACTIVITY, r);
  34. }
  35. //ActivityThread.H.java
  36. public void handleMessage(Message msg) {
  37.     if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
  38.     switch (msg.what) {
  39.         case LAUNCH_ACTIVITY: {
  40.             Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
  41.             final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
  43.             r.packageInfo = getPackageInfoNoCheck(
  44.                         r.activityInfo.applicationInfo, r.compatInfo);
  45.             handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
  46.             Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  47.         } break;
  48.         ....
  49.     }
  50. }
  51. //ActivityThread.java
  52. private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
  53.     ......
  54.     Activity a = performLaunchActivity(r, customIntent);
  55.     if (a != null) {
  56.         handleResumeActivity(r.token, false, r.isForward,
  57.                         !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
  58.         .....
  59.     }
  60.     .....
  61. }
  62. private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
  63.     .....
  64.     ContextImpl appContext = createBaseContextForActivity(r);
  65.         Activity activity = null;
  66.         try {
  67.             java.lang.ClassLoader cl = appContext.getClassLoader();
  68.             //创建activity
  69.             activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
  70.             StrictMode.incrementExpectedActivityCount(activity.getClass());
  71.             r.intent.setExtrasClassLoader(cl);
  72.             r.intent.prepareToEnterProcess();
  73.             if (r.state != null) {
  74.                 r.state.setClassLoader(cl);
  75.             }
  76.         } catch (Exception e) {
  77.             if (!mInstrumentation.onException(activity, e)) {
  78.                 throw new RuntimeException(
  79.                     "Unable to instantiate activity " + component
  80.                     + ": " + e.toString(), e);
  81.             }
  82.         }
  83.     .....
  84.     Application app = r.packageInfo.makeApplication(false, mInstrumentation);
  85.     .....
  86.     if (r.isPersistable()) {
  87.         //生命周期的调用
  88.         mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
  89.     } else {
  90.         mInstrumentation.callActivityOnCreate(activity, r.state);
  91.     }
  92.     .....
  93. }
  94. //LoadedApk.java
  95. public Application makeApplication(boolean forceDefaultAppClass,Instrumentation instrumentation){
  96.     if (mApplication != null) {
  97.         return mApplication;
  98.     }
  99.     try {
  100.         java.lang.ClassLoader cl = getClassLoader();
  101.         if (!mPackageName.equals("android")) {
  102.            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,"initializeJavaContextClassLoader");
  103.             initializeJavaContextClassLoader();
  104.             Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  105.         }
  106.         ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
  107.         //创建application
  108.         app = mActivityThread.mInstrumentation.newApplication(cl, appClass, appContext);
  109.         appContext.setOuterContext(app);
  110.     } catch (Exception e) {
  111.         if (!mActivityThread.mInstrumentation.onException(app, e)) {
  112.             Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  113.             throw new RuntimeException(
  114.                 "Unable to instantiate application " + appClass
  115.                 + ": " + e.toString(), e);
  116.         }
  117.     }
  118. }

这里activity启动之后将消息传递给activitythread中的handler处理，然后重点在消息处理后调用的performLaunchActivity中，主要干了两件事，一是通过反射创建activity，二是创建application，当然如果application已存在，就不用再创建了。后面就开始了Activity生命周期的调用。
在performLaunchActivity方法中可以看到，调用生命周期oncreate方法的具体实现是在mInstrumentation中，其实其他像activity和Application的生命周期的调用包括创建等等也是在这个类中实现，所以就印证了我上面提到的Instrumentation充当着一个管家的作用。

到这里，，就差不多可以点投降了。
这里简单的总结了下启动过程中的ipc，当然这里面不仅仅只有这两次跨进程通信，而且服务端参与的服务也不仅仅只有AMS，像在resolveIntent时就会跨进程去掉用PMS中的服务。
此处输入图片的描述

那么Activity启动的流程....大致.....是这样，猝。

一点儿干货

点此可以详细查看activity启动流程
个人觉得讲binder讲的最好的一篇

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注