四. AMS源码分析

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 ArrayList<ProcessRecord> mLruProcesses = new ArrayList<ProcessRecord>();
  • ProcessRecord是一个进程,里面包含了进程的相关信息.
• startProcess() @ProcessList.java
  • 启动进程
• Process.start() @Process.java
  • Process是一个进程ProcessRecord的工具类,相当于我们平时写的Utils,里面包含了静态方法
• (ZygoteProcess)ZYGOTE_PROCESS.start() @ProcessList.java
  • ZygoteProcess同样是一个工具类,这里会调用到ZygoteProcess.start()方法
• startViaZygote() @ZygoteProcess.java
• zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),zygotePolicyFlags, argsForZygote); @ZygoteProcess.java
• attemptUsapSendArgsAndGetResult(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,如果pid>=0则返回,
          //pid=0表示孩子进程创建成功,pid>0表示zygote进程创建成功,pid=-1表示fork创建进程失败
          result.pid = usapReader.readInt();
          // USAPs can't 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.LocalService
• startProcessLocked() @ActivityManagerService.LocalService
• startProcessLocked() @AMS
  • 这个方法返回值是ProcessRecord
• ProcessRecord proc = mProcessList.startProcessLocked(); @AMS
  • 通过这个方法作为一个入口去启动一个进程,最终返回该进程
  • 这个方法参数中包含了进程名字:processName、应用信息:ApplicationInfo等
  • 这个方法返回值是一个进程ProcessRecord,也就是一个App进程
• startProcessLocked() @ProcessList
  • 这里会调用多个相同名字的startProcessLocked()方法,但是参数不同,最终会调用到startProcess()方法
• Process.ProcessStartResult startResult = startProcess() @ProcessList
• Process.start() @ProcessList
  • 这是进程ProcessRecord的一个工具类,里面是一些静态方法,类似于我们平时写的Utils工具类
• (ZygoteProcess)ZYGOTE_PROCESS.start() @ZygoteProcess.java
  • 这是Zygote进程的一个工具类
  • 包含一个内部类ZygoteState,这个类里面包含一些和ZygoteServer进行socket通信的属性,如:mZygoteSocketAddress、mUsapSocketAddress、mZygoteSessionSocket、mZygoteInputStream、mZygoteOutputWriter等
• ZygoteProcess.start() @ZygoteProcess.java
• startViaZygote() @ZygoteProcess.java
• zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), zygotePolicyFlags, argsForZygote); @ZygoteProcess.java
  • openZygoteSocketIfNeeded(abi):这个方法会去连接ZygoteServer服务器,以便发送和接收socket消息,连接ZygoteServer代码如下:
    zygoteSessionSocket.connect(zygoteSocketAddress); @ZygoteProcess.java
  • argsForZygote:拼接很多参数,在通过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进程,孩子进程的pid=0,zygote进程的pid>0,fork方法最终会调到native层中的fork()方法,这个方法会去调用Linux层里的fork()方法.
  • 在孩子进程创建成功后,pid=0的逻辑判断中会去调用handleChildProc()方法,该方法最终会调用ActivityThread的main函数,流程如下:
• handleChildProc() @ZygoteConnection.java
• ZygoteInit.zygoteInit() @ZygoteConnection.java
  + 这里进入!isZygote的逻辑判断代码块
• RuntimeInit.applicationInit() @RuntimeInit.java
• findStaticMain(args.startClass, args.startArgs, classLoader); @RuntimeInit.java
• return 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;然后根据进程的pid=0去处理孩子进程(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绑定到AMS
    • thread:这是一个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); @ATMS
      • attachApplication() @RootWindowContainer.java
      • RootWindowContainer::startActivityForAttachedApplicationIfNeeded @RootWindowContainer.java
      • (ActivityStackSupervisor)mStackSupervisor.realStartActivityLocked() @RootWindowContainer.java
      • realStartActivityLocked() @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来实现:ClientTransaction
• Application进程拿到ClientTransaction事务,然后去处理ActivityB
• ActivityA:执行onStop生命周期

Activity启动流程详细流程:

• startActivityAsUser() @ATMS.LocalService
• startActivityAsUser() @ATMS
• getActivityStartController().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.java
• startActivityInner() @ActivityStarter.java
  • (ActivityStack)mTargetStack.startActivityLocked()//启动黑白屏页面
• (RootWindowContainer)mRootWindowContainer.resumeFocusedStacksTopActivities() @ActivityStarter.java
• (ActivityStack)focusedStack.resumeTopActivityUncheckedLocked() @RootWindowContainer.java
• resumeTopActivityInnerLocked() @ActivityStack
  • startPausingLocked(userLeaving, false /* uiSleeping */, next);
    执行当前Activity的onPause生命周期,next参数分析:
    ActivityRecord next = topRunningActivity(true);
• (ActivityStackSupervisor)mStackSupervisor.startSpecificActivity(next, true, false); @ActivityStack.java
• startSpecificActivity() @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.java
• schedule() @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.java
• execute() @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.java
    • Activity 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.java
      • handleResumeActivity() @ClientTransactionHandler
        • 最终是交给他的实现类ActivityThread来执行handleResumeActivity方法
      • handleResumeActivity() @ActivityThread.java
      • performResumeActivity(token, finalStateRequest, reason); @ActivityThread.java
      • (ActivityThread.ActivityClientRecord)r.activity.performResume(r.startsNotResumed, reason); @ActivityThread.ActivityClientRecord.Activity
      • mInstrumentation.callActivityOnResume(this); @Activity.java
      • activity.onResume(); @Instrumentation.java
      • onResume() @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,也就是管理所有的ActivityRecord
• ActivityStackSupervisor
  这是Activity栈的监管器
• ClientTransaction
  ClientTransaction是用于跨进程通信的事务,Activity栈的监管器ActivityStackSupervisor会被封装成一个事务.
  这个类包含了一些属性:
  • List mActivityCallbacks:要启动的Activity要执行的生命周期集合,如:onCreate、onStart和onResume
  • ActivityLifecycleItem mLifecycleStateRequest:要启动的Activity最终停留在哪个生命周期上,如:onResume
  • IApplicationThread mClient:app进程的IBinder对象?
  • IBinder mActivityToken:Activity的IBinder对象?