移动架构----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的启动,涉及到的流程梳理完了!

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容