Android Framework - 学习起步

前言

作为一名合格的 Android 开发,需要学习 Framework 知识,来解决 App 稳定性相关的问题

Framework 的源码学习一般由 init.rc 开始看起,因为它是一个 Android 系统启动必备的重要脚本,之后的几大系统进程都是由它启动的,比如 zygote,systemserver 等,这里主要记录一些基本概念,以及 Zygote 启动的源码分析

Binder 原理是相对较难的一个部分,先看其他系统源码,等功力足够时再拜读

init.rc

init 启动的四个重要进程如下:

  1. Zygote 创建 App 的进程
  2. ServiceManager 负责c/s通信管理的进程
  3. SurfaceFlingler 显示渲染服务
  4. Media 多媒体服务

SystemServer

Zygote 进程启动时,会顺带启动 SystemServer 进程

fork 是通过 native 方法调用,返回 pid 给到 Java 层

PMS

负责安装卸载 app,主要用于解析 apk 文件等操作

fork 进程的理解

我们都知道新开启的 App 进程都是由 Zygote.fork 出来的,那 fork 到底是个什么操作呢

首先 fork 是叉子的意思,我们所提及的 fork 实际为 native 层的 fork() 函数,当执行该函数时,会对父进程进行一次拷贝,拷贝完成过后,但用户内存空间是彼此独立,从此刻开始,开始各走各的

fork() 调用一次,返回两次,这是特性

  • AMS 和 Zygote 间是怎样通信的

AMS 通过 Socket 来通知 Zygote 进程,发送过程是怎样的 AMS -> Zygote 通过 socket 请求,Zygote 调用 fork() 方法,成功后返回给 AMS,新进程创建后调用 AtivityThread.main()

对于 epoll 的理解

全名是 EventPoll ,poll 是轮询的意思,是一个事件通知机制,性能上比较好,Handler 底层的事件唤醒也是用这玩意,具体是怎么实现的,不太清楚,先挖个坑,后面找个时间拜读一下源码

Zygote 启动过程

首先 Android 系统的第一个进程为 init 进程,负责解析执行 init.rc ,并且启动了 Zygote 进程

接下来通过阅读源码,分析一下 Zygote 的启动过程,从 AndroidRuntime,cpp 的 start() 开始看起

scss 复制代码
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    const char* rootDir = getenv("ANDROID_ROOT")
    // 创建虚拟机
    jni_invocation.Init(NULL);
    JNIEnv* env;
    if (startVm(&mJavaVM, &env, zygote, primary_zygote) != 0) {
        return;
    }
    onVmCreated(env);
     // 传入 ZygoteInit 的类路径
    // 当前线程为虚拟机的主线程
    char* slashClassName = toSlashClassName(className != NULL ? className : "");
    jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
        /* keep going */
    } else {
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");
        if (startMeth == NULL) {
            /* keep going */
        } else {
            env->CallStaticVoidMethod(startClass, startMeth, strArray);
#if 0
            if (env->ExceptionCheck())
                threadExitUncaughtException(env);
#endif
        }
    }
    //执行到这里虚拟机退出,应该对应着进程销毁
    free(slashClassName);
    ALOGD("Shutting down VM\n");
}

通过 native 创建了虚拟机实例,然后通过 JNI 调用 ZygoteInit ,开始到 Java 层的逻辑了

  • Java 层
scss 复制代码
// ZygoteInit.class
  public static void main(String[] argv) {
        ZygoteServer zygoteServer = null;
        // Mark zygote start. This ensures that thread creation will throw
        // an error.
        ZygoteHooks.startZygoteNoThreadCreation();
        // Zygote goes into its own process group.
        try {
            Os.setpgid(0, 0);
        } catch (ErrnoException ex) {
            throw new RuntimeException("Failed to setpgid(0,0)", ex);
        }
        Runnable caller;
        try {
            // 开启 DDMMS 
            RuntimeInit.preForkInit();
            boolean startSystemServer = false;
            String zygoteSocketName = "zygote";
            String abiList = null;
            boolean enableLazyPreload = false;
            // 判断各种配置开关
            for (int i = 1; i < argv.length; i++) {
                if ("start-system-server".equals(argv[i])) {
                    startSystemServer = true;
                } else if ("--enable-lazy-preload".equals(argv[i])) {
                    enableLazyPreload = true;
                } else if (argv[i].startsWith(ABI_LIST_ARG)) {
                    abiList = argv[i].substring(ABI_LIST_ARG.length());
                } else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
                    zygoteSocketName = argv[i].substring(SOCKET_NAME_ARG.length());
                } else {
                    throw new RuntimeException("Unknown command line argument: " + argv[i]);
                }
            }
            // 判断 SocketName 是否为 "zygote"
            final boolean isPrimaryZygote = zygoteSocketName.equals(Zygote.PRIMARY_SOCKET_NAME);
            if (!isRuntimeRestarted) {
                if (isPrimaryZygote) {
                    FrameworkStatsLog.write(FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED,
                            BOOT_TIME_EVENT_ELAPSED_TIME__EVENT__ZYGOTE_INIT_START,
                            startTime);
                } 
                
                // 判断 SocketName 是否为 "zygote_secondary"
                else if (zygoteSocketName.equals(Zygote.SECONDARY_SOCKET_NAME)) {
                    FrameworkStatsLog.write(FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED,
                            BOOT_TIME_EVENT_ELAPSED_TIME__EVENT__SECONDARY_ZYGOTE_INIT_START,
                            startTime);
                }
            }

            if (abiList == null) {
                throw new RuntimeException("No ABI list supplied.");
            }

            //是否预加载(具体为预加载 class / 类加载器 / 资源文件等)
            if (!enableLazyPreload) {
                bootTimingsTraceLog.traceBegin("ZygotePreload");
                EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
                        SystemClock.uptimeMillis());
                preload(bootTimingsTraceLog);
                EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
                        SystemClock.uptimeMillis());
                bootTimingsTraceLog.traceEnd(); // ZygotePreload
            }

            // Do an initial gc to clean up after startup
            bootTimingsTraceLog.traceBegin("PostZygoteInitGC");
            // 触发一次 gc (具体由 ZygoteHooks执行)
            gcAndFinalize();
            bootTimingsTraceLog.traceEnd(); // PostZygoteInitGC

            bootTimingsTraceLog.traceEnd(); // ZygoteInit

            Zygote.initNativeState(isPrimaryZygote);

            ZygoteHooks.stopZygoteNoThreadCreation();
            // ZygoteServer 做为 Socket 服务端,创建 socket 连接
            zygoteServer = new ZygoteServer(isPrimaryZygote);

            // 创建 SystemSerrver 进程,通过 Zygote fork 出来,之后 SystemSerrver 负责创建 AMS 等重要服务
            if (startSystemServer) {
                Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);

                // {@code r == null} in the parent (zygote) process, and {@code r != null} in the
                // child (system_server) process.
                if (r != null) {
                    r.run();
                    return;
                }
            }

            Log.i(TAG, "Accepting command socket connections");

            // The select loop returns early in the child process after a fork and
            // loops forever in the zygote.
            // 轮询执行,先不关注这块
            caller = zygoteServer.runSelectLoop(abiList);
        } catch (Throwable ex) {
            Log.e(TAG, "System zygote died with exception", ex);
            throw ex;
        } finally {
            if (zygoteServer != null) {
                zygoteServer.closeServerSocket();
            }
        }

        // We're in the child process and have exited the select loop. Proceed to execute the
        // command.
        if (caller != null) {
            caller.run();
        }
    }

总结一下 Zygote 的启动过程:

  1. 解析 init.rc 创建 AppRunTime
  2. 执行 AndroidRuntime.Start()
  3. JNI 调用 ZygoteInit.main(),转到 Java 层了
  4. 创建 Socket 服务端,准备相应客户端的请求
  5. 预加载
  6. 通过 fork 的方式启动 SystemServer 进程
  7. 开启轮询
相关推荐
花花鱼8 小时前
android studio 设置让开发更加的方便,比如可以查看变量的类型,参数的名称等等
android·ide·android studio
alexhilton9 小时前
为什么你的App总是忘记所有事情
android·kotlin·android jetpack
AirDroid_cn13 小时前
OPPO手机怎样被其他手机远程控制?两台OPPO手机如何相互远程控制?
android·windows·ios·智能手机·iphone·远程工作·远程控制
尊治13 小时前
手机电工仿真软件更新了
android
xiangzhihong816 小时前
使用Universal Links与Android App Links实现网页无缝跳转至应用
android·ios
车载应用猿16 小时前
基于Android14的CarService 启动流程分析
android
没有了遇见17 小时前
Android 渐变色实现总结
android
雨白19 小时前
Jetpack系列(四):精通WorkManager,让后台任务不再失控
android·android jetpack
mmoyula21 小时前
【RK3568 驱动开发:实现一个最基础的网络设备】
android·linux·驱动开发
sam.li1 天前
WebView安全实现(一)
android·安全·webview