Activity启动过程startActivity源码分析

本文基于Android28，以Activity#startActivity(Intent intent)开始为入口

@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
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
    startActivityForResult(intent, requestCode, null);                                  
}

接着继续看Activity#startActivityForResult(@RequiresPermission Intent intent, int requestCode,@Nullable Bundle options)的源码

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
		//mParent常用于ActivityGroup,但是ActivityGroup已废弃，所以一般的Activity都是走这里	
        if (mParent == null) {
			//启动一个新的Activity,核心功能位于mMainThread.getApplicationThread()。
			//Instrumentation类是用于监视system和application交互的类。
			//在最终启动activity的地方会用到Instrumentation
            options = transferSpringboardActivityOptions(options);
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
            if (ar != null) {
				//发送调用onActivityResult的消息
                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 {
			//ActitityGroup内部的Activity则会走这里，实现方式其实是一样的
            if (options != null) {
                mParent.startActivityFromChild(this, intent, requestCode, options);
            } else {
                // Note we want to go through this method for compatibility with
                // existing applications that may have overridden it.
                mParent.startActivityFromChild(this, intent, requestCode);
            }
        }
    }    

真正执行打开Activity是在mInstrumentation#execStartActivity方法中实现的，接着继续看到Instrumentation#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;
        if (referrer != null) {
            intent.putExtra(Intent.EXTRA_REFERRER, referrer);
        }
        if (mActivityMonitors != null) {
            synchronized (mSync) {
				//遍历ActivityMonitor,看是否存在这个Activity
                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++;
						//如果//当该monitor阻塞activity启动,也就是目标Activity无法打开就直接return
                        if (am.isBlocking()) {
                            return requestCode >= 0 ? am.getResult() : null;
                        }
						//如果存在就跳出循环 
                        break;
                    }
                }
            }
        }
        try {
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess(who);
			//真正的startActivity的方法，其实核心功能在whoThread的scheduleLaunchActivity完成的
            int result = ActivityManager.getService()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
			//用于检查打开Activity异常的方法，比如常见的Activity没在AndroidManifest的话，                       
        	//会抛出“...have you declared this activity in your AndroidManifest.xml?”异常
        	//内部实现是各种情况下需要抛出的异常信息			
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }

此处的ActivityManager#getService()#startActivity，是定义在ActivityManagerService的方法，进入ActivityManagerService查看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());
    }

    @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) {
        return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
                true /*validateIncomingUser*/);
    }

    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,
            boolean validateIncomingUser) {
        enforceNotIsolatedCaller("startActivity");

        userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
                Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");

        // TODO: Switch to user app stacks here.
        //mActivityStartController.obtainStarter()获取得到的是ActivityStarter;
        //ActivityStarter主要负责处理intenth和flags、选择启动的task、复用Activity等逻辑
        return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
                .setCaller(caller)
                .setCallingPackage(callingPackage)
                .setResolvedType(resolvedType)
                .setResultTo(resultTo)
                .setResultWho(resultWho)
                .setRequestCode(requestCode)
                .setStartFlags(startFlags)
                .setProfilerInfo(profilerInfo)
                .setActivityOptions(bOptions)
                .setMayWait(userId)
                .execute();

    }

最终将会调用到ActivityManagerService#startActivityAsUser，并且在ActivityManagerService#startActivityAsUser中在execute()的时候调用ActivityStarter#execute()，具体内容如下：

int execute() {
        try {
            // TODO(b/64750076): Look into passing request directly to these methods to allow
            // for transactional diffs and preprocessing.
            // 上面调用了setMayWait()，所以mRequest.mayWait为true，执行startActivityMayWait()。
			// ActivityStarter.startActivityMayWait() 的参数mRequest.inTask是一个ActivityRecord，默认是null
            if (mRequest.mayWait) {
                return startActivityMayWait(mRequest.caller, mRequest.callingUid,
                        mRequest.callingPackage, mRequest.intent, mRequest.resolvedType,
                        mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
                        mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
                        mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
                        mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
                        mRequest.inTask, mRequest.reason,
                        mRequest.allowPendingRemoteAnimationRegistryLookup);
            } else {
                return startActivity(mRequest.caller, mRequest.intent, mRequest.ephemeralIntent,
                        mRequest.resolvedType, mRequest.activityInfo, mRequest.resolveInfo,
                        mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
                        mRequest.resultWho, mRequest.requestCode, mRequest.callingPid,
                        mRequest.callingUid, mRequest.callingPackage, mRequest.realCallingPid,
                        mRequest.realCallingUid, mRequest.startFlags, mRequest.activityOptions,
                        mRequest.ignoreTargetSecurity, mRequest.componentSpecified,
                        mRequest.outActivity, mRequest.inTask, mRequest.reason,
                        mRequest.allowPendingRemoteAnimationRegistryLookup);
            }
        } finally {
            onExecutionComplete();
        }
    }

ActivityStarter#execute()中mRequest.mayWait无论true或false，最终都会走到ActivityStarter#startActivityUnchecked的方法，并且在ActivityStarter#startActivityUnchecked()决定任务栈，确定启动模式，是否调用deliverNewIntent，复用Activity等判断，具体的内容如下：

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
    IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
    int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
    ActivityRecord[] outActivity) {
    ...省略部分代码...
    // 选择或者创建TaskRecord
    // mLaunchFlags & FLAG_ACTIVITY_NEW_TASK 是true，会走setTaskFromReuseOrCreateNewTask()创建一个新的TaskRecord
    if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
        && (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
        newTask = true;
        // 创建新的TaskRecord
        result = setTaskFromReuseOrCreateNewTask(taskToAffiliate, topStack);
    } else if (mSourceRecord != null) {
        result = setTaskFromSourceRecord();
    } else if (mInTask != null) {
        result = setTaskFromInTask();
    } else {
    	// 创建新的TaskRecord
        setTaskToCurrentTopOrCreateNewTask();
    }
    
    // mStartActivity = r；mStartActivity表示准备启动的Activity
    if (mDoResume) {
        final ActivityRecord topTaskActivity =
            mStartActivity.getTask().topRunningActivityLocked();
        if (!mTargetStack.isFocusable()
           || (topTaskActivity != null && topTaskActivity.mTaskOverlay
           && mStartActivity != topTaskActivity)) {
           
             mTargetStack.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
             mService.mWindowManager.executeAppTransition();
        } else {
        	if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
        		//将启动的Activity的栈移动到前台
            	mTargetStack.moveToFront("startActivityUnchecked");
            }
        	//mSupervisor 准备mStartAcitivity到栈顶，
             mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity, mOptions);
        }
    }
    ...省略部分代码...
}

ActivityStarter构建了Activity的ActivityRecord和TaskRecord，做完了前期的准备工作了，下面就开始了对栈顶的Activity的停止和启动新的Activity。

mSupervisor是ActivityStackSupervisor，它负责管理ActivityStack，所以mSupervisor.resumeFocusedStackTopActivityLocked既是ActivityStackSupervisor#resumeFocusedStackTopActivityLocked方法

ActivityStackSupervisor#resumeFocusedStackTopActivityLocked内容如下：

boolean resumeFocusedStackTopActivityLocked() {
        return resumeFocusedStackTopActivityLocked(null, null, null);
    }

    boolean resumeFocusedStackTopActivityLocked(
            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {

        if (!readyToResume()) {
            return false;
        }

        if (targetStack != null && isFocusedStack(targetStack)) {
            return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
        }

        final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
        if (r == null || !r.isState(RESUMED)) {
            mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
        } else if (r.isState(RESUMED)) {
            // Kick off any lingering app transitions form the MoveTaskToFront operation.
            mFocusedStack.executeAppTransition(targetOptions);
        }

        return false;
    }

这时候ActivityStarter已经把目标栈移动到前台，所以会到ActivityStack的resumeTopActivityUncheckedLocked()，在ActivityStack#resumeTopActivityUncheckedLocked()方法里面会调用到ActivityStack#resumeTopActivityInnerLocked()

// 在resumeTopActivityInnerLocked里暂停之前活动的Activity和把要启动的Activity添加到栈顶
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
	final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
	if (mResumedActivity != null) {
        // 暂停之前的Activity
        pausing |= startPausingLocked(userLeaving, false, next, false);
    }
		
	if (next.app != null && next.app.thread != null) {
	    // activtiy存在，resume
		mStackSupervisor.scheduleResumeTopActivities();
	} else {
	    //创建进程，冷启动Activity。或者已启动App，重新启动Activity
		StackSupervisor.startSpecificActivityLocked(next, true, false);
	}
}
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
    ActivityRecord resuming, boolean pauseImmediately) {
    ...省略部分代码...
	// mService是AMS，prev.app.thread是ApplicationThread
	mService.getLifecycleManager().scheduleTransaction(prev.app.thread, prev.appToken,
         PauseActivityItem.obtain(prev.finishing, userLeaving,
	         prev.configChangeFlags, pauseImmediately));
	...省略部分代码...
}

mService.getLifecycleManager()获取到是ClientLifecycleManager，这个类负责执行ActivityLifecycleItem，就是生命周期的任务，如PauseActivityItem、ResumeActivtyItem，每次执行最后会跟ActivityThread交互。
ClientLifecycleManager#scheduleTransaction方法代码：

void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
            @NonNull ActivityLifecycleItem stateRequest) throws RemoteException {
        final ClientTransaction clientTransaction = transactionWithState(client, activityToken,
                stateRequest);
        scheduleTransaction(clientTransaction);
}
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();
        transaction.schedule();
        if (!(client instanceof Binder)) {
            // If client is not an instance of Binder - it's a remote call and at this point it is
            // safe to recycle the object. All objects used for local calls will be recycled after
            // the transaction is executed on client in ActivityThread.
            transaction.recycle();
        }
}
//ClientTransaction#schedule
public void schedule() throws RemoteException {
    // mClient是IApplicationThread
    mClient.scheduleTransaction(this);
}

ActivityLifecycleItem会被包装在ClientTransaction里面，如如PauseActivityItem、ResumeActivtyItem。
这里走到了IApplicationThread，而IApplicationThread的实体是ActivityThread内部类ApplicationThread，它是一个binder对象，IApplicationThread是它远程接口。

// ActivityThread#ApplicationThread#scheduleTransaction
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    ActivityThread.this.scheduleTransaction(transaction);
}

在这里已经到达ActivityThread，但是并不在主线程。没错，接下来就是用Handler切换线程的时候。
但是在这里你搜不到ActivityThread的scheduleTransaction()，原因是在ActivityThread继承了ClientTransactionHandler，ClientTransactionHandler实现了schedueleTransaction()

// ClientTransactionHandler
void scheduleTransaction(ClientTransaction transaction) {
    transaction.preExecute(this);
    sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
abstract void sendMessage(int what, Object obj);
//ActivityThread#sendMessage
void sendMessage(int what, Object obj) {
        sendMessage(what, obj, 0, 0, false);
}
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
        if (DEBUG_MESSAGES) Slog.v(
            TAG, "SCHEDULE " + what + " " + mH.codeToString(what)
            + ": " + arg1 + " / " + obj);
        Message msg = Message.obtain();
        msg.what = what;
        msg.obj = obj;
        msg.arg1 = arg1;
        msg.arg2 = arg2;
        if (async) {
            msg.setAsynchronous(true);
        }
        mH.sendMessage(msg);
}

//在ActivityThread.H.EXECUTE_TRANSACTION最终会走ActivityThread#H#handleMessage里面的这段代码
case EXECUTE_TRANSACTION:
     final ClientTransaction transaction = (ClientTransaction) msg.obj;
     mTransactionExecutor.execute(transaction);
     if (isSystem()) {
         // Client transactions inside system process are recycled on the client side
         // instead of ClientLifecycleManager to avoid being cleared before this
         // message is handled.
         transaction.recycle();
     }
     // TODO(lifecycler): Recycle locally scheduled transactions.
     break;

//其中TransactionExecutor#execute
public void execute(ClientTransaction transaction) {
     final IBinder token = transaction.getActivityToken();
     executeCallbacks(transaction);
     executeLifecycleState(transaction);
     mPendingActions.clear();
}
//executeLifecycleState()也是会执行ActivityLifecycleItem.execute
private void executeLifecycleState(ClientTransaction transaction) {
	final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
	if (lifecycleItem == null) {
		return;
	}
	final IBinder token = transaction.getActivityToken();
	final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
	if (r == null) {
		return;
	}
	// Cycle to the state right before the final requested state.
	cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);
	// Execute the final transition with proper parameters.
	lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
	lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}

其中LifecycleItem会走execute()，postExecute()等方法，也就是走PauseActivtyItem或者ResumeActivitItem的execute()，并切换到主线程。至此从startActivity开始创建一个activity并且将其添加到主线程的流程就结束了！