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

整体脑图

AMS整体脑图.png

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

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

1、Android系统启动流程

流程图

系统启动流程图.png

系统启动步骤：

1. 引导程序BootLoader启动。

2. Linux内核启动。

3. 启动init进程，解析init.rc文件。

4. Zygote进程启动。

5. 启动Binder线程池，启动SystemServer进程。

6. 启动一系列的服务，放到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方法中做了三件我们关心的事：

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

2、Binder启动流程

Binder模型图

binder模型图.png

流程图

binder启动流程图.png

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

3、AMS注册服务

流程图

AMS注册流程.png

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

1. 服务端初始化
2. 客户端初始化
3. 向binder驱动发送指令，已初始化
4. binder驱动唤醒ServiceManger服务
5. 注册AMS
6. binder通知ServiceManager完成注册
7. ServiceManager向binder驱动生成应答数据
8. 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的启动，涉及到的流程梳理完了！