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

桃扇骨 2021-10-18 13:34 1131阅读 0赞

相关源码：  
\\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启动流程》][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);

[Android P_Zygote]: https://blog.csdn.net/Sunxiaolin2016/article/details/99290301