前言

在system_server進程啟動的流程中，system_server在啟動其他服務(wù)的流程中，會去調(diào)用AMS的systemReady()方法，上一篇說這部分就會去啟動launcher應(yīng)用和和系統(tǒng)ui，然后這一篇就分析一下launcher應(yīng)用的具體啟動流程。

在系統(tǒng)服務(wù)的引導(dǎo)服務(wù)中，會啟動PMS服務(wù)，PMS服務(wù)會去掃描檢測手機中的系統(tǒng)應(yīng)用和用戶安裝的非系統(tǒng)應(yīng)用，launcher應(yīng)用也是在PMS啟動階段進行掃描，并將其清單文件對應(yīng)的信息解析完成，在后續(xù)調(diào)用AMS的systemReady()方法，launcher應(yīng)用的信息已經(jīng)解析完成了

#ActivityManagerService.java
public void systemReady(final Runnable goingCallback, @NonNull TimingsTraceAndSlog t) {
            t.traceBegin("resumeTopActivities");
            mAtmInternal.resumeTopActivities(false /* scheduleIdle */);
            t.traceEnd();
    }

mAtmInternal就是AMS中持有的ATMS的binder引用，就會執(zhí)行到ATMS的resumeTopActivities

//#ActivityTaskManagerService.java
public void resumeTopActivities(boolean scheduleIdle) {
            synchronized (mGlobalLock) {
              //會執(zhí)行RootWindowContainer的對應(yīng)方法
                mRootWindowContainer.resumeFocusedStacksTopActivities();
                if (scheduleIdle) {
                    mStackSupervisor.scheduleIdle();
                }
            }
        }

//RootWindowContainer.java
boolean resumeFocusedStacksTopActivities(ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
            if (!resumedOnDisplay) {
                final ActivityStack focusedStack = display.getFocusedStack();
                if (focusedStack != null) {
                    //進入這個流程
                    result |= focusedStack.resumeTopActivityUncheckedLocked(target, targetOptions);
                } else if (targetStack == null) {
                    result |= resumeHomeActivity(null /* prev */, "no-focusable-task",
                            display.getDefaultTaskDisplayArea());
                }
            }
        }
        return result;
    }

//ActivityStack.java
//step1
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
        boolean result = false;
        try {
            mInResumeTopActivity = true;
            //執(zhí)行這個方法
            result = resumeTopActivityInnerLocked(prev, options);
            final ActivityRecord next = topRunningActivity(true /* focusableOnly */);
        } finally {
        }

        return result;
    }
//step2
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
      if (!hasRunningActivity) {
            // There are no activities left in the stack, let's look somewhere else.
            //Launcher應(yīng)用進程啟動之前是沒有activity的，會繼續(xù)執(zhí)行
            return resumeNextFocusableActivityWhenStackIsEmpty(prev, options);
        }
}
//step3
private boolean resumeNextFocusableActivityWhenStackIsEmpty(ActivityRecord prev,
            ActivityOptions options) {
        final String reason = "noMoreActivities";
        //launcher應(yīng)用啟動就是執(zhí)行這個關(guān)鍵的resumeHomeActivity方法
            //又回到了RootWindowContainer.java類
        return mRootWindowContainer.resumeHomeActivity(prev, reason, getDisplayArea());
}

//RootWindowContainer.java
ActivityTaskManagerService mService;//成員屬性可以看出這個mService就是ATMS

boolean resumeHomeActivity(ActivityRecord prev, String reason,
            TaskDisplayArea taskDisplayArea) {
        final ActivityRecord r = taskDisplayArea.getHomeActivity();
        final String myReason = reason + " resumeHomeActivity";

            //繼續(xù)調(diào)用執(zhí)行
        return startHomeOnTaskDisplayArea(mCurrentUser, myReason, taskDisplayArea,
                false /* allowInstrumenting */, false /* fromHomeKey */);
}

boolean startHomeOnTaskDisplayArea(int userId, String reason, TaskDisplayArea taskDisplayArea,
            boolean allowInstrumenting, boolean fromHomeKey) {
            //獲取ATMS的startController，去啟動launcher
        mService.getActivityStartController().startHomeActivity(homeIntent, aInfo, myReason,
                taskDisplayArea);
        return true;
    }

通過一系列的狀態(tài)判斷和方法調(diào)用，最終會回到跟activity管理密切相關(guān)的ATMS類，去執(zhí)行ActivityStartController類中的啟動方法

#ActivityStartController.ava
void startHomeActivity(Intent intent, ActivityInfo aInfo, String reason,
            TaskDisplayArea taskDisplayArea) {
            //獲取ActivityStarter的實例，去執(zhí)行execute方法
        mLastHomeActivityStartResult = obtainStarter(intent, "startHomeActivity: " + reason)
                .setOutActivity(tmpOutRecord)
                .setCallingUid(0)
                .setActivityInfo(aInfo)
                .setActivityOptions(options.toBundle())
                .execute();
    }
//通過obtainStarter去獲取一個ActivityStarter實例
ActivityStarter obtainStarter(Intent intent, String reason) {
        return mFactory.obtain().setIntent(intent).setReason(reason);
    }

其他launcher應(yīng)用的啟動會執(zhí)行到ActivityStarter類的execute方法，從類名上看，這就是一個專注于啟動activity的類，跟應(yīng)用開發(fā)的關(guān)系還是很密切，繼續(xù)往后續(xù)代碼看

#ActivityStarter
//step1
int execute() {
        try {
            int res;
            synchronized (mService.mGlobalLock) {
                //上面的邏輯主要是對mRequest參數(shù)進行一些狀態(tài)缺省判斷
                //下一步的主要執(zhí)行邏輯
                res = executeRequest(mRequest);//step2
                return getExternalResult(mRequest.waitResult == null ? res
                        : waitForResult(res, mLastStartActivityRecord));
            }
        } finally {
        }
    }

//step2
private int executeRequest(Request request) {
            //會創(chuàng)建兩個ActivityRecord對象，Activity的啟動是會傳當(dāng)前的context，方便activity的棧的管理
        ActivityRecord sourceRecord = null;//from
        ActivityRecord resultRecord = null;//to
  
            //后續(xù)的執(zhí)行邏輯，前面就是對參數(shù)的各種處理邏輯
            //step3
        mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
                request.voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask,
                restrictedBgActivity, intentGrants);

        return mLastStartActivityResult;
}

//step3
private int startActivityUnchecked() {
        int result = START_CANCELED;
        final ActivityStack startedActivityStack;
        try {
            //step4
            result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
                    startFlags, doResume, options, inTask, restrictedBgActivity, intentGrants);
        } finally {}
  
        return result;
    }

//step4
int startActivityInner() {
   //launcher啟動的關(guān)鍵方法
   mRootWindowContainer.resumeFocusedStacksTopActivities(
                        mTargetStack, mStartActivity, mOptions);
}

//step5
#RootWindowContainer.java
boolean resumeFocusedStacksTopActivities() {
         result = targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
     return result;
}

//step6
#ActivityStack.java
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
   boolean result = false;
   result = resumeTopActivityInnerLocked(prev, options);
     return result;
}

//step7
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
        mStackSupervisor.startSpecificActivity(next, true, false);
}

//step8
#ActivityStackSupervisor.java
void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
        // Is this activity's application already running?
            //這個用來獲取需要啟動的activity的進程，看進程是否存在
        final WindowProcessController wpc =
                mService.getProcessController(r.processName, r.info.applicationInfo.uid);

        boolean knownToBeDead = false;
        if (wpc != null && wpc.hasThread()) {
            try {
                //應(yīng)用進程存在，執(zhí)行這個方法
                realStartActivityLocked(r, wpc, andResume, checkConfig);
                return;
            } catch (RemoteException e) {}
            knownToBeDead = true;
        }
        final boolean isTop = andResume && r.isTopRunningActivity();
        //如果應(yīng)用進程不存在，執(zhí)行這個方法，去通知zygote符合新的進程
        mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
    }

通過上面一些列的方法調(diào)用，最終會執(zhí)行到判斷進程是否存在的啟動Activity的邏輯，這部分跟應(yīng)用進程里面startactivity流程相關(guān)

目前的流程分析是通過system_server進程去啟動launcher進程，那么launcher進程就是不存在的，就會執(zhí)行到ActivityTaskManagerService的startProcessAsync創(chuàng)建進程的方法

#ActivityTaskManagerService.java
void startProcessAsync(ActivityRecord activity, boolean knownToBeDead, boolean isTop,
            String hostingType) {
        try {
            // ATMS lock held.
           //這類會通過handler去發(fā)生一個message
           //message里面攜帶的參數(shù)就是需要執(zhí)行的邏輯
            final Message m = PooledLambda.obtainMessage(ActivityManagerInternal::startProcess,
                    mAmInternal, activity.processName, activity.info.applicationInfo, knownToBeDead,
                    isTop, hostingType, activity.intent.getComponent());
            mH.sendMessage(m);
        } finally {}
    }

當(dāng)應(yīng)用進程不存在的時候，ATMS中會通過handler和messge機制進行消息傳遞，消息的內(nèi)容就是需要執(zhí)行的邏輯(ActivityManagerInternal::startProcess)，那這個就會執(zhí)行到AMS的方法中

#ActivityManagerService
public void startProcess(String processName, ApplicationInfo info, boolean knownToBeDead,
                boolean isTop, String hostingType, ComponentName hostingName) {
            try {
                synchronized (ActivityManagerService.this) {
                    // preempted by other processes before attaching the process of top app.
                    startProcessLocked(processName, info, knownToBeDead, 0 /* intentFlags */,
                            new HostingRecord(hostingType, hostingName, isTop),
                            ZYGOTE_POLICY_FLAG_LATENCY_SENSITIVE, false /* allowWhileBooting */,
                            false /* isolated */, true /* keepIfLarge */);
                }
            } finally {}
        }

//繼續(xù)調(diào)用到這個方法
final ProcessRecord startProcessLocked(String processName,
            ApplicationInfo info, boolean knownToBeDead, int intentFlags,
            HostingRecord hostingRecord, int zygotePolicyFlags, boolean allowWhileBooting,
            boolean isolated, boolean keepIfLarge) {
                    //下一步執(zhí)行
        return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags,
                hostingRecord, zygotePolicyFlags, allowWhileBooting, isolated, 0 /* isolatedUid */,
                keepIfLarge, null /* ABI override */, null /* entryPoint */,
                null /* entryPointArgs */, null /* crashHandler */);
    }

#ProcessList.java
 boolean startProcessLocked() {
         try {
                 //注意這里的傳入?yún)?shù)的全類目，后續(xù)的啟動中會用到  
                 final String entryPoint = "android.app.ActivityThread";

                    //下一步會執(zhí)行startProcess，啟動進程
                final Process.ProcessStartResult startResult = startProcess(hostingRecord,
                        entryPoint, app,
                        uid, gids, runtimeFlags, zygotePolicyFlags, mountExternal, seInfo,
                        requiredAbi, instructionSet, invokeWith, startTime);
                handleProcessStartedLocked(app, startResult.pid, startResult.usingWrapper,
                        startSeq, false);
            } catch (RuntimeException e) {}
  
            return app.pid > 0;
}

//進一步調(diào)用會執(zhí)行到Process.java類的start方法
private Process.ProcessStartResult startProcess() {
                   startResult = Process.start(entryPoint,
                        app.processName, uid, uid, gids, runtimeFlags, mountExternal,
                        app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
                        app.info.dataDir, invokeWith, app.info.packageName, zygotePolicyFlags,
                        isTopApp, app.mDisabledCompatChanges, pkgDataInfoMap,
                        whitelistedAppDataInfoMap, bindMountAppsData, bindMountAppStorageDirs,
                        new String[]{PROC_START_SEQ_IDENT + app.startSeq});
   
 }

#Process.java
public static final ZygoteProcess ZYGOTE_PROCESS = new ZygoteProcess();

public static ProcessStartResult start() {
            //參數(shù)很多就省略了，方便觀看執(zhí)行邏輯
            //會執(zhí)行到ZygoteProcess.java的start方法
        return ZYGOTE_PROCESS.start();
    }

• 這里需要注意，傳入的參數(shù)全類目是"android.app.ActivityThread"

接下來就會執(zhí)行到ZygoteProcess的start()方法

#ZygoteProcess.java
public final Process.ProcessStartResult start(...) {
        try {
            //繼續(xù)執(zhí)行到startViaZygote方法
            return startViaZygote(processClass, niceName, uid, gid, gids,
                    runtimeFlags, mountExternal, targetSdkVersion, seInfo,
                    abi, instructionSet, appDataDir, invokeWith, /*startChildZygote=*/ false,
                    packageName, zygotePolicyFlags, isTopApp, disabledCompatChanges,
                    pkgDataInfoMap, whitelistedDataInfoMap, bindMountAppsData,
                    bindMountAppStorageDirs, zygoteArgs);
        } catch (ZygoteStartFailedEx ex) {
        }
}

 private Process.ProcessStartResult startViaZygote(...){
    ArrayList<String> argsForZygote = new ArrayList<>();
            //跟forkSystemServer一樣，會添加一些的啟動參數(shù)
        argsForZygote.add("--runtime-args");
        argsForZygote.add("--setuid=" + uid);
        argsForZygote.add("--setgid=" + gid);
        argsForZygote.add("--runtime-flags=" + runtimeFlags);
            ...
   
         //進程的名稱屬性
       if (niceName != null) {
            argsForZygote.add("--nice-name=" + niceName);
        }
   
       synchronized(mLock) {
         //設(shè)置完屬性后，就會調(diào)用此方法
         //第一個參數(shù)openZygoteSocketIfNeeded，從名字可以看出是通過socket跟zygote進程通信
         return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),
                                              zygotePolicyFlags,
                                              argsForZygote);
        }
 }

我們前面知道所有的應(yīng)用進程跟system_server進程一樣，都是由zygote進程fork生成的，而且在zygote進程中會有一個socket等待消息的通知去處理生成新的進程，執(zhí)行到這一步，就能跟前面的流程關(guān)聯(lián)起來了

#ZygoteProcess.java
private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
        try {
            attemptConnectionToPrimaryZygote();
                        //primary跟下面的secondary就是zygote流程中提到的64位和32位的兼容模式
            if (primaryZygoteState.matches(abi)) {
                return primaryZygoteState;
            }

            if (mZygoteSecondarySocketAddress != null) {
                attemptConnectionToSecondaryZygote();
                if (secondaryZygoteState.matches(abi)) {
                    return secondaryZygoteState;
                }
            }
        } catch (IOException ioe) {
        }
}

//啟動主位數(shù)zygote連接
private void attemptConnectionToPrimaryZygote() throws IOException {
        if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
            //這里可以看出后續(xù)的執(zhí)行流程就是去調(diào)用connect方法建立socket連接
            primaryZygoteState =
                    ZygoteState.connect(mZygoteSocketAddress, mUsapPoolSocketAddress);
        }
}

//兼容位數(shù)的zygote連接，代碼邏輯跟上面一致
private void attemptConnectionToSecondaryZygote() throws IOException {
        if (secondaryZygoteState == null || secondaryZygoteState.isClosed()) {
            secondaryZygoteState =
                    ZygoteState.connect(mZygoteSecondarySocketAddress,
                            mUsapPoolSecondarySocketAddress);
        }
}

//建立連接
static ZygoteState connect(@NonNull LocalSocketAddress zygoteSocketAddress,
                @Nullable LocalSocketAddress usapSocketAddress)
                throws IOException {

                  //創(chuàng)建當(dāng)前進程的socket對象
            final LocalSocket zygoteSessionSocket = new LocalSocket();

            try {
                //建立連接
                zygoteSessionSocket.connect(zygoteSocketAddress);
                //輸入輸出流對象創(chuàng)建
                zygoteInputStream = new DataInputStream(zygoteSessionSocket.getInputStream());
                zygoteOutputWriter =
                        new BufferedWriter(
                                new OutputStreamWriter(zygoteSessionSocket.getOutputStream()),
                                Zygote.SOCKET_BUFFER_SIZE);
            } catch (IOException ex) {}

            return new ZygoteState(zygoteSocketAddress, usapSocketAddress,
                                   zygoteSessionSocket, zygoteInputStream, zygoteOutputWriter,
                                   getAbiList(zygoteOutputWriter, zygoteInputStream));
        }

通過這一系列的操作就創(chuàng)建好了當(dāng)前進程的Socket對象和輸入輸出流對象，接下來就要通過這個socket通道去進行消息的發(fā)送了，往上回一步，創(chuàng)建socket對象是方法的第一個參數(shù)，就回到對應(yīng)的方法部分

#ZygoteProcess.java
private Process.ProcessStartResult zygoteSendArgsAndGetResult(
            ZygoteState zygoteState, int zygotePolicyFlags, @NonNull ArrayList<String> args)
            throws ZygoteStartFailedEx {
            //處理參數(shù)
        String msgStr = args.size() + "\n" + String.join("\n", args) + "\n";

        if (shouldAttemptUsapLaunch(zygotePolicyFlags, args)) {
            try {
                //執(zhí)行到這個方法
                return attemptUsapSendArgsAndGetResult(zygoteState, msgStr);
            } catch (IOException ex) {}
        }

        return attemptZygoteSendArgsAndGetResult(zygoteState, msgStr);
    }

private Process.ProcessStartResult attemptUsapSendArgsAndGetResult(
            ZygoteState zygoteState, String msgStr)
            throws ZygoteStartFailedEx, IOException {
        try (LocalSocket usapSessionSocket = zygoteState.getUsapSessionSocket()) {
            final BufferedWriter usapWriter =
                    new BufferedWriter(
                            new OutputStreamWriter(usapSessionSocket.getOutputStream()),
                            Zygote.SOCKET_BUFFER_SIZE);
            final DataInputStream usapReader =
                    new DataInputStream(usapSessionSocket.getInputStream());

            //這個地方就是進行消息的寫入和發(fā)送
            usapWriter.write(msgStr);
            usapWriter.flush();

            Process.ProcessStartResult result = new Process.ProcessStartResult();
            result.pid = usapReader.readInt();
          
            if (result.pid >= 0) {
                return result;
            } else {
            }
        }
    }

小結(jié)

到這一步我們從systemServer進程的啟動其他服務(wù)的流程中，走到AMS的systemReady方法，然后AMS里面去一些的調(diào)用啟動topActivity，發(fā)現(xiàn)APP進程不存在，就通過AMS創(chuàng)建socket對象跟Zygote進程連接并發(fā)送消息，在Zygote進程中，我們前面分析了創(chuàng)建了socket通道，并會進入循環(huán)等待消息的到來，到這一步，就需要就分析Zygote進程循環(huán)等待消息后，接收到消息的處理，去fork新的app進程
上面涉及的類比較多，附上對應(yīng)的流程圖

啟動app進程給zygote進程發(fā)消息的流程圖.jpg

#ZygoteInit.java
public static void main(String argv[]) {
    zygoteServer = new ZygoteServer(isPrimaryZygote);
    if (startSystemServer) {
      //之前分析到這，啟動systemserver進程
        Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);  //fork systemserver

       if (r != null) {
          r.run();
          return;
         }
    }

    caller = zygoteServer.runSelectLoop(abiList);  //zygote 進程進入無限循環(huán)，處理請求
}

Runnable runSelectLoop(String abiList) {
     while (true) {
       
            int pollReturnValue;
            try {
                //通過epoll機制進行循環(huán)等待
                pollReturnValue = Os.poll(pollFDs, pollTimeoutMs);  //等到事件到來
            } catch (ErrnoException ex) {
            }
       
           if (pollReturnValue == 0) {

            } else {
             //有消息來了
                boolean usapPoolFDRead = false;

                //注意這里是倒序的，即優(yōu)先處理已建立鏈接的信息，后處理新建鏈接的請求
                while (--pollIndex >= 0) {
                    if ((pollFDs[pollIndex].revents & POLLIN) == 0) {
                        continue;
                    }

                    //server socket 最新加入 fds， 因此這里就是 server socket 收到數(shù)據(jù)
                    if (pollIndex == 0) {
                        // Zygote server socket

                        //收到新的建立通信的請求,建立通信連接
                        ZygoteConnection newPeer = acceptCommandPeer(abiList);
                        //加入到 peers 和 socketFDs,即下一次也開始監(jiān)聽
                        peers.add(newPeer);
                        socketFDs.add(newPeer.getFileDescriptor());

                    } else if (pollIndex < usapPoolEventFDIndex) {   //其他通信連接收到數(shù)據(jù)
                        // Session socket accepted from the Zygote server socket
                        try {
                            ZygoteConnection connection = peers.get(pollIndex);
                            //接收到請求后的具體執(zhí)行邏輯
                            final Runnable command = connection.processOneCommand(this);
                        }
                    }
                }
           }
     }
}

//接下來會執(zhí)行到ZygoteConnection的processOneCommand方法
#ZygoteConnection.java
Runnable processOneCommand(ZygoteServer zygoteServer) {
    int pid;
    //通過forkAndSpecialize去fork出新的進程
    pid = Zygote.forkAndSpecialize(parsedArgs.mUid, parsedArgs.mGid, parsedArgs.mGids,
                parsedArgs.mRuntimeFlags, rlimits, parsedArgs.mMountExternal, parsedArgs.mSeInfo,
                parsedArgs.mNiceName, fdsToClose, fdsToIgnore, parsedArgs.mStartChildZygote,
                parsedArgs.mInstructionSet, parsedArgs.mAppDataDir, parsedArgs.mIsTopApp,
                parsedArgs.mPkgDataInfoList, parsedArgs.mWhitelistedDataInfoList,
                parsedArgs.mBindMountAppDataDirs, parsedArgs.mBindMountAppStorageDirs);
  
   try {
            if (pid == 0) {
                // in child
                zygoteServer.setForkChild();
               //跟systemserver進程一樣，由zygote孵化來的子進程都需要關(guān)閉socket連接，釋放資源
                zygoteServer.closeServerSocket();
                //返回的最終執(zhí)行的runnable
                return handleChildProc(parsedArgs, childPipeFd, parsedArgs.mStartChildZygote);
            }
        }
}

//后續(xù)的孵化流程就跟啟動systemserver類似
#Zygote.java
static int forkAndSpecialize(){
   //system_server: nativeForkSystemServer
   int pid = nativeForkAndSpecialize();
}

#com_android_internal_os_Zygote.cpp
static jint com_android_internal_os_Zygote_nativeForkAndSpecialize(){
   //這個方法就是跟systemserver進程的孵化方法一致了
   pid_t pid = ForkCommon(env, false, fds_to_close, fds_to_ignore, true);
}

//生成需要執(zhí)行的Runnable
#ZygoteConnection.java
private Runnable handleChildProc(ZygoteArguments parsedArgs,
            FileDescriptor pipeFd, boolean isZygote) {
        closeSocket();
        Zygote.setAppProcessName(parsedArgs, TAG);

        if (parsedArgs.mInvokeWith != null) {
        } else {
            if (!isZygote) {
                return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion,
                        parsedArgs.mDisabledCompatChanges,
                        parsedArgs.mRemainingArgs, null /* classLoader */);
            } else {
                return ZygoteInit.childZygoteInit(parsedArgs.mTargetSdkVersion,
                        parsedArgs.mRemainingArgs, null /* classLoader */);
            }
        }
    }

到這一步，AMS就通過zygote啟動了launcher應(yīng)用進程，從這可以看出，啟動systemserver進程和普通的應(yīng)用進程都是由zygote去進行了，大體流程也是類似的，返回了Runable對象后會去執(zhí)行run方法，接下來的ZygoteInit.zygoteInit()就是在SystemServr啟動流程中有分析過的方法

->ZygoteInit.zygoteInit()
->RuntimeInit.applicationInit()
->findStaticMain()

而在后續(xù)的流程中，就是通過反射去執(zhí)行對應(yīng)類的main方法，在forkSystemServer方法中，最終執(zhí)行的就是SystemServer.main()，而啟動應(yīng)用進程，我們再ProcessList.java類中啟動進程，傳入的參數(shù)就是android.app.ActivityThread",所以launcher應(yīng)用的啟動后續(xù)就會去執(zhí)行ActivityThread.main()方法

小結(jié)

通過一些列的流程分析，走到了我們熟悉的ActivityThread.main()方法，這個方法就是應(yīng)用進程啟動的入口，里面就會是執(zhí)行主線程的looper的啟動，執(zhí)行application.oncreat()方法等，具體的launcher應(yīng)用的創(chuàng)建和顯示，和普通的app應(yīng)用流程一樣的，后續(xù)會分析PMS解析應(yīng)用四大組件后再分析app的啟動到顯示到桌面的流程

點擊桌面圖標(biāo)的流程和launcher啟動流程也是一樣的，通過AMS跟zygote建立socket連接，發(fā)送消息后，zygote會判斷當(dāng)進程不存在時去孵化新的應(yīng)用進程，然后再執(zhí)行對應(yīng)的ActivityThread.main()方法，重復(fù)的話有點多，涉及到的類和方法調(diào)用鏈也很多，梳理一遍對整個流程有一個更清晰的認(rèn)識

啟動流程的分析，有點感覺像是記流水賬一樣，類之間的方法相互調(diào)用，看幾遍都不一定能記得住，我感覺也不需要記住，跟app應(yīng)用層開發(fā)關(guān)聯(lián)性不大
但是，必要的流程還是需要梳理清楚，知道進程之間的關(guān)系，加深對整個Android系統(tǒng)的認(rèn)知，比如梳理完流程后，就能很清楚的認(rèn)知app進程的孵化是需要zygote進程去調(diào)用native的fork，app進程的啟動又是需要AMS進行發(fā)起，和zygote的通信是通過socket的方式發(fā)送消息，在AMS中有ActivityStarter類會判斷進程是否存在，分發(fā)不同的邏輯，應(yīng)用進程的啟動會執(zhí)行到ActivityThread.main()方法，不同的系統(tǒng)服務(wù)在SystemServer進程中初始化啟動，并且有SystemServiceManager進行生命周期的管理等

如果感興趣的朋友也可以跟我一樣跟著系統(tǒng)源碼一個方法一個方法的跟一下，加強自己吹逼的能力和知識儲備