前言

對於Android開發，幹上幾年後，都要進階，或者直接轉行了。如果你還在幹Android，想要進階對Framework的瞭解是必不可少的過程，下面就開始進入今天的主題吧。

我們知道，對於任何程序語言而言，入口一般都是main函數。

那Android的程序入口在哪呢？他的main函數是怎麼啓動起來的呢？

可能熟悉Android的同學，知道一個應用程序的入口在ActivityThread中，那有個問題，ActivityThread中的main函數是何時被誰被調用的呢？

將從本文中找到以上答案，如果已經熟悉了此過程的同學，可以在溫習一下。

Android架構

Android 平臺的基礎是 Linux 內核。Android Runtime (ART/Dalvik) 依靠 Linux 內核來執行底層功能，例如線程和低層內存管理等。

而在Android Runtime之上就是我們經常接觸的Java API Framework層，如下圖是Android的系統架構圖

今天的主題不是此架構圖的各個部分解釋，而是離應用層更近的Framework層啓動過程分析。

Android Framework概述

如果我們這裏拋開Android架構圖，那狹義的Framewrok主要包含那些內容呢？

按我的理解，可以分爲三個部分服務端，客戶端，和依賴Linux底層能力的驅動部分。

服務端

主要是ActivityManagerService（AMS）， WindowManagerService（WMS），PackageM anerService（PMS）

AMS 主要用於管理所有應用程序的Activity
WMS 管理各個窗口，隱藏，顯示等
PMS 用來管理跟蹤所有應用APK，安裝，解析，控制權限等.

還有用來處理觸摸消息的兩個類KeyInputQueue和InputDispatchThread，一個用來讀消息，一個用來分發消息.

客戶端

主要包括ActivityThread，Activity，DecodeView及父類View，PhoneWindow，ViewRootImpl及內部類W等

ActivityThread主要用來和AMS通訊的客戶端，Activity是我們編寫應用比較熟悉的類
後面幾個類的介紹，可以參考我的另一篇博客 Android 繪製原理淺析【乾貨】

依賴Linux底層能力的驅動

主要是SurfaceFlingger（SF）和Binder驅動

每一個窗口都對應一個Surface，SF驅動的作用就是把每一個Surface顯示到同一個屏幕上
Binder 內核驅動的作用，就是爲上面的服務端和客戶端(或者服務端和服務端之間)，提供IPC通訊用的。

Zygote

系統中運行的第一個Dalvik虛擬機程序叫做zygote，該名稱的意義是“一個卵”，，因爲接下來的所有 Dalvik虛擬機進程都是通過這個“卵” 孵化出來的。

zygote進程中包含兩個主要模塊，分別如下：

Socket服務端。該 Socket服務端用於接收啓動新的Dalvik進程的命令。
Framework共享類及共享資源。當zygote進程啓動後，會裝載一些共享的類及資源，其中共享類是在preload-classes文件中被定義，共享資源是在preload-resources中被定義。因爲zygote進程用於孵化出其他Dalvik進程，因此，這些類和資源裝載後，新的Dalvik進程就不需要再裝載這些類和資源了，這也就是所謂的共享。

zygote進程對應的具體程序是app_rocess,該程序存在於system/bin目錄下，啓動該程序的指令是
在 init.rc中進行配置的。

Zygote 有️兩個優秀的特點

每fork出的一個進程都是一個Dalvik虛擬機，獨立的進程可以防止一個程序的崩潰導致所有程序都崩潰，這種虛擬機類似Java虛擬機，對於程序員來說，可以直接使用Java開發應用
zygote進程預先會裝載共享類和共享資源，這些類及資源實際上就是SDK中定義的大部分類和資源。因此，當通過zygote孵化出新的進程後，新的APK進程只需要去裝載A PK 自身包含的類和資源即可，這就有效地解決了多個APK共享Framework資源的問題。

SystemServer

zygote孵化出的第一個Dalvik進程叫做SystemServer，SystemServer僅僅是該進程的別名，而該進程具體對應的程序依然是app_process，因爲SystemServer是從app_process中孵化出來的。

SystemServer中創建了一個Socket客戶端，並有AmS負責管理該客戶端，之後所有的Dalvik進程都將通過該Socket客戶端間接被啓動。當需要啓動新的APK進程時，AmS中會通過該Socket客戶端向 zygote進程的Socket服務端發送一個啓動命令，然後 zygote會孵化出新的進程。上面提到的服務端，AMS，PMS，WMS等都是在SystemServer中啓動的.

Android Framework 源頭

操作系統的一般啓動流程，分爲三個步驟

開機通電後，加載bootloader程序
操作系統內核初始化
執行第一個應用程序

Android 系統是基於Linux 內核Kernel，前面Linux bootloader這裏不做介紹，直接介紹操作系統內核初始化，在這個時候，它會加載init.rc文件.

init.rc文件

在Android根目錄下面，可以直接找到init.rc

generic_x86:/ # ls
acct     bin        cache   config data         dev init            init.rc              init.usb.rc      lost+found mnt oem  product sdcard  sys    ueventd.rc 
adb_keys bugreports charger d      default.prop etc init.environ.rc init.usb.configfs.rc init.zygote32.rc metadata   odm proc sbin    storage system vendor

打開init.rc

generic_x86:/ # cat init.rc
# ..... 省略其他
 # Now we can start zygote for devices with file based encryption
trigger zygote-start

# It is recommended to put unnecessary data/ initialization from post-fs-data
# to start-zygote in device's init.rc to unblock zygote start.
on zygote-start 
    # A/B update verifier that marks a successful boot.
    exec_start update_verifier_nonencrypted
    start netd
    start zygote
    start zygote_secondary

on property:vold.decrypt=trigger_restart_framework
    stop surfaceflinger
# 啓動SF
    start surfaceflinger  
    
# ..... 省略其他 media(媒體)  network（網絡）等啓動

也就是在 init.rc時，啓動Android 內核。

app_process

Android 內核也是main方法開始，他的main方法在 frameworks/base/cmds/app_process/app_main.cpp下

int main(int argc, char* const argv[])
{
    ...
    //初始化AndroidRuntime
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    
    bool zygote = false;
    bool startSystemServer = false;
    bool application = false;
    String8 niceName;
    String8 className;

    // 根據參數具體判斷啓動那個服務
    ++i;  // Skip unused "parent dir" argument.
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {
            zygote = true;
            niceName = ZYGOTE_NICE_NAME;
        } else if (strcmp(arg, "--start-system-server") == 0) {
            startSystemServer = true;
        } else if (strcmp(arg, "--application") == 0) {
            application = true;
        } else if (strncmp(arg, "--nice-name=", 12) == 0) {
            niceName.setTo(arg + 12);
        } else if (strncmp(arg, "--", 2) != 0) {
            className.setTo(arg);
            break;
        } else {
            --i;
            break;
        }
    }
    if (!className.isEmpty()) {
        args.add(application ? String8("application") : String8("tool"));
        runtime.setClassNameAndArgs(className, argc - i, argv + i);
    }else{
        ....
        //啓動SystemServer
        if (startSystemServer) {
            args.add(String8("start-system-server"));
        }
    }
    ....
     if (zygote) {
       //啓動Zygote
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else if (className) {
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    } else {
        fprintf(stderr, "Error: no class name or --zygote supplied.\n");
        app_usage();
        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
    }
}

在這個Main方法中，先初始化了AppRuntime，他的父類是AndroidRuntime。然後我們看到了啓動了Java類ZygoteInit。

那c++代碼裏怎麼啓動Java類呢，我們繼續看 start方法

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
   ...
   //啓動Java虛擬機
     if (startVm(&mJavaVM, &env, zygote, primary_zygote) != 0) {
        return;
    }
    ...
    //找到Java 裏面的Main方法
     jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
            /* keep going */
        } else {
        //執行Main方法
            env->CallStaticVoidMethod(startClass, startMeth, strArray);
    }
    ....    
}

可以看到最後先創建了Java虛擬機，調用了Java的main方法，是不是感覺有些熟悉感了。

ZygoteInit

上面介紹到，會啓動Java的ZygoteInit類，那他裏面幹了些什麼呢？我們來看一下關鍵代碼，還是從Main方法開始

//ZygoteInit.java
  public static void main(String argv[]) {
    ZygoteServer zygoteServer = new ZygoteServer();
    ZygoteHooks.startZygoteNoThreadCreation();
    
    //創建socket
    zygoteServer.createZygoteSocket(socketName);
    Zygote.createBlastulaSocket(blastulaSocketName);
    
    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
    } else {
        Zygote.resetNicePriority();
    }
    
    //fork SystemServer進程
    if (startSystemServer) {
        Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
        // child (system_server) process.
        if (r != null) {
            r.run();
            return;
        }
    }

    //等待Socket的接入
    if (caller == null) {
        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);
    }

註釋寫了大概Zygote 啓動裏面的初始化內容

創建Socket
加載系統資源
啓動SystemServer
runSelectLoop 等待socket接入，開始執行fork新的進程.

SystemServer

下面繼續看SystemServer 啓動的過程，從Main方法開始

//SystemServer.java
   /**
     * The main entry point from zygote.
     */
    public static void main(String[] args) {
        new SystemServer().run();
    }

很簡單，創建一個自己的對象，並執行run方法,看一下run方法

private void run() {
    ...
    if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
        Slog.w(TAG, "System clock is before 1970; setting to 1970.");
        SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
    }
            
    VMRuntime.getRuntime().clearGrowthLimit();
    // The system server has to run all of the time, so it needs to be
    // as efficient as possible with its memory usage.
    VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);

    android.os.Process.setThreadPriority(
                android.os.Process.THREAD_PRIORITY_FOREGROUND);
    android.os.Process.setCanSelfBackground(false);
    Looper.prepareMainLooper();
    
   // Create the system service manager.
    mSystemServiceManager = new SystemServiceManager(mSystemContext);
    mSystemServiceManager.setStartInfo(mRuntimeRestart,
            mRuntimeStartElapsedTime, mRuntimeStartUptime);
    LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);

   try {
        traceBeginAndSlog("StartServices");
        startBootstrapServices();
        startCoreServices();
        startOtherServices();
        SystemServerInitThreadPool.shutdown();
    } catch (Throwable ex) {
           Slog.e("System", "******************************************");
            Slog.e("System", "************ Failure starting system services", ex);
            throw ex;
    } finally {
        traceEnd();
    }
    
    Looper.loop();
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

run方法裏面主要進行了設置手機時間，設置虛擬機內存大小，創建消息循環Looper,創建SystemServiceManager等，最主要的是啓動了各類服務，我們接着看一下startBootstrapServices ，startCoreServices，startOtherServices方法

private void startBootstrapServices() {
    Installer installer = mSystemServiceManager.startService(Installer.class);
    mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
    
    mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);
    ....
}

private void startCoreServices() {
    ...
     mSystemServiceManager.startService(BatteryService.class);
     ...
}

 private void startOtherServices() {
        final Context context = mSystemContext;
        VibratorService vibrator = null;
        DynamicAndroidService dynamicAndroid = null;
        IStorageManager storageManager = null;
        NetworkManagementService networkManagement = null;
        IpSecService ipSecService = null;
        NetworkStatsService networkStats = null;
        NetworkPolicyManagerService networkPolicy = null;
        ConnectivityService connectivity = null;
        NsdService serviceDiscovery= null;
        WindowManagerService wm = null;
        SerialService serial = null;
        NetworkTimeUpdateService networkTimeUpdater = null;
        InputManagerService inputManager = null;
        TelephonyRegistry telephonyRegistry = null;
        ConsumerIrService consumerIr = null;
        MmsServiceBroker mmsService = null;
        HardwarePropertiesManagerService hardwarePropertiesService = null;
        ....
}

在這些方法中啓動了，我們的核心服務，和常用服務。代碼中也可以看到AMS，PMS，WMS等相關服務.

Launcher啓動介紹

一般服務啓動完成後，就會想繼調用systemReady()方法。
在SysytemServer startOtherServices中看到一個監聽回調

mActivityManagerService.systemReady(() -> {
  try {
        startSystemUi(context, windowManagerF);
    } catch (Throwable e) {
        reportWtf("starting System UI", e);
    }
  }
}

static final void startSystemUi(Context context, WindowManagerService windowManager) {
        Intent intent = new Intent();
        intent.setComponent(new ComponentName("com.android.systemui",
                    "com.android.systemui.SystemUIService"));
        intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
        //Slog.d(TAG, "Starting service: " + intent);
        context.startServiceAsUser(intent, UserHandle.SYSTEM);
        windowManager.onSystemUiStarted();
}

而Ams啓動完成後，顯示Launcher

//AMS.java
 public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
 ...
     startHomeActivityLocked(currentUserId, "systemReady");
     //
     mStackSupervisor.resumeFocusedStackTopActivityLocked();
 ...
 }

其實到這裏大致流程就介紹完了，但是文章開始的ActivityThread的main方法是何時被調用的，還沒回答，這裏不詳細展開，簡略回答一些.

ActivityThread的main方法如何被調用的？

AMS是管理Activity的啓動結束等，查看AMS代碼，噹噹前啓動的APP沒有創建進程時，會最終調用到ZygoteProcess，然後向 Zygote發送一個socket請求。

resumeTopActivityLocked -> startProcessLocked -> Process.start() -> ZygoteProcess.start() -> ZygoteProcess.startViaZygote() —> ZygoteProcess.zygoteSendArgsAndGetResult()

接下來，看一下大致代碼

//AMS.java
private final boolean startProcessLocked(ProcessRecord app, String hostingType,
            String hostingNameStr, boolean disableHiddenApiChecks, String abiOverride) {
            //這裏entryPoint爲ActivityThread
     final String entryPoint = "android.app.ActivityThread";

    return startProcessLocked(hostingType, hostingNameStr, entryPoint, app, uid, gids,
                    runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet, invokeWith,
                    startTime);    
}

//ZygoteProcess.java
private Process.ProcessStartResult startViaZygote(final String processClass,... ){
    ArrayList<String> argsForZygote = new ArrayList<String>();
    argsForZygote.add("--runtime-args");
    argsForZygote.add("--setuid=" + uid);
    argsForZygote.add("--setgid=" + gid);
    argsForZygote.add("--runtime-flags=" + runtimeFlags);
    argsForZygote.add("--target-sdk-version=" + targetSdkVersion);
    if (startChildZygote) {
        argsForZygote.add("--start-child-zygote");
    }
    argsForZygote.add(processClass);
    synchronized(mLock) {
        return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),
                                              useBlastulaPool,
                                              argsForZygote);
    }
}

//發起Socket請求，給Zygote
private static Process.ProcessStartResult zygoteSendArgsAndGetResult(
        ArrayList<String> args,..){
    blastulaSessionSocket = zygoteState.getBlastulaSessionSocket();

    final BufferedWriter blastulaWriter = new BufferedWriter(
            new OutputStreamWriter(blastulaSessionSocket.getOutputStream()),
                                Zygote.SOCKET_BUFFER_SIZE);
    final DataInputStream blastulaReader =
    new DataInputStream(blastulaSessionSocket.getInputStream());
    blastulaWriter.write(msgStr);
    blastulaWriter.flush();
    ...
}

最終 Zygote收到請求調用ZygoteInit中zygoteinit方法

//ZygoteInit.java
 public static final Runnable zygoteInit(int targetSdkVersion, String[] argv,
            ClassLoader classLoader) {
        if (RuntimeInit.DEBUG) {
            Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
        }

        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
        RuntimeInit.redirectLogStreams();

        RuntimeInit.commonInit();
        ZygoteInit.nativeZygoteInit();
        return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
    }

在 RuntimeInit中findStaticMain，最後在ZygoteInit中執行最終返回的這個Runnable,達到調用main方法的目的.

protected static Runnable applicationInit(int targetSdkVersion, String[] argv,
            ClassLoader classLoader) {
        nativeSetExitWithoutCleanup(true);
        VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);
        VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);
        final Arguments args = new Arguments(argv);
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        return findStaticMain(args.startClass, args.startArgs, classLoader);
    }

protected static Runnable findStaticMain(String className, String[] argv,
            ClassLoader classLoader) {
        ..
        m = cl.getMethod("main", new Class[] { String[].class });
        return new MethodAndArgsCaller(m, argv);
    }

總結

如果你都看到這了，希望幫忙點個贊，謝謝啦。
因爲本人水平有限，各路大佬如看到文中有錯誤，歡迎指出，在此表示感謝。

Android Framework啓動流程淺析

前言

Android架構

Android Framework概述

服務端

客戶端

依賴Linux底層能力的驅動

Zygote

SystemServer

Android Framework 源頭

init.rc文件

app_process

ZygoteInit

SystemServer

Launcher啓動介紹

ActivityThread的main方法如何被調用的？

總結

推薦閱讀

參考書籍

微服務實踐之使用 Visual Studio 2022 調試Dapr 應用程序

wpf附加屬性理解 WPF附加屬性

Android Gradle 學習筆記整理

Android OKHttp 可能你從來沒用過的攔截器【實用推薦】

如何優雅的處理Android 的OnActivityResult，RequestPermissions

Flutter PIP（畫中畫）效果的實現

Flutter 跨端網絡抓包 (以Android 爲例)

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結