activity启动流程分析

先来个大体流程图：

我们一般调用startActivity这个API来启动一个新的activity。实际上差不多所有的APP基本是由launcher 调用这个接口拉起来的。所以我们只要从Activity.java这个类跟踪看其实现过程就可以。

1.startActivity

    @Override
    public void startActivity(Intent intent) {
   
   
        this.startActivity(intent, null);
    }
        @Override
    public void startActivity(Intent intent, @Nullable Bundle options) {
   
   
        if (options != null) {
   
   
            startActivityForResult(intent, -1, options);
        } else {
   
   
            // Note we want to go through this call for compatibility with
            // applications that may have overridden the method.
            startActivityForResult(intent, -1);
        }
    }

如上代码所示，实际上调用的是startActivityForResult这个接口

2.startActivityForResult

    /**
     * Same as calling {@link #startActivityForResult(Intent, int, Bundle)}
     * with no options.
     *
     * @param intent The intent to start.
     * @param requestCode If >= 0, this code will be returned in
     *                    onActivityResult() when the activity exits.
     *
     * @throws android.content.ActivityNotFoundException
     *
     * @see #startActivity
     */
    public void startActivityForResult(@RequiresPermission 
    Intent intent, int requestCode) {
   
   
        startActivityForResult(intent, requestCode, null);
    }

在这里 可以仔细看下上面的注释说明，如果requestCode这个参数大于等于0，那么activity起来后，会在onActivityResult()这个接口里面返回。所以
如果我们需要返回值，则直接调startActivityForResult接口。因为startActivity传入的是－1

  public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
   
   
        if (mParent == null) {
   
   
            options = transferSpringboardActivityOptions(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());
            }
            if (requestCode >= 0) {
   
   
                // If this start is requesting a result, we can avoid making
                // the activity visible until the result is received.  Setting
                // this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
                // activity hidden during this time, to avoid flickering.
                // This can only be done when a result is requested because
                // that guarantees we will get information back when the
                // activity is finished, no matter what happens to it.
                mStartedActivity = true;
            }

            cancelInputsAndStartExitTransition(options);
            // TODO Consider clearing/flushing other event sources and events for child windows.
        } else {
   
   
        ……

这里做的事比较少，就2步
1.如果传入的options是空值，那么会获取调用都的options.但有个前提就是调用者的动画类型是ANIM_SCENE_TRANSITION
2.调用Instrumentation类提供的execStartActivity接口

3.execStartActivity

   public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
   
   
        IApplicationThread whoThread = (IApplicationThread) contextThread;
        Uri referrer = target != null ? target.onProvideReferrer() : null;
        //这个是用来表明身份的，表示调用者是谁。如果有需要则要
        //重写onProvideReferrer这个接口（调用者）
        if (referrer != null) {
   
   
            intent.putExtra(Intent.EXTRA_REFERRER, referrer);
        }
        //mActivityMonitors应该为null,我搜遍所有代码，也没找到有
        //谁调用了addMonitor接口
        if (mActivityMonitors != null) {
   
   
            synchronized (mSync) {
   
   
                final int N = mActivityMonitors.size();
                for (int i=0; i<N; i++) {
   
   
                    final ActivityMonitor am = mActivityMonitors.get(i);
                    ActivityResult result = null;
                    if (am.ignoreMatchingSpecificIntents()) {
   
   
                        result = am.onStartActivity(intent);
                    }
                    if (result != null) {
   
   
                        am.mHits++;
                        return result;
                    } else if (am.match(who, null, intent)) {
   
   
                        am.mHits++;
                        if (am.isBlocking()) {
   
   
                            return requestCode >= 0 ? am.getResult() : null;
                        }
                        break;
                    }
                }
            }
        }
        try {
   
   
        //这个是针对intent的一些特殊的action增加一些flag和操作
            intent.migrateExtraStreamToClipData();
        //如果intent的包名和调用者的包者不一样，那么调用者这边就
        //需要做一些准备动作
            intent.prepareToLeaveProcess(who);
          //调用AMS接口进行启动activity的流程
            int result = ActivityManager.getService()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
   
   
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }

这个API主要就是AMS的startActivity的接口，继续进入下步流程。这里需要注意下传递的参数

4.startActivity

    @Override
    public final int startActivity(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
   
   
        return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                resultWho, requestCode, startFlags, profilerInfo, bOptions,
                UserHandle.getCallingUserId());
    }

这块就是新增加了一个参数，uid.如果系统支持多用户那么 uid就是IPC那边获取的。不支持多 用户那就是系统用户

5.startActivityAsUser

    @Override
    public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
   
   
        enforceNotIsolatedCaller("startActivity");
        userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
                userId, false, ALLOW_FULL_ONLY, "startActivity", null);
        // TODO: Switch to user app stacks here.
        return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
                resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
                profilerInfo, null, null, bOptions, false, userId, null, null,
                "startActivityAsUser");
    }

这个函数，前面检查uid。实际上，根本代码实现并没有作什么操作。主要就是后面调用ActivityStarter类的接口继续流程，注意传入的参数

7.startActivityMayWait

  final int startActivityMayWait(IApplicationThread caller, int callingUid,
            String callingPackage, Intent intent, String resolvedType,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            IBinder resultTo, String resultWho, int requestCode, int startFlags,
            ProfilerInfo profilerInfo, WaitResult outResult,
            Configuration globalConfig, Bundle bOptions, boolean ignoreTargetSecurity, int userId,
            IActivityContainer iContainer, TaskRecord inTask, String reason) {
   
   
        // Refuse possible leaked file descriptors
        if (intent != null && intent.hasFileDescriptors()) {
   
   
            throw new IllegalArgumentException("File descriptors passed in Intent");
        }
        mSupervisor.mActivityMetricsLogger.notifyActivityLaunching();
        boolean componentSpecified = intent.getComponent() != null;

        // Save a copy in case ephemeral needs it
        final Intent ephemeralIntent = new Intent(intent);
        // Don't modify the client's object!
        intent = new Intent(intent);
        if (componentSpecified
                && intent.getData() != null
                && Intent.ACTION_VIEW.equals(intent.getAction())
                && mService.getPackageManagerInternalLocked()
                        .isInstantAppInstallerComponent(intent.getComponent())) {
   
   
            // intercept intents targeted directly to the ephemeral installer the
            // ephemeral installer should never be started with a raw URL; instead
            // adjust the intent so it looks like a "normal" instant app launch
            intent.setComponent(null /*component*/);
            componentSpecified = false;
        }
		//根据intent和userid，查找所有应用。根据其Manifest的配置
		//找到我们所需要的activity,这块是调用的PMS服务
        ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId);
        if (rInfo == null) {
   
   
            UserInfo userInfo = mSupervisor.getUserInfo(userId);
            if (userInfo != null && userInfo.isManagedProfile()) {
   
   
                // Special case for managed profiles, if attempting to launch non-cryto aware
                // app in a locked managed profile from an unlocked parent allow it to resolve
                // as user will be sent via confirm credentials to unlock the profile.
                UserManager userManager = UserManager.get(mService.mContext);
                boolean profileLockedAndParentUnlockingOrUnlocked = false;
                long token = Binder.clearCallingIdentity();
                try {
   
   
                    UserInfo parent = userManager.getProfileParent(userId);
                    profileLockedAndParentUnlockingOrUnlocked = (parent != null)
                            && userManager.isUserUnlockingOrUnlocked(parent.id)
                            && !userManager.isUserUnlockingOrUnlocked(userId);
                } finally {
   
   
                    Binder.restoreCallingIdentity(token);
                }