网站建设与管理模拟题1,在网站怎么做代销,平面设计主要学什么软件,wordpress分类规则AMS 主要负责四大组件的启动、切换和调度以及应用程序的管理和调度工作. ActivityManager的组成主要分为以下几个部分:
服务代理: 由ActivityManagerProxy实现,用于与Server端提供的系统服务进行进程间通信服务中枢: ActivityManagerNative,继承自Binder并实现了IActivityMana…AMS 主要负责四大组件的启动、切换和调度以及应用程序的管理和调度工作. ActivityManager的组成主要分为以下几个部分:
服务代理: 由ActivityManagerProxy实现,用于与Server端提供的系统服务进行进程间通信服务中枢: ActivityManagerNative,继承自Binder并实现了IActivityManager,他提供了服务接口和Binder接口的相互转化,并在内部存储服务代理对象,并提供了getDefault方法返回服务代理.Client端: 由ActivityManager封装了一部分服务接口给Client端调用.ActivityManager内部通过ActivityManagerNative的getDefault方法,可以得到一个ActivityManagerProxy对象的引用,进而通过该代理类对象调用远程服务的方法.Server端: 由ActivityManagerService实现,提供Server端的系统服务
SystemServer进程如何管理SystemService? SystemService是一个抽象类,将具体服务的一些公共方法抽离出来(如:onStart()方法),方便SystemServiceManager管理所有的服务; 所有的服务要么直接继承自SystemService,要么定义一个内部类LifeCycle继承自SystemService并在内部类中,将当前服务(如:AMS)类作为一个成员变量; 我们在通过SystemServiceManager调用startService()方法启动服务的时候,就会调用抽象类SystemService的onStart()方法,最后的实现就是由相应服务去实现. 如:AMS的LifeCycle内部类的onStart()方法、BatterService的onStart()方法.
AMS的启动流程 通过SystemService的启动引导服务方法startBootstrapServices(),然后通过SystemServiceManger的startService()方法,最终会调用到AMS的start()方法,完成AMS的启动. AMS启动时实现了哪些功能: AMS.start()
mProcessCpuThread.start();//启动CPU监控线程mBatteryStatsService.publish();//注册电池状态和权限管理服务mProcessCpuInitLatch.await();//等待mProcessCpuInitLatch完成初始化,释放锁,初始化期间禁止访问
SystemServer中启动AMS也完成了一些初始化任务:
mActivityManagerService.initPowerManagement();//初始化电源管理mActivityManagerService.setSystemProcess();//设置为系统进程 将一些服务添加到ServiceManager进程集合中,如:GraphicsBinder、DbBinder、ProcessInfoService、PermissionController等.
由于AMS管理的服务很多,四大组件都是通过AMS来管理的;所以将Activity的管理抽离出来交给ATMS来管理,但是AMS同时会管理ATMS,通过在AMS中持有ATMS的成员变量. public ActivityTaskManagerService mActivityTaskManager;
App的启动流程 App的启动流程中涉及到4个进程,不同的进程进间采取了Binder和Soket的通信机制,同一个进程中有采用了Handler的通信方式.
Launcher进程 从ServiceManager集合中获取到AMS的IBinder对象转化的代理类ActivityManagerProxy,通过Binder通信机制,向SystemServer进程中的AMS服务发送启动app主页面的请求startActivity(). SystemServer进程 接收到Launcher进程发送过来的启动app首页的请求; 若app已经存在于后台,直接通过SystemServer进程去启动我们的app进程中的主页; 若app不存在,此时SystemServer进程需要向Zygote进程发送soket消息,请求创建app进程. Zygote进程 通过ZygoteServer接收SystemServer进程发送来的创建App进程的soket消息,通过fork创建App进程. App进程 App进程创建成功后,从ServiceManager集合中取出AMS的IBinder对象的代理类ActivityManagerProxy;通过Binder通信机制和SystemServer进程通信,通过AMS的代理类调用SystemServer进程中的AMS服务;调用AMS的启动App主页方法realStartActivityLocked(),该方法会获取到App进程ApplicationThread服务的代理类ApplicationThreadProxy;SystemServer进程通过Binder进程间通信机制与App进程通信,通过SystemServer进程中的代理类ApplicationThreadProxy,调用App进程中的ApplicationThread服务的scheduleLaunchActivity()方法;然后通过App进程中的ApplicationThread发送Handler消息LAUNCHER_ACTIVITY给ActivityThread,在ActivityThread中调用handleLaunchActivity方法,调用Activity的onCreate()方法.
AMS源码分析 SystemServer进程要启动App进程的首页时,当发现App没有运行在后台,则需要通知Zygote进程去创建一个App进程出来,此时会调用AMS的startProcess() 方法创建进行.
(ProcessList)mProcessList AMS.java AMS类中包含一个ProcessRecord的集合ProcessList,用于管理一个个进程ProcessRecord. final ArrayListProcessRecord mLruProcesses new ArrayListProcessRecord();ProcessRecord是一个进程,里面包含了进程的相关信息. startProcess() ProcessList.java 启动进程 Process.start() Process.java Process是一个进程ProcessRecord的工具类,相当于我们平时写的Utils,里面包含了静态方法 (ZygoteProcess)ZYGOTE_PROCESS.start() ProcessList.java ZygoteProcess同样是一个工具类,这里会调用到ZygoteProcess.start()方法 startViaZygote() ZygoteProcess.javazygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),zygotePolicyFlags, argsForZygote); ZygoteProcess.javaattemptUsapSendArgsAndGetResult(zygoteState, msgStr); ZygoteProcess.java 通过Socket获取到输出流和输出流,发送和接收消息(目标:ZygoteServer) (BufferWriter)usapWriter.write(msgStr); 通过sokect将拼接好的命令通过字符流发送给Zygote服务器(ZygoteServer)ZygoteServer接收到sokect消息后,在connection.processOneCommand(this)方法中,会去解析参数msgStr-args,然后通过fork创建进程: pid Zygote.forkAndSpecialize()进程创建成功后,会将pid和usingWrapper这两个参数发送给客户端,以便下面通过输入流读取这两个参数: (DataOutputStream)mSocketOutStream.writeInt(pid); (DataOutputStream)mSocketOutStream.writeBoolean(usingWrapper);result.pid (DataInputStream)usapReader.readInt(); 通过读取soket返回消息中的pid,判断进程是否创建成功 try (LocalSocket usapSessionSocket zygoteState.getUsapSessionSocket()) {final BufferedWriter usapWriter new BufferedWriter(new OutputStreamWriter(usapSessionSocket.getOutputStream()),Zygote.SOCKET_BUFFER_SIZE);final DataInputStream usapReader new DataInputStream(usapSessionSocket.getInputStream());//通过输出流写入拼接的命令usapWriter.write(msgStr);usapWriter.flush();Process.ProcessStartResult result new Process.ProcessStartResult();//通过输入流读取数据中的pid,如果pid0则返回,//pid0表示孩子进程创建成功,pid0表示zygote进程创建成功,pid-1表示fork创建进程失败result.pid usapReader.readInt();// USAPs cant be used to spawn processes that need wrappers.result.usingWrapper false;if (result.pid 0) {return result;} else {throw new ZygoteStartFailedEx(USAP specialization failed);}}AMS如何启动进程 AMS中有一个管理进程的类ProcessList,通过这个ProcessList去启动一个个的进程ProcessRecord,进程的启动入口就是AMS的startProcessLocked(). AMS启动进程的流程如下: AMS启动一个进程其实是打开这个App的首页面,当发现这个首页所在的进程不存在,则会发送sokect消息给Zygote进程;Zygote进程中的ZygoteServer在接收到这条socket消息后,通过fork去创建出app进程(下面的代码只分析到发送一条sokect消息给Zygote服务器) startProcessAsync() ATMS ATMS作为AMS中一个专门用于管理Activity的启动与切换的工具,这里面就包含了启动一个Activity的方法,这里的Activity被封装成了ActivityRecord ActivityManagerInternal::startProcess() ATMS ActivityManagerInternal的实现类,是AMS中的内部类LocalService,LocalService包含类这个startProcess()方法 startProcess() ActivityManagerService.LocalServicestartProcessLocked() ActivityManagerService.LocalServicestartProcessLocked() AMS 这个方法返回值是ProcessRecord ProcessRecord proc mProcessList.startProcessLocked(); AMS 通过这个方法作为一个入口去启动一个进程,最终返回该进程这个方法参数中包含了进程名字:processName、应用信息:ApplicationInfo等这个方法返回值是一个进程ProcessRecord,也就是一个App进程 startProcessLocked() ProcessList 这里会调用多个相同名字的startProcessLocked()方法,但是参数不同,最终会调用到startProcess()方法 Process.ProcessStartResult startResult startProcess() ProcessListProcess.start() ProcessList 这是进程ProcessRecord的一个工具类,里面是一些静态方法,类似于我们平时写的Utils工具类 (ZygoteProcess)ZYGOTE_PROCESS.start() ZygoteProcess.java 这是Zygote进程的一个工具类包含一个内部类ZygoteState,这个类里面包含一些和ZygoteServer进行socket通信的属性,如:mZygoteSocketAddress、mUsapSocketAddress、mZygoteSessionSocket、mZygoteInputStream、mZygoteOutputWriter等 ZygoteProcess.start() ZygoteProcess.javastartViaZygote() ZygoteProcess.javazygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), zygotePolicyFlags, argsForZygote); ZygoteProcess.java openZygoteSocketIfNeeded(abi):这个方法会去连接ZygoteServer服务器,以便发送和接收socket消息,连接ZygoteServer代码如下: zygoteSessionSocket.connect(zygoteSocketAddress); ZygoteProcess.javaargsForZygote:拼接很多参数,在通过socket将该消息发送给Zygote进程中的ZygoteServer服务器后,会解析出这条消息中的参数信息 attemptZygoteSendArgsAndGetResult() ZygoteProcess.java 通过输出流将消息发送给ZygoteServer服务器,Zygote进程通过fork创建孩子进程,然后通过输入流读取ZygoteServer服务器返回的数据,源码分析如下:private Process.ProcessStartResult attemptZygoteSendArgsAndGetResult(ZygoteState zygoteState, String msgStr) throws ZygoteStartFailedEx {try {//通过输出流将这条消息msgStr发送给ZygoteServer服务器,然后通过fork创建app进程final BufferedWriter zygoteWriter zygoteState.mZygoteOutputWriter;//在进程创建成功后,ZygoteServer服务器恢复消息,然后通过输入流读取返回的数据final DataInputStream zygoteInputStream zygoteState.mZygoteInputStream;//数据是先写入到缓冲区里zygoteWriter.write(msgStr);//发送消息//flush()方法将输入流和输出流中的缓冲进行刷新使缓冲区中的元素即时做输入和输出而不必等缓冲区满zygoteWriter.flush();// Always read the entire result from the input stream to avoid leaving// bytes in the stream for future process starts to accidentally stumble// upon.Process.ProcessStartResult result new Process.ProcessStartResult();result.pid zygoteInputStream.readInt();result.usingWrapper zygoteInputStream.readBoolean();if (result.pid 0) {throw new ZygoteStartFailedEx(fork() failed);}return result;} catch (IOException ex) {zygoteState.close();Log.e(LOG_TAG, IO Exception while communicating with Zygote - ex.toString());throw new ZygoteStartFailedEx(ex);}
}Zygote进程中的ZygoteServer里面有一个死循环,不停的在轮询有没有发送来的sokect消息,当有消息发送过来的时候,就会去处理这条socket消息.下面是Zygote进程在初始化时main()方法里创建的ZygoteServer服务器,这是一个Socket服务器.
//创建ZygoteServer Socket服务器
zygoteServer new ZygoteServer(isPrimaryZygote);
//开启一个死循环,不停遍历有没有发送来的socket消息,接收到socket消息则会fork出一个进程
caller zygoteServer.runSelectLoop(abiList);
//返回的被封装成了一个Runnable对象,后面会调用他的run方法,
//最终会调用到Runnable的实现类RuntimeInit.MethodAndArgsCaller的run方法.
//该方法中会通过反射去调用ActivityThread类的main函数:
//mMethod.invoke(null, new Object[] { mArgs });
caller.run();//最终执行创建的App进程的初始化操作,也就是ActivityThread的main方法Zygote进程接收到Soket消息并fork出App进程的流程如下:
runSelectLoop() ZygoteServer.java 遍历有没有发送过来的socket消息返回值是一个Runnable对象,这个对象被封装在了MethodAndArgsCaller (ZygoteConnection)connection.processOneCommand(this); ZygoteServer.java 处理发送来的这条消息 processOneCommand(ZygoteServer zygoteServer) ZygoteConnection.java 解析发送来的socket消息中的参数: String[] args Zygote.readArgumentList(mSocketReader); int pid Zygote.forkAndSpecialize() 通过fork创建孩子进程和zygote进程,孩子进程的pid0,zygote进程的pid0,fork方法最终会调到native层中的fork()方法,这个方法会去调用Linux层里的fork()方法.在孩子进程创建成功后,pid0的逻辑判断中会去调用handleChildProc()方法,该方法最终会调用ActivityThread的main函数,流程如下: handleChildProc() ZygoteConnection.javaZygoteInit.zygoteInit() ZygoteConnection.java 这里进入!isZygote的逻辑判断代码块RuntimeInit.applicationInit() RuntimeInit.javafindStaticMain(args.startClass, args.startArgs, classLoader); RuntimeInit.javareturn new MethodAndArgsCaller(m, argv); MethodAndArgsCaller是RuntimeInit的一个内部类,他继承自Runnable这里会创建一个MethodAndArgsCaller作为Runnable的实现类返回,最终就是调用MethodAndArgsCaller的run()方法; 这个方法可以在创建SystemServer进程时,调用SystemServer的main函数这个方法还可以在创建App进程时,调用ActivityThread的main函数(我们这里是分析的创建App进程,所以走这一步) 这里为什么是ActivityThread的main函数,是因为在AMS发送socket消息里面拼接的参数就是ActivityThread?这里我还没找到方法去验证.这里孩子进程先创建,然后创建zygote进程,在zygote进程创建完成后,调用的方法handleParentProc()中,会将Zygote进程的数据通过流的形式发送出去,代码如下: mSocketOutStream.writeInt(pid); mSocketOutStream.writeBoolean(usingWrapper);
最终,ZygoteProcess中的attemptZygoteSendArgsAndGetResult()方法中,会获取到ZygoteServer中通过fork()创建的进程信息,比如:pid和usingWrapper. 总结: AMS通过持有的进程管理类ProcessList的启动进程方法mProcessList.startProcessLocked(),作为启动进程的入口,期间会调用到Process和ZygoteProcess这两个工具类的start()方法,最终在ZygoteProcess中,通过流的方式将拼接的参数发送给Zygote进程中的ZygoteServer服务器ZygoteServer是一个Socket服务器,里面有一个死循环用于接收socket消息,在接收到socket消息后就会去解析消息中的参数,然后通过fork()先后创建孩子进程(App进程)和zygote进程并返回进程的pid;然后根据进程的pid0去处理孩子进程(App进程),最终通过反射调用到ActivityThread的main函数中去;处理完孩子进程(App进程)后,会去处理创建的zygote进程,并发送sokect消息给SystemServer进程中的AMS,告诉AMS创建的进程pid和usingWrapper. App进程启动后,attach过程
main() ActivityThread.java 创建一个ActivityThread,然后调用attach()方法创建一个Looper并执行loop()方法,让App进程一直处于运行状态 (ActivityThread)thread.attach(false, startSeq); ActivityThread.java(AMS)mgr.attachApplication(mAppThread, startSeq); ActivityThread.java mgr参数说明:其实就是AMS final IActivityManager mgr ActivityManager.getService();mAppThread参数说明:是一个ApplicationThread对象,他作为ActivityThread的内部类存在.ApplicationThread继承自IApplicationThread.Stub,所以我们可以把他作为一个IBinder对象.这个方法最终将一个App进程IBinder对象注册到SystemServer进程中的AMS服务中.于是乎,SystemServer进程就可以通过App进程的IBinder服务的代理类,通过Binder机制实现跨进程通信,App进程相当于是Server端,而SystemServer进程相当于是Client端. attachApplicationLocked(thread, callingPid, callingUid, startSeq); AMS (IApplicationThread)thread.bindApplication() AMS 将IBinder绑定到AMSthread:这是一个AIDL生成的Java类IApplicationThread,作为一个服务器,需要由他的Stub类的子类来完成具体的实现.会调用ActivtyThread.ApplicationThread类中的bindApplication()方法,这里会通过Handler发送消息BIND_APPLICATION,在主线程中调用handleBindApplication(data)做一些处理: installContentProviders(app, data.providers);//创建四大组件之ContentProvider(Application)app data.info.makeApplication(data.restrictedBackupMode, null);//创建Application,并调用他的attach()方法mInstrumentation.callApplicationOnCreate(app);//执行Application的生命周期 (ProcessRecord)app.makeActive(thread, mProcessStats); AMS 将(IApplicationThread)_thread对象赋值给ProcessRecord中的thread对象;解析:_thread是App进程中ActivityThread内部类ApplicationThread的IBinder对象,ProcessRecord是SystemServer进程中的AMS里的ProcessList中的一个进程.所以,这里的赋值操作,是为了方便实现跨进程通信,实现SystemServer进程中的AMS去直接使用App进程中的IApplicationThread对象. mProcessList.updateLruProcessLocked(app, false, null); AMS 将ProcessRecord添加到ProcessList中去,也就是将进程ProcessRecord添加到AMS的进程管理类ProcessList集合中去,这里的ProcessRecord进程就相当于是我们的App进程. (ActivityTaskManagerInternal)mAtmInternal.attachApplication(app.getWindowProcessController()); AMS ATMS中内部类LocalService继承自ActivityTaskManagerInternal这里会调用到ATMS中的LocalService内部类中的attachApplication()方法最终在ATMS中执行Activity的启动流程,流程如下: (RootWindowContainer)mRootWindowContainer.attachApplication(wpc); ATMSattachApplication() RootWindowContainer.javaRootWindowContainer::startActivityForAttachedApplicationIfNeeded RootWindowContainer.java(ActivityStackSupervisor)mStackSupervisor.realStartActivityLocked() RootWindowContainer.javarealStartActivityLocked() ActivityStackSupervisor.java 这个方法会将启动的Activity初始状态标记为LaunchActivityItem,最终状态标记为ResumeActivityItem,代码如下:// Create activity launch transaction.
final ClientTransaction clientTransaction ClientTransaction.obtain(proc.getThread(), r.appToken);//TODO 这里将ClientTransaction添加回调,回调的状态是LaunchActivityItem
clientTransaction.addCallback(LaunchActivityItem.obtain());
// Set desired final state.
final ActivityLifecycleItem lifecycleItem;
//TODO 传递过来的andResume为true,这里会将最终的状态标记成ResumeActivityItem
if (andResume) {lifecycleItem ResumeActivityItem.obtain(dc.isNextTransitionForward());
} else {lifecycleItem PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);// Schedule transaction.
mService.getLifecycleManager().scheduleTransaction(clientTransaction);在启动Activity的时候,最终调用到TransactionExecutor的execute(clientTransaction)方法时,里面的两个方法,executeCallbacks(transaction)和executeLifecycleState(transaction),分别在执行ClientTransactionItem的execute()方法和ActivityLifecycleItem的execute()方法时,最终就会分别调用到实现类LaunchActivityItem和ResumeActivityItem的execute()方法.
AMS是如何管理App进程的? AMS类中包含一个管理进程的变量mProcessList,ProcessList是用来管理手机中所有的App进程的,每一个App进程就是一个ProcessRecord,而ProcessRecord中包含一个变量(IApplicationThread)thread,IApplicationThread相当于是一个Server端的IBinder对象,我们将这个IBinder对象注册到AMS中去;AMS要访问App进程,(SystemServer进程中的)AMS只需要通过IBinder对象的代理类(IBinder的Proxy)即可与App进程实现跨进程通信,从而实现AMS对每一个App进程的管理.
Activity的启动流程(总结) 比如:ActivityA要启动ActivityB
解析ActivityB启动的参数然后通过ActivityStack栈来管理和启动ActivityB 所有的Activity都是通过一个栈(ActivityStack)来管理的和启动,每一个Activity会被封装成ActivityRecord将ActivityStackSupervisor(管理ActivityStack栈)封装成ClientTransaction事务,然后发送给App进程目前还在AMS中,也就是SystemServer进程 跨通信的流程,使用Binder来实现:ClientTransactionApplication进程拿到ClientTransaction事务,然后去处理ActivityBActivityA:执行onStop生命周期
Activity启动流程详细流程:
startActivityAsUser() ATMS.LocalServicestartActivityAsUser() ATMSgetActivityStartController().obtainStarter(intent, startActivityAsUser)... .execute(); ATMS getActivityStartController()返回的是ActivityStarterControler对象obtainStarter()会返回一个ActivityStarter对象,这里使用完ActivityStarter会将其数据清空,放入一个ActivityStarter缓存持中;这个原理类似于RecyclerView的缓存池里面省略的set方法都是给ActivityStarter.Request内部类赋值execute()取出里面省略的set方法给ActivityStarter.Request中赋值的参数,然后处理这些参数 executeRequest(mRequest) ActivityStarter.java 根据这些参数创建出需要启动Activity对象的ActivityRecord,代码如下: ActivityRecord r new ActivityRecord(...); startActivityUnchecked() ActivityStarter.javastartActivityInner() ActivityStarter.java (ActivityStack)mTargetStack.startActivityLocked()//启动黑白屏页面 (RootWindowContainer)mRootWindowContainer.resumeFocusedStacksTopActivities() ActivityStarter.java(ActivityStack)focusedStack.resumeTopActivityUncheckedLocked() RootWindowContainer.javaresumeTopActivityInnerLocked() ActivityStack startPausingLocked(userLeaving, false /* uiSleeping */, next); 执行当前Activity的onPause生命周期,next参数分析: ActivityRecord next topRunningActivity(true); (ActivityStackSupervisor)mStackSupervisor.startSpecificActivity(next, true, false); ActivityStack.javastartSpecificActivity() ActivityStackSupervisor.java 判断要启动页面的进程是否存在逻辑代码块:if (wpc ! null wpc.hasThread()) {try {//需要启动的页面所在进程存在,就会调用这个方法,这里涉及到App的冷启动和热启动realStartActivityLocked(r, wpc, andResume, checkConfig);return;} catch (RemoteException e) {}knownToBeDead true;
}
/**这里省略其他代码*/
//如果需要启动的页面的进程还不存在,我们需要去创建该页面所在的进程,也就是创建app进程
mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? top-activity : activity);realStartActivityLocked(r, wpc, andResume, checkConfig); ActivityStackSupervisor.java 这里我们是在同一个app中启动页面,所以进程已经存在了,所以进入上面的if代码块,执行realStartActivityLocked()方法构建ClientTransaction对象 final ClientTransaction clientTransaction ClientTransaction.obtain( proc.getThread(), r.appToken); (ATMS)mService.getLifecycleManager().scheduleTransaction(clientTransaction); ActivityStackSupervisor.java 在(AMS)ATMS中去处理ClientTransation scheduleTransaction() ClientLifecycleManager.javaschedule() ClientTransaction.java (IApplicationThread)mClient.scheduleTransaction(this);这里的IApplicationThread是ActivityThread的内部类ApplicationThread,而this就是当前封装的ClientTransaction对象,所以最终会调用到ActivityThread.ApplicationThread类中的scheduleTransaction()方法. scheduleTransaction() ActivityThread.ApplicationThread ActivityThread.this.scheduleTransaction(transaction); 这个方法内部会调用ActivityThread的scheduleTransaction(),这个类没有实现scheduleTransaction方法,是由他的父类ClientTransactionHandler来实现的scheduleTransaction()方法. scheduleTransaction() ClientTransactionHandler.java sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction); IBinder(ActivityThread.Application继承自IBinder的Stub类)是在子线程中,这个方法中会通过Handler发送一条消息交给主线程去处理,具体的处理这条消息的地方是在子类ActivityThread中完成的. (TransactionExecutor)mTransactionExecutor.execute(transaction) ActivityThread.javaexecute() TransactionExecutor.java 最终在这个方法中去管理我们Activity的生命周期//这里transaction是ClientTransaction,
//他是从IBinder子线程传递给ActivityThread主线程的一条消息
executeCallbacks(transaction);
executeLifecycleState(transaction);executeCallbacks(transaction) TransactionExecutor.java item.execute(mTransactionHandler, token, mPendingActions); TransactionExecutor.java 这个方法会执行到LaunchActivityItem的execute方法 execute() LaunchActivityItem.java 这个方法中会构建一个ActivityClientRecord,这是ActivityThread的一个内部类,代码如下: ActivityClientRecord r new ActivityClientRecord(...); (ClientTransactionHandler)client.handleLaunchActivity(r, pendingActions, null); LaunchActivityItem.java 最终会交给ClientTransactionHandler的实现类ActivityThread来处理handleLaunchActivity()方法. handleLaunchActivity() ActivityThread.javaActivity a performLaunchActivity(r, customIntent); ActivityThread.java 通过Instrumentation来创建一个Activity,实现方式是通过反射 activity mInstrumentation.newActivity(cl, component.getClassName(), r.intent);获取到我们在ActivityThread.ApplicationThread中通过bindApplication()方法创建的Application对象调用activity.attach()方法,这个方法会为我们的Activity创建PhoneWindow,赋值mUiThread、mMainThread、mApplication、mIntent、mActivityInfo等.然后执行Activity的onCreate生命周期 mInstrumentation.callActivityOnCreate(activity, r.state);将ActivityClientRecord中的生命周期状态设置为onCreate, (ActivityThread.ActivityClientRecord)r.setState(ON_CREATE); executeLifecycleState(transaction) TransactionExecutor.java cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction); 这个方法中,会通过计算,去执行上面executeCallbacks(transaction)方法最后执行到的ON_CREATE生命周期,与ON_RESUME生命周期之间的生命周期方法,也就是ON_START生命周期方法.lifecycleItem.execute(mTransactionHandler, token, mPendingActions); 这个方法会去执行ResumeActivityItem中的execute()方法. execute() ResumeActivityItem.javahandleResumeActivity() ClientTransactionHandler 最终是交给他的实现类ActivityThread来执行handleResumeActivity方法 handleResumeActivity() ActivityThread.javaperformResumeActivity(token, finalStateRequest, reason); ActivityThread.java(ActivityThread.ActivityClientRecord)r.activity.performResume(r.startsNotResumed, reason); ActivityThread.ActivityClientRecord.ActivitymInstrumentation.callActivityOnResume(this); Activity.javaactivity.onResume(); Instrumentation.javaonResume() Activity.java 总结: 我们通过ATMS.LocalService的startActivityAsUser()方法作为入口去启动一个新的页面Activity;然后通过ActivityStarter去解析设置的参数,并将我们要启动的Activity封装成一个ActivityRecord,然后通过ActivityStarter执行当前Activity的onPause生命周期;然后通过ActivityStackSupervisor(Activity栈的管理类)调用startSpecificActivity方法去启动指定的页面,这个方法中会判断启动页面的进程是否存在;如果Activity所在进程不存在,则会去创建App进程;若启动的Activity所在进程存在,则调用realStartActivityLocked()方法去启动这个页面,这个方法中会构建ClientTransaction对象,作为一条消息从子线程ApplicationThread发送给主线程ActivtyThread去处理; 最终将这个消息中的ClientTransaction对象交给TransactionExecutor的execute()方法去处理,这个execute方法中包含了两个方法,分别处理LAUNCH事件和ONRUME事件;LAUNCH事件最终会执行到ON_CREATE生命周期;而在执行ON_RESUME生命周期前,会有一个方法计算这ON_CREATE和ON_RESUME之间的生命周期ON_START,并执行ON_START生命周期方法;最终完成了启动页面Activity的onCreate、onStart和onResume生命周期方法的执行. 扩展: 执行Activity的生命周期方法最终会交给ActivityThread,具体的实现是由Instrumentaction类来完成的,他会执行Activity和Application的生命周期方法. Activity启动过程中的一些工具类
ActivityStarter 用于启动Activity,并解析Activity启动时的参数,这个类中包含了一个内部类DefaultFactory,这个内部类里面包含了一些属性:ActivityStartController、ActivityTaskManagerService、ActivityStackSupervisor和ActivityStartInterceptor,在构造函数中给这些变量赋值,从而可以通过这个内部类的实例获取到这些参数的值;ActivityStarterControler ActivityStarter的控制器,用于创建ActivityStarter;ATMS中包含了一个ActivityStartController成员变量ActivityRecord 在底层每一个Activity都被封装成了一个个的ActivityRecord,这个对象中会包含了我们Activity的相关信息ActivityStack 这是一个栈,用于管理我们app的所有Activity,也就是管理所有的ActivityRecordActivityStackSupervisor 这是Activity栈的监管器ClientTransaction ClientTransaction是用于跨进程通信的事务,Activity栈的监管器ActivityStackSupervisor会被封装成一个事务. 这个类包含了一些属性: List mActivityCallbacks:要启动的Activity要执行的生命周期集合,如:onCreate、onStart和onResumeActivityLifecycleItem mLifecycleStateRequest:要启动的Activity最终停留在哪个生命周期上,如:onResumeIApplicationThread mClient:app进程的IBinder对象?IBinder mActivityToken:Activity的IBinder对象?
