Android系統啟動流程（四）Launcher行程啟動程序決議（附帶面試題）-有解無憂

前面我們分析了init行程，zygote行程，SystemServer行程，本篇的Launcher是系統啟動流程的最后一個行程，

1 Launcher概述

Launcher行程是一個系統的應用程式，位于packages/apps/Launcher3中，它用于顯示已經安裝的應用程式，它通過訪問PackageManagerService獲取安裝的應用程式，然后將他們封裝成一個個的快捷圖示顯示到螢屏上，每一個圖示包含了被啟動應用程式的Intent資訊，點擊之后就可以啟動對應應用程式，

2 Launcher行程決議

private void startOtherServices() {
	mActivityManagerService.systemReady(new Runnable() {
		@Override
            public void run() {
			...
			mSystemServiceManager.startBootPhase(
                        SystemService.PHASE_ACTIVITY_MANAGER_READY);
		}
	}
}

Launcher的入口函式在System.startOtherServices方法中，我們進入systemReady方法中：

frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

    public void systemReady(final Runnable goingCallback) {
    	...
		mStackSupervisor.resumeFocusedStackTopActivityLocked();
		...
	}

進入到了ActivityStackSupervisor.resumeFocusedStackTopActivityLocked中

frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java

	
	boolean resumeFocusedStackTopActivityLocked() {
        return resumeFocusedStackTopActivityLocked(null, null, null);
    }

    boolean resumeFocusedStackTopActivityLocked(
            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
        if (targetStack != null && isFocusedStack(targetStack)) {
            return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
        }
        final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
        if (r == null || r.state != RESUMED) {
            mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
        }
        return false;
    }

在上面最后呼叫到了mFocusedStack.resumeTopActivityUncheckedLocked，mFocusedStack是ActivityStack型別的，我們進入查看原始碼：

frameworks/base/services/core/java/com/android/server/am/ActivityStack.java

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
        if (mStackSupervisor.inResumeTopActivity) {
            // Don't even start recursing.
            return false;
        }

        boolean result = false;
        try {
            // Protect against recursion.
            mStackSupervisor.inResumeTopActivity = true;
            if (mService.mLockScreenShown == ActivityManagerService.LOCK_SCREEN_LEAVING) {
                mService.mLockScreenShown = ActivityManagerService.LOCK_SCREEN_HIDDEN;
                mService.updateSleepIfNeededLocked();
            }
            result = resumeTopActivityInnerLocked(prev, options);
        } finally {
            mStackSupervisor.inResumeTopActivity = false;
        }
        return result;
    }

	private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
        ...
        
        final TaskRecord prevTask = prev != null ? prev.task : null;
        if (next == null) {
            /***
             * 這里啟動了Launcher
             */
            return isOnHomeDisplay() &&
                    mStackSupervisor.resumeHomeStackTask(returnTaskType, prev, reason);
        }
    }

上面從resumeTopActivityUncheckedLocked呼叫到了resumeTopActivityInnerLocked中，最后呼叫到了ActivityStackSupervisor.resumeHomeStackTask函式，

frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java

	boolean resumeHomeStackTask(int homeStackTaskType, ActivityRecord prev, String reason) {
        ...
        
        // Only resume home activity if isn't finishing.
        if (r != null && !r.finishing) {
            mService.setFocusedActivityLocked(r, myReason);
            return resumeFocusedStackTopActivityLocked(mHomeStack, prev, null);
        }
        return mService.startHomeActivityLocked(mCurrentUser, myReason);
    }

接著進入到了ActivityManagerService.startHomeActivityLocked

frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

boolean startHomeActivityLocked(int userId, String reason) {
        if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL
                && mTopAction == null) {
            // We are running in factory test mode, but unable to find
            // the factory test app, so just sit around displaying the
            // error message and don't try to start anything.
            return false;
        }
        // 1 
        Intent intent = getHomeIntent();
        ActivityInfo aInfo = resolveActivityInfo(intent, STOCK_PM_FLAGS, userId);
        if (aInfo != null) {
            intent.setComponent(new ComponentName(aInfo.applicationInfo.packageName, aInfo.name));
            // Don't do this if the home app is currently being
            // instrumented.
            aInfo = new ActivityInfo(aInfo);
            aInfo.applicationInfo = getAppInfoForUser(aInfo.applicationInfo, userId);
            ProcessRecord app = getProcessRecordLocked(aInfo.processName,
                    aInfo.applicationInfo.uid, true);
            if (app == null || app.instrumentationClass == null) {
                intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NEW_TASK);
                mActivityStarter.startHomeActivityLocked(intent, aInfo, reason);
            }
        } else {
            Slog.wtf(TAG, "No home screen found for " + intent, new Throwable());
        }

        return true;
    }

在注釋1處的getHomeIntent方法代碼如下：

	Intent getHomeIntent() {
        Intent intent = new Intent(mTopAction, mTopData != null ? Uri.parse(mTopData) : null);
        intent.setComponent(mTopComponent);
        intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
        if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
            intent.addCategory(Intent.CATEGORY_HOME);//1 
        }
        return intent;
    }

在注釋1處添加了一個CATEGORY_HOME，CATEGORY_HOME = "android.intent.category.HOME"，這里我們鎖定就是啟動了Launcher頁面，因為我們查看系統應用Launcher的清單檔案中匹配了它，Launcher的清單檔案如下：

<manifest
    xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.android.launcher3">
    <uses-sdk android:targetSdkVersion="23" android:minSdkVersion="16"/>

    <uses-permission android:name="android.permission.CALL_PHONE" />
    ...
    
    <application
        android:allowBackup="@bool/enable_backup"
        android:backupAgent="com.android.launcher3.LauncherBackupAgentHelper"
        android:hardwareAccelerated="true"
        android:icon="@mipmap/ic_launcher_home"
        android:label="@string/app_name"
        android:largeHeap="@bool/config_largeHeap"
        android:restoreAnyVersion="true"
        android:supportsRtl="true" >

        <activity
            android:name="com.android.launcher3.Launcher"
            android:launchMode="singleTask"
            android:clearTaskOnLaunch="true"
            android:stateNotNeeded="true"
            android:theme="@style/Theme"
            android:windowSoftInputMode="adjustPan"
            android:screenOrientation="nosensor"
            android:configChanges="keyboard|keyboardHidden|navigation"
            android:resumeWhilePausing="true"
            android:taskAffinity=""
            android:enabled="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.HOME" />
                <category android:name="android.intent.category.DEFAULT" />
                <category android:name="android.intent.category.MONKEY"/>
            </intent-filter>
        </activity>      
    </application>
</manifest>

從上面可以看出Launcher的intent-filter匹配了上面的Intent，所以Launcher就被啟動起來了，就會執行onCreate方法，

3 Launcher行程圖示顯示程序

Launcher.onCreate函式如下：

packages/apps/Launcher3/src/com/android/launcher3/Launcher.java

@Override
    protected void onCreate(Bundle savedInstanceState) {
       
        super.onCreate(savedInstanceState);
		//1
        LauncherAppState app = LauncherAppState.getInstance();
		//2
        mModel = app.setLauncher(this);
       
        setContentView(R.layout.launcher);
        
        if (!mRestoring) {
           		//3
                mModel.startLoader(PagedView.INVALID_RESTORE_PAGE);
            } else {
                // We only load the page synchronously if the user rotates (or triggers a
                // configuration change) while launcher is in the foreground
                mModel.startLoader(mWorkspace.getRestorePage());
            }
        }
    }

注釋1處單例獲取LauncherAppState的實體，在注釋2處呼叫它的setLauncher函式并將Launcher物件傳入，setLauncher函式如下所示：

packages/apps/Launcher3/src/com/android/launcher3/LauncherAppState.java

 	LauncherModel setLauncher(Launcher launcher) {
        getLauncherProvider().setLauncherProviderChangeListener(launcher);
        mModel.initialize(launcher);
        mAccessibilityDelegate = ((launcher != null) && Utilities.ATLEAST_LOLLIPOP) ?
            new LauncherAccessibilityDelegate(launcher) : null;
        return mModel;
    }

接著呼叫到了LauncherModel的initialize函式：

packages/apps/Launcher3/src/com/android/launcher3/LauncherModel.java

/**
     * Set this as the current Launcher activity object for the loader.
     */
    public void initialize(Callbacks callbacks) {
        synchronized (mLock) {
            // Disconnect any of the callbacks and drawables associated with ItemInfos on the
            // workspace to prevent leaking Launcher activities on orientation change.
            unbindItemInfosAndClearQueuedBindRunnables();
            mCallbacks = new WeakReference<Callbacks>(callbacks);
        }
    }

我們看到上面其實就是設定了一個回呼函式，回呼函式就是Launcher自身，不過是以一個弱參考的方式，這個回呼后面會用到，

接著分析onCreate中的注釋3的部分，launcherModel.startLoader方法：

  @Thunk static final HandlerThread sWorkerThread = new HandlerThread("launcher-loader");
    static {
        sWorkerThread.start();
    }
    @Thunk static final Handler sWorker = new Handler(sWorkerThread.getLooper());

	public void startLoader(int synchronousBindPage, int loadFlags) {
        // Enable queue before starting loader. It will get disabled in Launcher#finishBindingItems
        InstallShortcutReceiver.enableInstallQueue();
        synchronized (mLock) {
            // Clear any deferred bind-runnables from the synchronized load process
            // We must do this before any loading/binding is scheduled below.
            synchronized (mDeferredBindRunnables) {
                mDeferredBindRunnables.clear();
            }

            // Don't bother to start the thread if we know it's not going to do anything
            if (mCallbacks != null && mCallbacks.get() != null) {
                // If there is already one running, tell it to stop.
                stopLoaderLocked();
                mLoaderTask = new LoaderTask(mApp.getContext(), loadFlags);
                if (synchronousBindPage != PagedView.INVALID_RESTORE_PAGE
                        && mAllAppsLoaded && mWorkspaceLoaded && !mIsLoaderTaskRunning) {
                    mLoaderTask.runBindSynchronousPage(synchronousBindPage);
                } else {
                    sWorkerThread.setPriority(Thread.NORM_PRIORITY);
                    sWorker.post(mLoaderTask);
                }
            }
        }
    }

上面創建了一個HandlerThread的子執行緒的Handler，用來處理耗時任務，在上面的最后post了一個任務，這個任務的類是LoaderTask.java，實作了Runnable介面，run方法如下：

	public void run() {
            synchronized (mLock) {
                if (mStopped) {
                    return;
                }
                mIsLoaderTaskRunning = true;
            }
            // Optimize for end-user experience: if the Launcher is up and // running with the
            // All Apps interface in the foreground, load All Apps first. Otherwise, load the
            // workspace first (default).
            keep_running: {
                if (DEBUG_LOADERS) Log.d(TAG, "step 1: loading workspace");
                //1 
                loadAndBindWorkspace();

                if (mStopped) {
                    break keep_running;
                }

                waitForIdle();

                // second step
                if (DEBUG_LOADERS) Log.d(TAG, "step 2: loading all apps");
                // 2
                loadAndBindAllApps();
            }

            // Clear out this reference, otherwise we end up holding it until all of the
            // callback runnables are done.
            mContext = null;

            synchronized (mLock) {
                // If we are still the last one to be scheduled, remove ourselves.
                if (mLoaderTask == this) {
                    mLoaderTask = null;
                }
                mIsLoaderTaskRunning = false;
                mHasLoaderCompletedOnce = true;
            }
        }

上面的兩個注釋寫的很清楚，在注釋1處loadAndBindWorkspace是加載作業空間，在注釋2處loadAndBindAllApps用來加載所有的app，

loadAndBindAllApps原始碼如下：

 	private void loadAndBindAllApps() {
            if (DEBUG_LOADERS) {
                Log.d(TAG, "loadAndBindAllApps mAllAppsLoaded=" + mAllAppsLoaded);
            }
            if (!mAllAppsLoaded) {
            	// 1 
                loadAllApps();
                synchronized (LoaderTask.this) {
                    if (mStopped) {
                        return;
                    }
                }
                updateIconCache();
                synchronized (LoaderTask.this) {
                    if (mStopped) {
                        return;
                    }
                    mAllAppsLoaded = true;
                }
            } else {
                onlyBindAllApps();
            }
        }

注釋1處呼叫了loadAllApps()，原始碼如下：

	private void loadAllApps() {
		...
        mHandler.post(new Runnable() {
            public void run() {
                final long bindTime = SystemClock.uptimeMillis();
                final Callbacks callbacks = tryGetCallbacks(oldCallbacks);
                if (callbacks != null) {
                    callbacks.bindAllApplications(added);//1
                    ...
                }
            }
        });
       ...
    }

這里的callbacks就是上面弱參考存盤的Launcher，所以我們直接查看Launcher中的bindAllApplications，代碼如下：

packages/apps/Launcher3/src/com/android/launcher3/Launcher.java

	 public void bindAllApplications(final ArrayList<AppInfo> apps) {
        if (waitUntilResume(mBindAllApplicationsRunnable, true)) {
            mTmpAppsList = apps;
            return;
        }
        if (mAppsView != null) {
        	//1 
            mAppsView.setApps(apps);
        }
        if (mLauncherCallbacks != null) {
            mLauncherCallbacks.bindAllApplications(apps);
        }
    }

在注釋1處呼叫了 mAppsView的setApps，mAppsView是一個AllAppsContainerView型別的，我們查看它的setApps方法：

packages/apps/Launcher3/src/com/android/launcher3/allapps/AllAppsContainerView.java

	private final AlphabeticalAppsList mApps;
	
	public void setApps(List<AppInfo> apps) {
        mApps.setApps(apps);
    }

這里我們查看onFinishInflate函式

    
    private AllAppsRecyclerView mAppsRecyclerView;
	
	@Override
    protected void onFinishInflate() {
        super.onFinishInflate();

		//1 初始化控制元件
        mAppsRecyclerView = (AllAppsRecyclerView) findViewById(R.id.apps_list_view);
        //2 傳遞應用
        mAppsRecyclerView.setApps(mApps);
        mAppsRecyclerView.setLayoutManager(mLayoutManager);
        //3 設定adapter
        mAppsRecyclerView.setAdapter(mAdapter);
        mAppsRecyclerView.setHasFixedSize(true);
        mAppsRecyclerView.addOnScrollListener(mElevationController);
        mAppsRecyclerView.setElevationController(mElevationController);
    }

onFinishInflate在xml加載完成之后就會呼叫，這里launcher中app的顯示邏輯和我們平時將資料顯示到一個RecyclerView上基本一致，所以這里也比較好理解，

4 Android系統啟動流程

在此對整個Android系統啟動流程做一個全面的總結：

1 按Power鍵啟動電源及系統啟動

當按下電源鍵，引導芯片代碼開始從固化在ROM中預定義的地方開始執行，加載引導程式Bootloader到RAM，然后執行引導程式，

2 引導程式Bootloader

引導程式是Android作業系統被拉起來之前的一個程式，類似于window一樣，它的作用就是把系統拉起運行起來，它是針對特定的主板與芯片的，設備制造商要么使用很受歡迎的引導程式比如redboot、uboot、qibootloader或者開發自己的引導程式，它不是Android作業系統的一部分，引導程式是OEM廠商或者運營商加鎖和限制的地方，

3 linux內核啟動

Android內核與桌面linux內核啟動的方式差不多，內核啟動時，設定快取、被保護存盤器、計劃串列，加載驅動，當內核完成系統設定，它首先在系統檔案中尋找”init”檔案，然后啟動root行程或者系統的第一個行程，

4 init行程啟動
創建和掛載啟動所需要的檔案目錄，初始化和啟動屬性服務，決議init.rc配置并且啟動Zygote行程，

5 Zygote行程啟動

創建JavaVM并為JavaVM注冊JNI，創建服務端Socket，啟動SystemServer行程，

6 SystemServer行程啟動

啟動Binder執行緒池和SystemServiceManager，并且啟動各種系統服務，

7 Launcher啟動

被SystemServer行程啟動的ActivityManagerService會啟動Launcher，Launcher啟動后會將已安裝應用的快捷圖示顯示到界面上，

5 面試題

1 Android系統啟動流程? 答案如上所述

2 什么是寫時拷貝(copy- on-write)？

寫時拷貝copy_on_write技術: fork的實作是使用copy_on_write技術實作的，它是一種可以推遲甚至避免拷貝的技術，內核此時并不復制整個行程的地址空間，而是讓父子行程共享同一個地址空間，只有在子行程真正需要寫入資料的時候才會賦值地址空間，從而使得每個行程擁有自己的行程空間，也就是順澩的復制是在需要寫入資料的時候才會進行，在此之前只會以只讀的形式共享，

3 孤兒行程和僵尸行程是什么？

fork系統呼叫之后，父子行程將交替執行，執行順序不定，如果父行程先退出，子行程還沒退出那么子行程的父行程將變為init行程（托孤給了init行程），（注：任何一個行程都必須有父行程）如果子行程先退出，父行程還沒退出，那么子行程必須等到父行程捕獲到了子行程的退出狀態才真正結束，否則這個時候子行程就成為僵行程（僵尸行程：只保留一些退出資訊供父行程查詢).

4 system_server 為什么要在 Zygote 中啟動，而不是由 init 直接啟動呢？

Zygote 作為一個范訓器，可以提前加載一些資源，這樣 fork() 時基于 Copy-On-Write 機制創建的其他行程就能直接使用這些資源，而不用重新加載，比如 system_server 就可以直接使用 Zygote 中的 JNI函式、共享庫、常用的類、以及主題資源，

5 為什么要專門使用 Zygote 行程去范訓應用行程，而不是讓 system_server 去范訓呢？

system_server 相比 Zygote 多運行了 AMS、WMS 等服務，這些對一個應用程式來說是不需要的，另外行程的 fork() 對多執行緒不友好，僅會將發起呼叫的執行緒拷貝到子行程，這可能會導致死鎖，而system_server 中肯定是有很多執行緒的，

6 多執行緒的行程fork呼叫為什么會導致死鎖？

多執行緒的行程的fork呼叫：復制整個用戶空間的資料（通常使用 copy-on-write 的策略，
所以可以實作的速度很快）以及所有系統物件，然后僅復制當前執行緒到子行程，這里：所有父行程中別的執行緒，到了子行程中都是突然蒸發掉的假設這么一個環境，在 fork 之前，有一個子執行緒 lock 了某個鎖，獲得了對鎖的所有權，fork 以后，在子行程中，所有的額外執行緒都人間蒸發了，而鎖卻被正常復制了，在子行程看來，這個鎖沒有主人，所以沒有任何人可以對它解鎖，當子行程想 lock 這個鎖時，不再有任何手段可以解開了，程式發生死鎖

7 Zygote 為什么不采用 Binder 機制進行 IPC 通信？

Binder 機制中存在 Binder 執行緒池，是多執行緒的，如果 Zygote 采用 Binder 的話就存在上面說的fork() 與多執行緒的問題了，其實嚴格來說，Binder 機制不一定要多執行緒，所謂的 Binder 執行緒只不過是在回圈讀取 Binder 驅動的訊息而已，只注冊一個 Binder 執行緒也是可以作業的，比如 service manager就是這樣的，實際上 Zygote 盡管沒有采取 Binder 機制，它也不是單執行緒的，但它在 fork() 前主動停止了其他執行緒，fork() 后重新啟動了，

轉載請註明出處，本文鏈接：https://www.uj5u.com/qianduan/162829.html

標籤：其他

上一篇：從一次專案重構說起CSS3自定義變數在專案中是如何使用的？

下一篇：c語言字串處理報錯 warning,C4996,sprintf,deprecated,C4996,strcpy,C4996,strcat