基础代码流程
Activity.class ::startActivity()
-->startActivityForResult() //往下传的参数 IBinder 是当前 mMainThread.getApplicationThread() 和mtoken
-->Instrumentation.class ::execStartActivity(Context who, IBinder contextThread, IBinder token, Activity target,Intent intent, int requestCode, Bundle options)
-->ActityManangerService.class ::startActivity()//这里传递了ApplicationThread
-->startActivityAsUser（）
-->ActivityStarter.class ::execute()//设置进去了IApplicationThread 和Intent 给mRequest 这里也涉及到了权限的提升和充值
--> executeRequest()// mService.getProcessController(caller); 这里找到对应app 构建 ActivityRecord 将找到的app （WindowProcessController）塞入进去
-->startActivityUnchecked()
-->startActivityInner()//setInitialState() 将 r 给了mStartActivity
//这里还调用了startActivityLocked（） 将对应的activity开始构建挂载 挂载的task 还会将activityRecord 挂到最上层
RootWindowContainer.class::resumeFocusedTasksTopActivities()
--> Task.class:: resumeTopActivityUncheckedLocked
-->resumeTopActivityInnerLocked()
-->ActivityTaskSupervisor.class::startSpecificActivity();//假设需要创建页面
到这里分2个分支 一种进程存在，一种进程不存在
进程存在
ActivityTaskSupervisor::realStartActivityLocked(){
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
//基本上是基于事件去驱动了
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(isTransitionForward);
} else {
lifecycleItem = PauseActivityItem.obtain();
}
//在callBack 里设置 LaunchActivityItem（）
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
System.identityHashCode(r), r.info,
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
r.getSavedState(), r.getPersistentSavedState(), results, newIntents,
r.takeOptions(), isTransitionForward,
proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
r.createFixedRotationAdjustmentsIfNeeded(), r.shareableActivityToken,
r.getLaunchedFromBubble()));
//ClientTransaction 中的 client 其实就是appThread
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
}
-->ClientLifecycleManager.java::scheduleTransaction(){
final IApplicationThread client = transaction.getClient();
-->
ClientTransaction.java::schedule();
{ //其实就是AppThread 就是上面一路传递过来的
mClient.scheduleTransaction(this);
}
-----------------------
回调 ActitvityThread 中的ApplicationThread 的scheduleTransaction
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
// 回调 ActivityThread 的scheduleTransaction（） 因为 ActivityThread 继承 ClientTransactionHandler 走 父类方法
ClientTransactionHandler.class ::scheduleTransaction(){
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
//查看 消息响应
handleMessage（）{
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
break;
}
-->TransactionExecutor.java:: execute(){
executeCallbacks(transaction);
{
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
final ClientTransactionItem item = callbacks.get(i);
//LaunchActivityItem 上面传入的
item.execute(mTransactionHandler, token, mPendingActions);
}
}
---> LaunchActivityItem.class ::execute(){
ActivityClientRecord r = client.getLaunchingActivity(token);
// 回调 ActivityThread.handleLaunchActivity
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
}
-->
ActivityThread.class::handleLaunchActivity(){
final Activity a = performLaunchActivity(r, customIntent);//反射构建 调用剩下生命周期
}
进程不存在
ActivityTaskSupervisor.class::startSpecificActivity(){
//省略。。。。
mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
}
ActivityTaskManagerService.class::startProcessAsync();{
final Message m = PooledLambda.obtainMessage(ActivityManagerInternal::startProcess,
mAmInternal, activity.processName, activity.info.applicationInfo, knownToBeDead,
isTop, hostingType, activity.intent.getComponent());
mH.sendMessage(m);
}
-->ActivityManagerInternal::startProcess()
-->startProcess()
-->startProcessLocked()
ProcessList.class::startProcessLocked()
-->startProcess()
-->Process.class ::start()
-->ZygoteProcess.class::start()
-->startViaZygote()//拼装启动参数argsForZygote
-->zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),//该方法打开和zygote的套接字
zygotePolicyFlags,
argsForZygote)
-->
//将参数拼接字符串后 io操作
attemptZygoteSendArgsAndGetResultI(zygoteState, msgStr){
final BufferedWriter zygoteWriter = zygoteState.mZygoteOutputWriter;
final DataInputStream zygoteInputStream = zygoteState.mZygoteInputStream;
zygoteWriter.write(msgStr);
zygoteWriter.flush();
Process.ProcessStartResult result = new Process.ProcessStartResult();
result.pid = zygoteInputStream.readInt();
result.usingWrapper = zygoteInputStream.readBoolean();
}
备注：
在zygoteProcess 里面 public static final String PRIMARY_SOCKET_NAME = "zygote";` `public static final String SECONDARY_SOCKET_NAME = "zygote_secondary";
在调用 openZygoteSocketIfNeeded（） 调用 attemptConnectionToPrimaryZygote(); 会和zygote 进行socket 链接， 而链接的端口的启动 是在zygoteInit.class里面 main() 里构建了ZygoteServer（） 在他的构造方法里 构建了 这两个端口
总结：
总结:将构建参数通过socket 传递给zygote 事先知道了zygoye的地址 在Android系统中，usap_pool_primary是一个UNIX域套接字（LocalSocket），它扮演着Zygote进程与其他系统组件之间通信桥梁的角色，尤其是与SystemServer相关的通信。Zygote在启动时会创建两个主要的socket：一个是众所周知的zygote socket，另一个就是usap_pool_primary。
zygote socket主要用于孵化新的应用程序进程，当系统需要创建一个新的App进程时，会通过这个socket向Zygote发送请求。而usap_pool_primary socket的存在目的稍微特殊一些，它是用来支持所谓的“预先创建的进程池”（pre-forked process pool）机制的一个部分。
预先创建的进程池是一种优化策略，旨在减少进程创建的延迟。在这个机制下，Zygote会在启动时预先fork出一定数量的子进程，并让这些子进程保持空闲状态，监听在usap_pool_primary socket上。当系统有快速启动服务或进程的需求时，比如启动System Server或者是其他需要快速响应的系统组件，就可以直接从这个进程池中挑选一个进程来使用，而无需经历完整的进程创建过程。这样可以显著加快这些关键服务的启动速度。
简而言之，usap_pool_primary socket是Android系统为了提高某些关键服务启动效率而设计的一个通信通道，它辅助实现了进程预创建和快速分配，是系统性能优化的一部分。
进入zygote
ZygoteInit.class::main(){
caller = zygoteServer.runSelectLoop(abiList);
caller.run();
}
-->ZygoteServer.class::runSelectLoop();//while ture 等待传递的数据
//构建出来 ZygoteConnection 并将传递过来的参数赋值进去
--> //这里返回的是一个Runnable 下面的代码追踪都是为了返回该Runnable
ZygoteConnection.class::processCommand(this, multipleForksOK);
-->handleChildProc(parsedArgs, childPipeFd,parsedArgs.mStartChildZygote);
--> ZygoteInit.class::zygoteInit();
-->RuntimeInit.calss::applicationInit();
-->findStaticMain()//其实就是反射构建对应类 并构建main 方法后返回 这里构建的是ActivityThread ，下图断点
进入 ActivityThread
ActivityThread.class::main(){
ActivityThread thread = new ActivityThread();//构建thread
thread.attach(false, startSeq);
}
::attach(){
// 获取Ams 让他管理当前应用
final IActivityManager mgr = ActivityManager.getService();
mgr.attachApplication(mAppThread, startSeq);
}
-->ActivityManagerService::attachApplication()
--> attachApplicationLocked(thread, callingPid, callingUid, startSeq){
thread.bindApplication () // 调用了ActivityThread.bindApplication 这里包含了application的构建和基本参数的设定。
mAtmInternal.attachApplication(app.getWindowProcessController())
}
-->attachApplication()
--> RootWindowContainer.class::attachApplication()//通过 ATMS 启动根 Activity
-->startActivityForAttachedApplicationIfNeeded()
-->mTaskSupervisor.realStartActivityLocked（）// 承接我们编写好的进程存在的页面启动流程
备注
在应用桌面点击 其实会调用到
Laucher.class::startActivitySafely()
->BaseDraggingActivity.class::startActivitySafely --> Activity.class:: startActivity(intent, optsBundle);
一个页面的启动 其实会涉及多个生命周期，我们只是单纯的抓个一个走到底，真正开发的时候还是需要多去打堆栈去观察，多思考。
其实某种程度来说 ，在wms的角度看，其实就是挂载层级的的window 向前挪和向后挪。
之前好奇 Task的构建过程 ，其实是在ActivityStarter的 startActivityInner 中构建的新的task
if (newTask) {
final Task taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
? mSourceRecord.getTask() : null;
setNewTask(taskToAffiliate);
} else if (mAddingToTask) {
addOrReparentStartingActivity(targetTask, "adding to task");
}
一个Activity 在启动的过程中，涉及到前一个页面的隐藏，这个逻辑简单记录一下
ActivityStarter.startActivityInner()
--> mRootWindowContainer.resumeFocusedTasksTopActivities(
mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
-->RootWindowContainer.resumeFocusedTasksTopActivities()
-->Task.resumeTopActivityUncheckedLocked()
-->resumeTopActivityInnerLocked()
--> boolean pausing = !deferPause && taskDisplayArea.pauseBackTasks(next);
-->pauseBackTasks()
-->task.startPausingLocked()
{
//这里构建了 暂停的item
mAtmService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),
prev.appToken, PauseActivityItem.obtain(prev.finishing, userLeaving,
prev.configChangeFlags, pauseImmediately));
}
再次做总结：
从类型转变上来说可以是核心 构建ActivityRecord 因为 继承windowToken,
在ActivityStarer.executeRequest() 构建 一个新的 ActivityRecord 包含跳转的页面的所有参数， 在startActivityInner（）里面 setInitialState 先进行赋值活动，然后
判断是否是 task 挂载问题，涉及到栈顶等问题，这里会有多种情况，挂载现有，挂载到最上层显示的，挂载到root上等， 然后会将该页面开始启动挂载流程， 然后 在 RootWindowContainer 调用 resumeFocusedTasksTopActivities（）调用task 的 resumeTopActivityUncheckedLocked 构建 ClientTransaction 构建 然后塞进去了 ActivityLifecycleItem ，最后调用执行，最后会调用binder 执行到ActivityThread,
ApplicationThread 的scheduleTransaction ,最后基于消息 会调用到 基于消息 开始调用生命周期 performLaunchActivity（） 等 反射构建Activity ， 检查对应的Application进程是否存在，然后反射调用启动
，然后反射调用attach 构建phoneWindow 等 最后 基于生命周期不断的推进状态，然后开始调用onCreat（）和 onResume 在oncreat（） 里面 构建出对应开始对布局进行解析， 构建decorview， 并将构建出来的布局 挂载到decoview的 id 为content的view 上，
onResume() 里面做的就比较多了 在 执行 执行 resumeActivityItem 会调用到 handleResumeActivity()的时候 会调用WindowManagerImp.addView() 构建 ViewRootImpl并将原来构建好的view 设置进去。 并加入 mRoots。
ViewRootImpl 是核心类， 构造函数构建出了 第一构造了windowSession, 构建了W类 可以 传递给wms，可以监听wms 的回调 setview ()构建了inputchannel。 构建了 InputQueue和 WindowInputEventReceiver 保证了触摸事件的回调。
然后 触发了 requestLayout(); 会进行状态的推进。
关于Activity 中token的构建，其实是依赖于Intent构建出来的。
