移动架构----AMS流程梳理

整体脑图

AMS整体脑图.png

AMS涉及到的知识点有很多，这里主要记录一下AMS相关的启动流程，主要包括：

Android系统启动
Binder启动
AMS注册服务
Activity启动
代码说明以26版本为例。

1、Android系统启动流程

流程图

系统启动流程图.png

系统启动步骤：

引导程序BootLoader启动。
Linux内核启动。
启动init进程，解析init.rc文件。
Zygote进程启动。
启动Binder线程池，启动SystemServer进程。

启动一系列的服务，放到Binder线程池中。
这里需要注意的是，系统服务与zygote是通过socket进行通信的。
下面结合源代码对以上启动步骤做进一步的说明：

 //Zygoteinit.java    
 public static void main(String argv[]) {
     ZygoteServer zygoteServer = new ZygoteServer();
     ...
     //创建一个Server端的Socket
     zygoteServer.registerServerSocket(socketName);
     ...
     //启动SystemServer进程
     if (startSystemServer) {
         startSystemServer(abiList, socketName, zygoteServer);
     }
     Log.i(TAG, "Accepting command socket connections");
     //开启死循环，等待服务请求
     zygoteServer.runSelectLoop(abiList);
     zygoteServer.closeServerSocket();
   } catch (Zygote.MethodAndArgsCaller caller) {
     caller.run();
   } catch (Throwable ex) {
     Log.e(TAG, "System zygote died with exception", ex);
     zygoteServer.closeServerSocket();
     throw ex;
    }
 }

总体来说，ZogoteInit中的main方法中做了三件我们关心的事：

创建了一个Server端的Socket，用来与后续开启的服务通信。
启动了SystemServer进程，用于开启后续的服务。
开启循环，等待服务请求创建的Socket。

2、Binder启动流程

Binder模型图

binder模型图.png

流程图

binder启动流程图.png

Binder的启动流程对应Android系统启动流程中的ServiceManger创建。对binder驱动的操作主要在native层，这里不做详细的说明，只是简单的图示一下过程。

3、AMS注册服务

流程图

AMS注册流程.png

这里做下说明，图中的客户端进程是指除了SystemServer以外的进程统称为客户端进程。
AMS的注册过程主要也是在native层完成的，主要包括：

服务端初始化
客户端初始化
向binder驱动发送指令，已初始化
binder驱动唤醒ServiceManger服务
注册AMS
binder通知ServiceManager完成注册
ServiceManager向binder驱动生成应答数据
binder驱动唤醒客户端进程，通知客户端AMS注册完成

4、App启动流程

流程图

应用启动流程.png

启动App的时候，AMS通过Socket与Zygote进程进行通信，在Android系统启动流程中会有一个循环，一直等待接收服务发来的请求，当Zygote创建的socket接受到AMS的请求时，最终会调用Zygote的MethodAndArgsCaller方法，在这个方法中最终执行了ActivityThread的main方法，及App的入口方法。
下面用代码加以说明：

//ActivityManagerService.java    
private final void startProcessLocked(ProcessRecord app, String hostingType,
        String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) {
    ...
        if (hostingType.equals("webview_service")) {
            startResult = startWebView(entryPoint,
                    app.processName, uid, uid, gids, debugFlags, mountExternal,
                    app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
                    app.info.dataDir, null, entryPointArgs);
        } else {
            //调用Process中的start方法
            startResult = Process.start(entryPoint,
                    app.processName, uid, uid, gids, debugFlags, mountExternal,
                    app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
                    app.info.dataDir, invokeWith, entryPointArgs);
        }
        ...
}
//Process.java
public static final ProcessStartResult start(final String processClass,
                              final String niceName,
                              int uid, int gid, int[] gids,
                              int debugFlags, int mountExternal,
                              int targetSdkVersion,
                              String seInfo,
                              String abi,
                              String instructionSet,
                              String appDataDir,
                              String invokeWith,
                              String[] zygoteArgs) {
    //调用ZygoteProcess中的start方法
    return zygoteProcess.start(processClass, niceName, uid, gid, gids,
                debugFlags, mountExternal, targetSdkVersion, seInfo,
                abi, instructionSet, appDataDir, invokeWith, zygoteArgs);
}

ZygoteProcess中的start会调用openZygoteSocketIfNeeded与Zygote进程通过socket进行通信：

private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
    ...
    if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
        ...
            //与Zygote进程通信
            primaryZygoteState = ZygoteState.connect(mSocket);
        ...
    }
...
    if (secondaryZygoteState == null || secondaryZygoteState.isClosed()) {
        ...
            //与Zygote进程通信
            secondaryZygoteState = ZygoteState.connect(mSecondarySocket);
        ...
    }
...
}

在Android系统启动流程中有一个死循环一直在等待Sokcet连接，当收到AMS发来的请求后最后会执行Zygote中的MethodAmdArgsCaller类中的run方法：

public static class MethodAndArgsCaller extends Exception
        implements Runnable {
    /** method to call */
    private final Method mMethod;

    /** argument array */
    private final String[] mArgs;

    public MethodAndArgsCaller(Method method, String[] args) {
        mMethod = method;
        mArgs = args;
    }

    public void run() {
        ...
            //这里其实就是ActivityThread的main方法
            mMethod.invoke(null, new Object[] { mArgs });
        ...
    }
}

5、Activity启动流程

Activity启动流程.png

Activity启动流程包括：

AMS发送请求，最终调用ApplicationThread中的scheduleReceiver
ApplicationThread发送消息
ActivityThread处理消息
调用handlelaunchActivity

调用Activity.onCreate
当发送消息为LAUNCH_ACTIVITY时，会执行：

//ActivityThread.java
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
 ...
  Activity a = performLaunchActivity(r, customIntent);
  ...
}
 
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
          ...
          if (r.isPersistable()) {//21版本增加的支持数据持久化标识，用于关机重启数据恢复
              //调用Activity中的performCreate
              mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
          } else {
              //调用Activity中的performCreate
              mInstrumentation.callActivityOnCreate(activity, r.state);
          }
         ...
}
//Instrumentation.java
public void callActivityOnCreate(Activity activity, Bundle icicle) {
  prePerformCreate(activity);
  //调用Activity中的performCreate
  activity.performCreate(icicle);
  postPerformCreate(activity);
}
 //Activity.java
 final void performCreate(Bundle icicle) {
   restoreHasCurrentPermissionRequest(icicle);
   //调用Activity的onCreate，生命周期开始。
   onCreate(icicle);
   mActivityTransitionState.readState(icicle);
   performCreateCommon();
 }

到这里，从Android系统到Activity的启动，涉及到的流程梳理完了！