Android P窗口机制之Activity启动流程

相关源码：
\frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java
\frameworks\base\services\core\java\com\android\server\am\ActivityStarter.java
\frameworks\base\services\core\java\com\android\server\am\ActivityStackSupervisor.java
\frameworks\base\services\core\java\com\android\server\am\ActivityStack.java
\frameworks\base\services\core\java\com\android\server\am\ClientLifecycleManager.java
\frameworks\base\core\java\android\app\servertransaction\ClientTransaction.java
\frameworks\base\core\java\android\app\ActivityThread.java
\frameworks\base\core\java\android\app\ClientTransactionHandler.java
\frameworks\base\core\java\android\app\servertransaction\TransactionExecutor.java

Activity启动几种方式：

• 在Launcher界面点击应用程序图标启动Activity
• 通过内部调用startActivity接口来启动
• adb start命令直接启动应用程序

不管通过哪一种启动方式，最终都是由ActivityManagerService服务区启动的。

ActivityManagerService负责启动和管理Activity和Service。

上一篇介绍了ActivityManagerService的启动：
《Android P窗口机制之Zygote启动流程》

Activity启动流程

源码路径：\frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java
\frameworks\base\services\core\java\com\android\server\am\ActivityStarter.java

1、调用startActivity();

2、调用startActivityAsUser()，分局不同的userID去启动activity;

3、调用obtainStarter()，切换app stack，初始化一个activity启动器，即ActivityStarter，最终调用ActivityStarter.java中的execute。

源码：

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.
    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();
}

4、ActivityStarter.java调用execute()，调用startActivityMayWait()或者startActivity()

/**
 * Starts an activity based on the request parameters provided earlier.
 * @return The starter result.
 */
int execute() {
    try {
        // TODO(b/64750076): Look into passing request directly to these methods to allow
        // for transactional diffs and preprocessing.
        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,
                    mRequest.originatingPendingIntent);
        } 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,
                    mRequest.originatingPendingIntent);
        }
    } finally {
        onExecutionComplete();
    }
}

4.1 调用startActivityMayWait()，主要做了如下处理

• 解析intent数据
• 收集intent的相关信息
• 用于记录activity的数据
• 启动activity

4.2 调用startActivity()，主要做如下处理

• 检查intent是否合法，类名是否存在等检查
• 检查权限
• 给相应activity的intent设置flag
• 设置ActivityRecord，生命周期
• 加入栈顶
• 设置目标stack和现有activity匹配，根据需要清除stack
• 根据activity的启动模式判断直接插入已存在top stack还是重新插入
• 调用mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,mOptions);

5、调用resumeFocusedStackTopActivityLocked

源码路径：
\frameworks\base\services\core\java\com\android\server\am\ActivityStack.java

在resumeFocusedStackTopActivityLocked()中调用了resumeTopActivityInnerLocked()

5.1 调用resumeTopActivityInnerLocked

5.2 调用ActivityStackSupervisor中的startSpecificActivityLocked()

源码路径：\frameworks\base\services\core\java\com\android\server\am\ActivityStackSupervisor.java

5.3 调用realStartActivityLocked()，让app程序执行生命周期的回调。

// Schedule transaction.
mService.getLifecycleManager().scheduleTransaction(clientTransaction);

\frameworks\base\core\java\android\app\servertransaction\ClientTransaction.java

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();
    }
}

5.4 调用scheduleTransaction()

源码：\frameworks\base\core\java\android\app\servertransaction\ClientTransaction.java

public void schedule() throws RemoteException {
    mClient.scheduleTransaction(this);
}

/** Target client. */
private IApplicationThread mClient;

mClient是一个ApplicationThread对象，用于SystemService与app端进行通信交互的。

源码：\frameworks\base\core\java\android\app\ActivityThread.java

内部类ApplicationThread中：

@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    ActivityThread.this.scheduleTransaction(transaction);
}

源码：\frameworks\base\core\java\android\app\ClientTransactionHandler.java
ClientTransactionHandler是ActivityThread的父类。

/** Prepare and schedule transaction for execution. */
void scheduleTransaction(ClientTransaction transaction) {
    transaction.preExecute(this);
    sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}

通过handler发送消息通知ActivityThread。进入ActivityThread中的sendMessage()

关键点，看下ActivityThread的handler处理：

class H extends Handler {
	public void handleMessage(Message msg) {
		switch (msg.what) {
		   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;
		}
	}
}

关键点1：mTransactionExecutor.execute(transaction)
\frameworks\base\core\java\android\app\servertransaction\TransactionExecutor.java

public void execute(ClientTransaction transaction) {
    final IBinder token = transaction.getActivityToken();
    log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);

    executeCallbacks(transaction);

    executeLifecycleState(transaction);
    mPendingActions.clear();
    log("End resolving transaction");
}

最终调用到ActivityThread中handleLaunchActivity，主要做两件事情：
1、activity初始化
2、创建activity，performLaunchActivity()

performLaunchActivity主要做的处理：
1、初始化activity的context
2、利用classloader机制反射获取activity实例
3、创建app的入口Application
4、执行activity的attach方法，初始化window，view
5、执行activity的oncreate()方法

我重点关注的是view和window的创建：

activity.attach(appContext, this, getInstrumentation(), r.token,
        r.ident, app, r.intent, r.activityInfo, title, r.parent,
        r.embeddedID, r.lastNonConfigurationInstances, config,
        r.referrer, r.voiceInteractor, window, r.configCallback);