提示ContentProvider將放到下一章分析，不過本章將涉及和ContentProvider有關的知識點。

提示讀者們最好在桌上放一杯清茶，以保持AMS分析旅途中頭腦清醒。

//①呼叫main函式，得到一個Context物件

context =ActivityManagerService.main(factoryTest);

//②setSystemProcess：這樣SystemServer程式可加到AMS中，並被它管理

ActivityManagerService.setSystemProcess();

//③installSystemProviders：將SettingsProvider放到SystemServer程式中來執行

ActivityManagerService.installSystemProviders();

//④在內部儲存WindowManagerService（以後簡稱WMS）

ActivityManagerService.self().setWindowManager(wm);

//⑤和WMS互動，彈出“啟動進度“對話方塊

ActivityManagerNative.getDefault().showBootMessage(

             context.getResources().getText(

               //該字串中文為：“正在啟動應用程式”

               com.android.internal.R.string.android_upgrading_starting_apps),

              false);

//⑥AMS是系統的核心，只有它準備好後，才能呼叫其他服務的systemReady

//注意，有少量服務在AMS systemReady之前就緒，它們不影響此處的分析

ActivityManagerService.self().systemReady(newRunnable() {

    publicvoid run() {

   startSystemUi(contextF);//啟動systemUi。如此，狀態列就準備好了

    if(batteryF != null) batteryF.systemReady();

    if(networkManagementF != null) networkManagementF.systemReady();

    ......

    Watchdog.getInstance().start();//啟動Watchdog

    ......//呼叫其他服務的systemReady函式

}

 publicstatic final Context main(int factoryTest) {

    AThreadthr = new AThread();//①建立一個AThread執行緒物件

    thr.start();

    ......//等待thr建立成功

    ActivityManagerServicem = thr.mService;

    mSelf =m;

    //②呼叫ActivityThread的systemMain函式

    ActivityThreadat = ActivityThread.systemMain();

    mSystemThread= at;

    //③得到一個Context物件，注意呼叫的函式名為getSystemContext，何為System Context

    Contextcontext = at.getSystemContext();

    context.setTheme(android.R.style.Theme_Holo);

    m.mContext= context;

    m.mFactoryTest= factoryTest;

    //ActivtyStack是AMS中用來管理Activity的啟動和排程的核心類，以後再分析它

    m.mMainStack = new ActivityStack(m, context,true);

    //呼叫BSS的publish函式，我們在第5章的BSS知識中介紹過了

    m.mBatteryStatsService.publish(context);

    //另外一個service：UsageStatsService。後續再分析該服務

    m.mUsageStatsService.publish(context);

    synchronized (thr) {

           thr.mReady = true;

           thr.notifyAll();//通知thr執行緒，本執行緒工作完成

     }

    //④呼叫AMS的startRunning函式

    m.startRunning(null, null, null, null);

   returncontext;

}

static class AThread extends Thread {//AThread從Thread類派生

   ActivityManagerServicemService;

   booleanmReady = false;

   publicAThread() {

     super("ActivityManager");//執行緒名就叫“ActivityManager”

   }

   publicvoid run() {

     Looper.prepare();//看來，AThread執行緒將支援訊息迴圈及處理功能

     android.os.Process.setThreadPriority(//設定執行緒優先順序

                   android.os.Process.THREAD_PRIORITY_FOREGROUND);

     android.os.Process.setCanSelfBackground(false);

      //建立AMS物件

     ActivityManagerService m = new ActivityManagerService();

     synchronized (this) {

           mService= m;//賦值AThread內部成員變數mService，指向AMS

          notifyAll();  //通知main函式所線上程

      }

     synchronized (this) {

        while (!mReady) {

           try{

                 wait();//等待main函式所線上程的notifyAll

               }......

           }

       }......

    Looper.loop();//進入訊息迴圈

 }

 }

private ActivityManagerService() {

    FiledataDir = Environment.getDataDirectory();//指向/data/目錄

    FilesystemDir = new File(dataDir, "system");//指向/data/system/目錄

   systemDir.mkdirs();//建立/data/system/目錄

    //建立BatteryStatsService（以後簡稱BSS）和UsageStatsService（以後簡稱USS）

   //我們在分析PowerManageService時已經見過BSS了

   mBatteryStatsService = new BatteryStatsService(new File(

               systemDir, "batterystats.bin").toString());

   mBatteryStatsService.getActiveStatistics().readLocked();

    mBatteryStatsService.getActiveStatistics().writeAsyncLocked();

   mOnBattery = DEBUG_POWER ? true

               : mBatteryStatsService.getActiveStatistics().getIsOnBattery();

   mBatteryStatsService.getActiveStatistics().setCallback(this);

    //建立USS

    mUsageStatsService= new UsageStatsService(new File(

               systemDir, "usagestats").toString());

    //獲取OpenGl版本

   GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version",

           ConfigurationInfo.GL_ES_VERSION_UNDEFINED);

     //mConfiguration型別為Configuration，用於描述資原始檔的配置屬性，例如

     //字型、語言等。後文再討論這方面的內容

    mConfiguration.setToDefaults();

    mConfiguration.locale = Locale.getDefault();

     //mProcessStats為ProcessStats型別，用於統計CPU、記憶體等資訊。其內部工作原理就是

    //讀取並解析/proc/stat檔案的內容。該檔案由核心生成，用於記錄kernel及system

    //一些執行時的統計資訊。讀者可在Linux系統上通過man proc命令查詢詳細資訊

    mProcessStats.init();

     //解析/data/system/packages-compat.xml檔案，該檔案用於儲存那些需要考慮螢幕尺寸

    //的APK的一些資訊。讀者可參考AndroidManifest.xml中compatible-screens相關說明。

    //當APK所執行的裝置不滿足要求時，AMS會根據設定的引數以採用螢幕相容的方式去執行它

    mCompatModePackages = new CompatModePackages(this, systemDir);

     Watchdog.getInstance().addMonitor(this);

     //建立一個新執行緒，用於定時更新系統資訊（和mProcessStats互動）

    mProcessStatsThread = new Thread("ProcessStats") {...//先略去該段程式碼}

    mProcessStatsThread.start();

 }

注意應用程式指那些執行APK的程式，它們由Zyote 派生（fork）而來，上面執行了dalvik虛擬機器。與應用程式相對的就是系統程式（包括Zygote和SystemServer）。

另外，讀者須將“應用程式和系統程式”與“應用APK和系統APK”的概念區分開來。APK的判別依賴其檔案所在位置（如果apk檔案在/data/app目錄下，則為應用APK）。

public static final ActivityThread systemMain() {

   HardwareRenderer.disable(true);//禁止硬體渲染加速

   //建立一個ActivityThread物件，其建構函式非常簡單

  ActivityThread thread = new ActivityThread();

  thread.attach(true);//呼叫它的attach函式，注意傳遞的引數為true

   returnthread;

 }

提示解答這個問題，對於理解SystemServer中各服務的互動方式是尤其重要的。

private void attach(boolean system) {

    sThreadLocal.set(this);

    mSystemThread= system;//判斷是否為系統程式

    if(!system) {

        ......//應用程式的處理流程

     } else {//系統程式的處理流程，該情況只在SystemServer中處理

       //設定DDMS時看到的systemserver程式名為system_process

       android.ddm.DdmHandleAppName.setAppName("system_process");

       try {

            //ActivityThread的幾員大將出場，見後文的分析

            mInstrumentation = new Instrumentation();

            ContextImpl context = new ContextImpl();

            //初始化context，注意第一個引數值為getSystemContext

            context.init(getSystemContext().mPackageInfo, null, this);

            Application app = //利用Instrumentation建立一個Application物件

                    Instrumentation.newApplication(Application.class,context);

             //一個程式支援多個Application，mAllApplications用於儲存該程式中

            //的Application物件

            mAllApplications.add(app);

             mInitialApplication = app;//設定mInitialApplication

            app.onCreate();//呼叫Application的onCreate函式

           }......//try/catch結束

      }//if(!system)判斷結束

     //註冊Configuration變化的回撥通知

     ViewRootImpl.addConfigCallback(newComponentCallbacks2() {

          publicvoid onConfigurationChanged(Configuration newConfig) {

            ......//當系統配置發生變化（如語言切換等）時，需要呼叫該回撥

          }

           public void onLowMemory() {}

           public void onTrimMemory(int level) {}

        });

 }

提示此處的Application是Android中的一個概念，可理解為一種容器，它內部包含四大元件。另外，一個程式可以執行多個Application。

public ContextImpl getSystemContext() {

  synchronized(this) {

   if(mSystemContext == null) {//單例模式

       ContextImplcontext =  ContextImpl.createSystemContext(this);

       //LoadedApk是2.3引入的一個新類，代表一個載入到系統中的APK

       LoadedApkinfo = new LoadedApk(this, "android", context, null,

                       CompatibilityInfo.DEFAULT_COMPATIBILITY_INFO);

       //初始化該ContextImpl物件

      context.init(info, null, this);

      //初始化資源資訊

      context.getResources().updateConfiguration(

                        getConfiguration(),getDisplayMetricsLocked(

                       CompatibilityInfo.DEFAULT_COMPATIBILITY_INFO, false));

       mSystemContext = context;//儲存這個特殊的ContextImpl物件

      }

   }

    returnmSystemContext;

}

注意在函式中有些成員變數的型別為基類型別，而在圖6-2中直接指向了實際型別。

注意該族譜成員並不完全。另外，Activity、Service和Application所實現的介面也未畫出。

//注意呼叫該函式時所傳遞的4個引數全為null

public final void startRunning(String pkg, Stringcls, String action,

                                    String data) {

  synchronized(this) {

     if (mStartRunning) return;  //如果已經呼叫過該函式，則直接返回

    mStartRunning = true;

     //mTopComponent最終賦值為null

    mTopComponent = pkg != null && cls != null

                   ? new ComponentName(pkg, cls) : null;

    mTopAction = action != null ? action : Intent.ACTION_MAIN;

    mTopData = data; //mTopData最終為null

     if(!mSystemReady) return; //此時mSystemReady為false，所以直接返回

    }

   systemReady(null);//這個函式很重要，可惜不在本次startRunning中呼叫

}

public static void setSystemProcess() {

  try {

      ActivityManagerService m = mSelf;

       //向ServiceManager註冊幾個服務

       ServiceManager.addService("activity",m);

       //用於列印記憶體資訊

      ServiceManager.addService("meminfo", new MemBinder(m));

       /*

        Android4.0新增的，用於列印應用程式使用硬體顯示加速方面的資訊（Applications

         Graphics Acceleration Info）。讀者通過adb shell dumpsys gfxinfo看看具體的

         輸出

       */

      ServiceManager.addService("gfxinfo", new GraphicsBinder(m));

        if(MONITOR_CPU_USAGE)//該值預設為true，新增cpuinfo服務

            ServiceManager.addService("cpuinfo", new CpuBinder(m));

        //向SM註冊許可權管理服務PermissionController

       ServiceManager.addService("permission", newPermissionController(m));

      /*    重要說明：

        向PackageManagerService查詢package名為"android"的ApplicationInfo。

        注意這句呼叫：雖然PKMS和AMS同屬一個程式，但是二者互動仍然藉助Context。

        其實，此處完全可以直接呼叫PKMS的函式。為什麼要費如此周折呢

      */

      ApplicationInfo info = //使用AMS的mContext物件

               mSelf.mContext.getPackageManager().getApplicationInfo(

                        "android",STOCK_PM_FLAGS);

          //①呼叫ActivityThread的installSystemApplicationInfo函式

            mSystemThread.installSystemApplicationInfo(info);

           synchronized (mSelf) {

               //②此處涉及AMS對程式的管理，見下文分析

               ProcessRecord app = mSelf.newProcessRecordLocked(

                       mSystemThread.getApplicationThread(), info,

                        info.processName);//注意，最後一個引數為字串，值為“system”

               app.persistent = true;

               app.pid = MY_PID;

               app.maxAdj = ProcessList.SYSTEM_ADJ;

               //③儲存該ProcessRecord物件

               mSelf.mProcessNames.put(app.processName, app.info.uid, app);

               synchronized (mSelf.mPidsSelfLocked) {

                   mSelf.mPidsSelfLocked.put(app.pid, app);

               }

               //根據系統當前狀態，調整程式的排程優先順序和OOM_Adj，後續將詳細分析該函式

                mSelf.updateLruProcessLocked(app, true,true);

           }

        } ......//拋異常

    }

public voidinstallSystemApplicationInfo(ApplicationInfo info) {

 synchronized (this) {

   //返回的ContextImpl物件即之前在AMS的main函式一節中建立的那個物件

   ContextImpl context = getSystemContext();

    //又呼叫init初始化該Context，是不是重複呼叫init了？

   context.init(new LoadedApk(this, "android", context, info,

              CompatibilityInfo.DEFAULT_COMPATIBILITY_INFO), null, this);

     //建立一個Profiler物件，用於效能統計

     mProfiler = new Profiler();

     }

 }

提示如果讀者知道Binder系統支援客戶端監聽服務端的死亡訊息，那麼這個問題的答案就簡單了：服務端自然在應用程式中，因為AMS需要監聽應用程式的死亡通知。

public final void scheduleStopActivity(IBindertoken, boolean showWindow,

                                     intconfigChanges) {

  queueOrSendMessage(//該函式內部將給一個Handler傳送對應的訊息

               showWindow ? H.STOP_ACTIVITY_SHOW : H.STOP_ACTIVITY_HIDE,

               token, 0, configChanges);

 }

提示Activity的onStop函式也將在主執行緒中被呼叫。

final ProcessRecordnewProcessRecordLocked(IApplicationThread thread,

                ApplicationInfo info, String customProcess) {

   Stringproc = customProcess != null ? customProcess : info.processName;

  BatteryStatsImpl.Uid.Proc ps = null;

  BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics();

  synchronized (stats) {

        //BSImpl將為該程式建立一個耗電量統計項

        ps =stats.getProcessStatsLocked(info.uid, proc);

   }

   //建立一個ProcessRecord物件，用於和其他程式通訊的thread作為第一個引數

   returnnew ProcessRecord(ps, thread, info, proc);

 }

ProcessRecord(BatteryStatsImpl.Uid.Proc_batteryStats,

        IApplicationThread_thread,ApplicationInfo _info, String _processName) {

    batteryStats = _batteryStats; //用於電量統計

     info =_info; //儲存ApplicationInfo

    processName = _processName; //儲存程式名

      //一個程式能執行多個Package，pkgList用於儲存package名

    pkgList.add(_info.packageName);

     thread= _thread;//儲存IApplicationThread,通過它可以和應用程式互動

     //下面這些xxxAdj成員變數和程式排程優先順序及OOM_adj有關。以後再分析它的作用

     maxAdj= ProcessList.EMPTY_APP_ADJ;

    hiddenAdj = ProcessList.HIDDEN_APP_MIN_ADJ;

    curRawAdj = setRawAdj = -100;

     curAdj= setAdj = -100;

   //用於控制該程式是否常駐記憶體（即使被殺掉，系統也會重啟它），只有重要的程式才會有此待遇

    persistent = false;

     removed= false;

}

   app.persistent = true;//設定該值為true

   app.pid =MY_PID;//設定pid為SystemServer的程式號

   app.maxAdj= ProcessList.SYSTEM_ADJ;//設定最大OOM_Adj，系統程式預設值為-16

   //另外，app的processName被設定成“system”

提示讀者在定製自己的Android系統時，萬不可去掉/system/app/SettingsProvider.apk，否則系統將無法正常啟動。

public static final void installSystemProviders(){

 List<ProviderInfo> providers;

 synchronized (mSelf) {

    /*

    從mProcessNames找到程式名為“system”且uid為SYSTEM_UID的ProcessRecord，

    返回值就是前面在installSystemApplication中建立的那個ProcessRecord，它代表

    SystemServer程式

    */

   ProcessRecord app = mSelf.mProcessNames.get("system",Process.SYSTEM_UID);

    //①關鍵呼叫，見下文分析

    providers= mSelf.generateApplicationProvidersLocked(app);

    if(providers != null) {

       ......//將非系統APK（即未設ApplicationInfo.FLAG_SYSTEM標誌）提供的Provider

      //從providers列表中去掉

        }

     if(providers != null) {//②為SystemServer程式安裝Provider

         mSystemThread.installSystemProviders(providers);

     }

    //監視Settings資料庫中Secure表的變化，目前只關注long_press_timeout配置的變化

    mSelf.mCoreSettingsObserver = new CoreSettingsObserver(mSelf);

     //UsageStatsService的工作，以後再討論

    mSelf.mUsageStatsService.monitorPackages();

 }

注意此處不再區分系統程式還是應用程式。由於只和ActivityThread互動，因此它執行在什麼程式無關緊要。

private final List<ProviderInfo> generateApplicationProvidersLocked(

                              ProcessRecordapp) {

  List<ProviderInfo> providers = null;

  try {

         //①向PKMS查詢滿足要求的ProviderInfo，最重要的查詢條件包括：程式名和程式uid

         providers = AppGlobals.getPackageManager().

            queryContentProviders(app.processName, app.info.uid,

             STOCK_PM_FLAGS | PackageManager.GET_URI_PERMISSION_PATTERNS);

        } ......

   if(providers != null) {

      finalint N = providers.size();

      for(int i=0; i<N; i++) {

         //②AMS對ContentProvider的管理，見下文解釋

        ProviderInfo cpi =   (ProviderInfo)providers.get(i);

        ComponentName comp = new ComponentName(cpi.packageName, cpi.name);

        ContentProviderRecord cpr = mProvidersByClass.get(comp);

         if(cpr == null) {

             cpr = new ContentProviderRecord(cpi, app.info, comp);

              //ContentProvider在AMS中用ContentProviderRecord來表示

              mProvidersByClass.put(comp, cpr);//儲存到AMS的mProvidersByClass中

          }

          //將資訊也儲存到ProcessRecord中

         app.pubProviders.put(cpi.name, cpr);

          //儲存PackageName到ProcessRecord中

         app.addPackage(cpi.applicationInfo.packageName);

         //對該APK進行dex優化

         ensurePackageDexOpt(cpi.applicationInfo.packageName);

         }

     }

    returnproviders;

 }

public List<ProviderInfo>queryContentProviders(String processName,

    int uid,int flags) {

  ArrayList<ProviderInfo> finalList = null;

  synchronized (mPackages) {

     //還記得mProvidersByComponent的作用嗎？它以ComponentName為key，儲存了

     //PKMS掃描APK得到的PackageParser.Provider資訊。讀者可參考圖4-8

     finalIterator<PackageParser.Provider> i =

                      mProvidersByComponent.values().iterator();

       while(i.hasNext()) {

          final PackageParser.Provider p = i.next();

           //下面的if語句將從這些Provider中搜尋本例設定的processName為“system”，

          //uid為SYSTEM_UID，flags為FLAG_SYSTEM的Provider

          if (p.info.authority != null

               && (processName == null

                   ||(p.info.processName.equals(processName)

                        &&p.info.applicationInfo.uid == uid))

               && mSettings.isEnabledLPr(p.info, flags)

                && (!mSafeMode || ( p.info.applicationInfo.flags

                        &ApplicationInfo.FLAG_SYSTEM) != 0)) {

                    if (finalList == null) {

                        finalList = newArrayList<ProviderInfo>(3);

                   }

                 //由PackageParser.Provider得到ProviderInfo，並新增到finalList中

                //關於Provider類及ProviderInfo類，可參考圖4-5

                  finalList.add(PackageParser.generateProviderInfo(p,flags));

               }

           }

        }

   if(finalList != null)

      //最終結果按provider的initOrder排序，該值用於表示初始化ContentProvider的順序

      Collections.sort(finalList, mProviderInitOrderSorter);

   returnfinalList;//返回最終結果

 }

提示從執行效率角度來說，這樣做也是合情合理的。因為SystemServer的很多Service都依賴Settings資料庫，把它們放在同一個程式中，可以降低由於程式間通訊帶來的效率損失。

public final void installSystemProviders(List<ProviderInfo>providers) {

  if(providers != null)

    //呼叫installContentProviders，第一個引數真實型別是Application

   installContentProviders(mInitialApplication, providers);

}

private void installContentProviders(

           Context context, List<ProviderInfo> providers) {

   finalArrayList<IActivityManager.ContentProviderHolder> results =

                   new ArrayList<IActivityManager.ContentProviderHolder>();

  Iterator<ProviderInfo> i = providers.iterator();

   while(i.hasNext()) {

    ProviderInfo cpi = i.next();

     //①呼叫installProvider函式，得到一個IContentProvider物件

    IContentProvider cp = installProvider(context, null, cpi, false);

     if (cp!= null) {

       IActivityManager.ContentProviderHolder cph =

                    newIActivityManager.ContentProviderHolder(cpi);

       cph.provider = cp;

       //將返回的cp儲存到results陣列中

       results.add(cph);

        synchronized(mProviderMap){

         //mProviderRefCountMap，；型別為HashMap<IBinder,ProviderRefCount>，

         //主要通過ProviderRefCount對ContentProvider進行引用計數控制，一旦引用計數

         //降為零，表示系統中沒有地方使用該ContentProvider，要考慮從系統中登出它

         mProviderRefCountMap.put(cp.asBinder(), new ProviderRefCount(10000));

         }

     }

   }

    try {

       //②呼叫AMS的publishContentProviders註冊這些ContentProvider，第一個引數

       //為ApplicationThread

       ActivityManagerNative.getDefault().publishContentProviders(

                      getApplicationThread(), results);

        } ......

    }

提示 上述工作其實和Binder Service類似，一個Binder Service也需要先建立，然後註冊到ServiceManager中。

private IContentProvider installProvider(Contextcontext,

           IContentProvider provider, ProviderInfoinfo, boolean noisy) {

//注意本例所傳的引數：context為mInitialApplication，provider為null,info不為null，

// noisy為false

  ContentProvider localProvider = null;

   if(provider == null) {

      Context c = null;

      ApplicationInfo ai = info.applicationInfo;

       /*

        下面這個if判斷的作用就是為該ContentProvider找到對應的Application。

        在AndroidManifest.xml中，ContentProvider是Application的子標籤，所以

       ContentProvider和Application有一種對應關係。在本例中，傳入的context（

        其實是mInitialApplication）代表的是framework-res.apk，而Provider代表的

        是SettingsProvider。而SettingsProvider.apk所對應的Application還未建立，

        所以下面的判斷語句最終會進入最後的else分支

      */

       if(context.getPackageName().equals(ai.packageName)) {

          c= context;

       }else if (mInitialApplication != null &&

                 mInitialApplication.getPackageName().equals(ai.packageName)){

          c = mInitialApplication;

       } else {

         try{

             //ai.packageName應該是SettingsProvider.apk的Package，

             //名為“com.android.providers.settings”

             //下面將建立一個Context，指向該APK

              c = context.createPackageContext(ai.packageName,

                           Context.CONTEXT_INCLUDE_CODE);

           }

       }//if(context.getPackageName().equals(ai.packageName))判斷結束

       if (c == null)  return null;

       try {

         /*

         為什麼一定要找到對應的Context呢？除了ContentProvider和Application的

         對應關係外，還有一個決定性原因：即只有對應的Context才能載入對應APK的Java位元組碼，

         從而可通過反射機制生成ContentProvider例項

        */

         finaljava.lang.ClassLoader cl = c.getClassLoader();

         //通過Java反射機制得到真正的ContentProvider，

         //此處將得到一個SettingsProvider物件

         localProvider=(ContentProvider)cl.loadClass(info.name).newInstance();

         //從ContentProvider中取出其mTransport成員（見下文分析）

         provider =localProvider.getIContentProvider();

         if (provider == null) return null;

         //初始化該ContentProvider，內部會呼叫其onCreate函式

        localProvider.attachInfo(c, info);

      }......

   }//if(provider == null)判斷結束

  synchronized (mProviderMap) {

      /*

        ContentProvider必須指明一個和多個authority，在第4章曾經提到過，

         在URL中host:port的組合表示一個authority。這個單詞不太好理解，可簡單

         認為它用於指定ContentProvider的位置（類似網站的域名）

     */

      String names[] =PATTERN_SEMICOLON.split(info.authority);

      for (int i=0; i<names.length; i++) {

             ProviderClientRecord pr = newProviderClientRecord(names[i],

                                           provider, localProvider);

            try {

                //下面這句對linkToDeath的呼叫頗讓人費解，見下文分析

                  provider.asBinder().linkToDeath(pr, 0);

                  mProviderMap.put(names[i], pr);

           }......

      }//for迴圈結束

     if(localProvider != null) {

         // mLocalProviders用於儲存由本程式建立的ContentProvider資訊

          mLocalProviders.put(provider.asBinder(),

                   new ProviderClientRecord(null, provider, localProvider));

              }

     }//synchronized 結束

  return provider;

}

 publicfinal void publishContentProviders(IApplicationThread caller,

                           List<ContentProviderHolder>providers) {

  ......

  synchronized(this){

    //找到呼叫者所在的ProcessRecord物件

   finalProcessRecord r = getRecordForAppLocked(caller);

   ......

   finallong origId = Binder.clearCallingIdentity();

   final intN = providers.size();

   for (inti=0; i<N; i++) {

      ContentProviderHolder src = providers.get(i);

       ......

       //①注意：先從該ProcessRecord中找對應的ContentProviderRecord

     ContentProviderRecord dst = r.pubProviders.get(src.info.name);

      if(dst != null) {

          ComponentName comp = newComponentName(dst.info.packageName,

                                                         dst.info.name);

          //以ComponentName為key，儲存到mProvidersByClass中

         mProvidersByClass.put(comp, dst);

         String names[] = dst.info.authority.split(";");

         for (int j = 0; j < names.length; j++)

               mProvidersByName.put(names[j], dst);//以authority為key，儲存

              //mLaunchingProviders用於儲存處於啟動狀態的Provider

               int NL = mLaunchingProviders.size();

               int j;

               for (j=0; j<NL; j++) {

                 if (mLaunchingProviders.get(j) ==dst) {

                      mLaunchingProviders.remove(j);

                      j--;

                      NL--;

                  }//

              }//for (j=0; j<NL; j++)結束

              synchronized (dst) {

                  dst.provider = src.provider;

                  dst.proc = r;

                  dst.notifyAll();

              }//synchronized結束

             updateOomAdjLocked(r);//每釋出一個Provider，需要調整對應程式的oom_adj

            }//for(int j = 0; j < names.length; j++)結束

        }//for(int i=0; i<N; i++)結束

        Binder.restoreCallingIdentity(origId);

    }// synchronized(this)結束

 }

public void systemReady(final RunnablegoingCallback) {

     synchronized(this){

       ......

       if(!mDidUpdate) {//判斷是否為升級

           if(mWaitingUpdate)   return; //升級未完成，直接返回

           //準備PRE_BOOT_COMPLETED廣播

            Intent intent = newIntent(Intent.ACTION_PRE_BOOT_COMPLETED);

           List<ResolveInfo> ris = null;

           //向PKMS查詢該廣播的接收者

            ris= AppGlobals.getPackageManager().queryIntentReceivers(

                                intent, null,0);

            ......//從返回的結果中刪除那些非系統APK的廣播接收者

            intent.addFlags(Intent.FLAG_RECEIVER_BOOT_UPGRADE);

            //讀取/data/system/called_pre_boots.dat檔案，這裡儲存了上次啟動時候已經

             //接收並處理PRE_BOOT_COMPLETED廣播的元件。鑑於該廣播的特殊性，系統希望

           //該廣播僅被這些接收者處理一次

             ArrayList<ComponentName>lastDoneReceivers =

                                          readLastDonePreBootReceivers();

              final ArrayList<ComponentName> doneReceivers=

                                         newArrayList<ComponentName>();

             ......//從PKMS返回的接收者中刪除那些已經處理過該廣播的物件

            for (int i=0; i<ris.size(); i++) {

                ActivityInfo ai = ris.get(i).activityInfo;

                 ComponentName comp = newComponentName(ai.packageName, ai.name);

                doneReceivers.add(comp);

                intent.setComponent(comp);

                IIntentReceiver finisher = null;

                if (i == ris.size()-1) {

                    //為最後一個廣播接收者註冊一個回撥通知，當該接收者處理完廣播後，將呼叫該

                   //回撥

                   finisher = new IIntentReceiver.Stub() {

                       public voidperformReceive(Intent intent, int resultCode,

                                        Stringdata, Bundle extras, boolean ordered,

                                        booleansticky) {

                                 mHandler.post(newRunnable() {

                                   public void run(){

                                   synchronized(ActivityManagerService.this) {

                                       mDidUpdate = true;

                                    }

                                 //儲存那些處理過該廣播的接收者資訊

                                 writeLastDonePreBootReceivers(doneReceivers);

                                  showBootMessage(mContext.getText(

                                        R.string.android_upgrading_complete),

                                        false);

                                   systemReady(goingCallback);

                                }//run結束

                            });// new Runnable結束

                        }//performReceive結束

                  };//finisher建立結束

              }// if (i == ris.size()-1)判斷結束

           //傳送廣播給指定的接收者

             broadcastIntentLocked(null, null, intent,null, finisher,

              0, null, null, null, true, false, MY_PID, Process.SYSTEM_UID);

            if (finisher != null)   mWaitingUpdate = true;

         }

       if(mWaitingUpdate)    return;

       mDidUpdate= true;

  }

   mSystemReady = true;

    if(!mStartRunning)  return;

   }//synchronized(this)結束

建議如有哪位讀者瞭解與此相關的知識，不妨和大家分享。

   ArrayList<ProcessRecord>procsToKill = null;

  synchronized(mPidsSelfLocked) {

     for(int i=mPidsSelfLocked.size()-1; i>=0; i--) {

         ProcessRecord proc = mPidsSelfLocked.valueAt(i);

          //從mPidsSelfLocked中找到那些先於AMS啟動的程式，哪些程式有如此能耐，

         //在AMS還未啟動完畢就啟動完了呢？對，那些宣告瞭persistent為true的程式有可能

          if(!isAllowedWhileBooting(proc.info)){

            if (procsToKill == null)

                 procsToKill = new ArrayList<ProcessRecord>();

             procsToKill.add(proc);

           }

       }//for結束

   }// synchronized結束

   synchronized(this){

       if(procsToKill != null) {

          for (int i=procsToKill.size()-1; i>=0; i--) {

             ProcessRecord proc = procsToKill.get(i);

             //把這些程式關閉，removeProcessLocked函式比較複雜，以後再分析

              removeProcessLocked(proc, true, false);

           }

        }

      //至此，系統已經準備完畢

      mProcessesReady = true;

   }

  synchronized(this) {

     if(mFactoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL) {

     }//和工廠測試有關，不對此進行討論

   }

   //查詢Settings資料，獲取一些配置引數

   retrieveSettings();

//呼叫systemReady傳入的引數，它是一個Runnable物件，下節將分析此函式

if (goingCallback != null) goingCallback.run();

 synchronized (this) {

     if(mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {

        try{

            //從PKMS中查詢那些persistent為1的ApplicationInfo

            List apps = AppGlobals.getPackageManager().

                           getPersistentApplications(STOCK_PM_FLAGS);

            if (apps != null) {

                int N = apps.size();

                 int i;

                 for (i=0; i<N; i++) {

                   ApplicationInfo info = (ApplicationInfo)apps.get(i);

                   //由於framework-res.apk已經由系統啟動，所以這裡需要把它去除

                   //framework-res.apk的packageName為"android"

                   if (info != null && !info.packageName.equals("android"))

                        addAppLocked(info);//啟動該Application所在的程式

                      }

                   }

               }......

      }

   mBooting= true; //設定mBooting變數為true，其作用後面會介紹

   try {

        if(AppGlobals.getPackageManager().hasSystemUidErrors()) {

            ......//處理那些Uid有錯誤的Application

      }......

       //啟動全系統第一個Activity，即Home

      mMainStack.resumeTopActivityLocked(null);

    }// synchronized結束

}

ActivityManagerService.self().systemReady(newRunnable() {

    publicvoid run() {

   startSystemUi(contextF);//啟動SystemUi

   //呼叫其他服務的systemReady函式

    if(batteryF != null) batteryF.systemReady();

    if(networkManagementF != null) networkManagementF.systemReady();

    ......

    Watchdog.getInstance().start();//啟動Watchdog

    ......//呼叫其他服務的systemReady函式

 }

static final void startSystemUi(Context context) {

     Intentintent = new Intent();

     intent.setComponent(new ComponentName("com.android.systemui",

                 "com.android.systemui.SystemUIService"));

       context.startService(intent);

 }

注意在精簡ROM時，也不能刪除SystemUi.apk。

final booleanresumeTopActivityLocked(ActivityRecord prev) {

   //找到下一個要啟動的Activity

  ActivityRecord next = topRunningActivityLocked(null);

   finalboolean userLeaving = mUserLeaving;

  mUserLeaving = false;

   if (next== null) {

       //如果下一個要啟動的ActivityRecord為空，則啟動Home

       if(mMainStack) {//全系統就一個ActivityStack，所以mMainStack永遠為true

          //mService指向AMS

          return mService.startHomeActivityLocked();//mService指向AMS

        }

    }

   ......//以後再詳細分析

}

boolean startHomeActivityLocked() {

   Intentintent = new Intent( mTopAction,

               mTopData != null ? Uri.parse(mTopData) :null);

   intent.setComponent(mTopComponent);

   if(mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL)

       intent.addCategory(Intent.CATEGORY_HOME);//新增Category為HOME類別

    //向PKMS查詢滿足條件的ActivityInfo

   ActivityInfo aInfo =

           intent.resolveActivityInfo(mContext.getPackageManager(),

                                  STOCK_PM_FLAGS);

    if(aInfo != null) {

       intent.setComponent(new ComponentName(

                          aInfo.applicationInfo.packageName,aInfo.name));

       ProcessRecordapp = getProcessRecordLocked(aInfo.processName,

                                             aInfo.applicationInfo.uid);

       //在正常情況下，app應該為null，因為剛開機，Home程式肯定還沒啟動

       if(app == null || app.instrumentationClass == null) {

            intent.setFlags(intent.getFlags()|

                                 Intent.FLAG_ACTIVITY_NEW_TASK);

            //啟動Home

            mMainStack.startActivityLocked(null, intent, null, null, 0, aInfo,

                                  null, null, 0, 0, 0, false, false,null);

          }

      }//if(aInfo != null)判斷結束

  return true;

}

final ActivityRecord activityIdleInternal(IBindertoken, boolean fromTimeout,

           Configuration config) {

   booleanbooting = false;

   ......

   if(mMainStack) {

      booting = mService.mBooting; //在systemReady的第三階段工作中設定該值為true

      mService.mBooting = false;

   }

   ......

   if(booting)   mService.finishBooting();//呼叫AMS的finishBooting函式

}

final void finishBooting() {

   IntentFilter pkgFilter = new IntentFilter();

   pkgFilter.addAction(Intent.ACTION_QUERY_PACKAGE_RESTART);

   pkgFilter.addDataScheme("package");

   mContext.registerReceiver(new BroadcastReceiver() {

      public void onReceive(Context context, Intent intent) {

       ......//處理Package重啟的廣播

      }

    }, pkgFilter);

  synchronized (this) {

      finalint NP = mProcessesOnHold.size();

      if (NP> 0) {

          ArrayList<ProcessRecord> procs =

                   new ArrayList<ProcessRecord>(mProcessesOnHold);

           for(int ip=0; ip<NP; ip++)//啟動那些等待啟動的程式

             startProcessLocked(procs.get(ip), "on-hold", null);

           }

       if(mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {

          //每15鍾檢查系統各應用程式使用電量的情況，如果某程式使用WakeLock時間

          //過長，AMS將關閉該程式

          Message nmsg =

                      mHandler.obtainMessage(CHECK_EXCESSIVE_WAKE_LOCKS_MSG);

          mHandler.sendMessageDelayed(nmsg, POWER_CHECK_DELAY);

           //設定系統屬性sys.boot_completed的值為1

           SystemProperties.set("sys.boot_completed","1");

          //傳送ACTION_BOOT_COMPLETED廣播

          broadcastIntentLocked(null, null,

                        newIntent(Intent.ACTION_BOOT_COMPLETED, null),

                        null, null, 0, null,null,

                       android.Manifest.permission.RECEIVE_BOOT_COMPLETED,

                        false, false, MY_PID,Process.SYSTEM_UID);

           }

        }

 }

public static void main(String[] args) {

   try {

        (newAm()).run(args);//構造一個Am物件，並呼叫run函式

   }......

 }

am start [-D] [-W] [-P <FILE>][--start-profiler <FILE>] [-S] <INTENT>

am start -W -n com.dfp.test/.TestActivity

 privatevoid run(String[] args) throws Exception {

  mAm =ActivityManagerNative.getDefault();

  mArgs =args;

  String op= args[0];

  mNextArg =1;

  if (op.equals("start"))  runStart();//用於啟動Activity

  else if ......//處理其他引數

}

 privatevoid runStart() throws Exception {

    Intentintent = makeIntent();

    StringmimeType = intent.getType();

    //獲取mimeType，

    if(mimeType == null && intent.getData() != null

         && "content".equals(intent.getData().getScheme())) {

        mimeType = mAm.getProviderMimeType(intent.getData());

    }

    if(mStopOption) {

     ......//處理-S選項，即先停止對應的Activity，再啟動它

    }

    //FLAG_ACTIVITY_NEW_TASK這個標籤很重要

   intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

   ParcelFileDescriptor fd = null;

    if(mProfileFile != null) {

         try{......//處理-P選項，用於效能統計

            fd = ParcelFileDescriptor.open(......)

          }......

    }

   IActivityManager.WaitResult result = null;

    int res;

    if(mWaitOption) {//mWaitOption控制是否等待啟動結果，如果有-W選項，則該值為true

               //呼叫AMS的startActivityAndWait函式

        result = mAm.startActivityAndWait(null,intent, mimeType,

                        null, 0, null, null, 0,false, mDebugOption,

                        mProfileFile, fd,mProfileAutoStop);

         res= result.result;

     } ......

     ......//列印結果

 }

提示為什麼選擇從am來分析Activity的啟動呢？如果選擇從一個Activity來分析如何啟動另一個Activity，則將給人一種雞生蛋、蛋孵雞的感覺，故此處選擇從am入手。除此之外，從am來分析Activity的啟動也是Activity啟動分析中相對簡單的一條路線。

 publicfinal WaitResult startActivityAndWait(

   /*

    在絕大多數情況下，一個Acitivity的啟動是由一個應用程式發起的，IApplicationThread是

    應用程式和AMS互動的通道，也可算是呼叫程式的標示，在本例中，AM並非一個應用程式，所以

    傳遞的caller為null

   */

  IApplicationThread caller,

   //Intent及resolvedType，在本例中，resolvedType為null

   Intentintent, String resolvedType,

   //下面兩個引數和授權有關，讀者可參考第3章對CopyboardService分析中介紹的授權知識

   Uri[] grantedUriPermissions,//在本例中為null

   intgrantedMode,//在本例中為0

   IBinder resultTo,//在本例中為null，用於接收startActivityForResult的結果

   StringresultWho,//在本例中為null

   //在本例中為0，該值的具體意義由呼叫者解釋。如果該值大於等於0，則AMS內部儲存該值，

   //並通過onActivityResult返回給呼叫者

   int requestCode,

   boolean onlyIfNeeded,//本例為false

   boolean debug,//是否除錯目標程式

   //下面3個引數和效能統計有關

   StringprofileFile,

   ParcelFileDescriptor profileFd, booleanautoStopProfiler)

 publicfinal WaitResult startActivityAndWait(IApplicationThread caller,

      Intent intent, String resolvedType, Uri[]grantedUriPermissions,

      int grantedMode, IBinder resultTo,StringresultWho, int requestCode,

      booleanonlyIfNeeded, boolean debug,String profileFile,

      ParcelFileDescriptor profileFd, booleanautoStopProfiler) {

     //建立WaitResult物件用於儲存處理結果

    WaitResult res = new WaitResult();

    //mMainStack為ActivityStack型別，呼叫它的startActivityMayWait函式

   mMainStack.startActivityMayWait(caller, -1, intent, resolvedType,

               grantedUriPermissions, grantedMode, resultTo, resultWho,

               requestCode, onlyIfNeeded, debug, profileFile, profileFd,

              autoStopProfiler, res, null);//最後一個引數為Configuration，

    //在本例中為null

    returnres;

 }

提示為什麼叫Activity？讀者可參考Merrian-Webster詞典對Activity的解釋[③]：“an organizational unit forperforming a specific function”，也就是說，它是一個有組織的單元，用於完成某項指定功能。

提示用過Android手機的讀者應該知道，長按Home鍵，系統會彈出近期Task列表，使使用者能快速在多個Task間切換。

/* topRunningActivityLocked:

找到棧中第一個與notTop不同的，並且不處於finishing狀態的ActivityRecord。當notTop為

null時，該函式即返回棧中第一個需要顯示的ActivityRecord。提醒讀者，棧的出入口只能是棧頂。

雖然mHistory是一個陣列，但是查詢均從陣列末端開始，所以其行為也粗略符合Stack的定義

*/

final ActivityRecordtopRunningActivityLocked(ActivityRecord notTop) {

    int i =mHistory.size()-1;

    while (i>= 0) {

        ActivityRecord r = mHistory.get(i);

         if (!r.finishing && r != notTop)  return r;

         i--;

     }

     returnnull;

  }

/* topRunningNonDelayedActivityLocked

與topRunningActivityLocked類似，但ActivityRecord要求增加一項，即delayeResume為

false

*/

final ActivityRecordtopRunningNonDelayedActivityLocked(ActivityRecord notTop) {

     int i =mHistory.size()-1;

     while(i >= 0) {

        ActivityRecord r = mHistory.get(i);

        //delayedResume變數控制是否暫緩resume Activity

         if (!r.finishing && !r.delayedResume&& r != notTop)   return r;

        i--;

     }

    returnnull;

  }

private ActivityRecord findActivityLocked(Intentintent, ActivityInfo info) {

  ComponentName cls = intent.getComponent();

   if(info.targetActivity != null)

        cls= new ComponentName(info.packageName, info.targetActivity);

   final intN = mHistory.size();

   for (inti=(N-1); i>=0; i--) {

      ActivityRecord r = mHistory.get(i);

     if (!r.finishing)

         if (r.intent.getComponent().equals(cls))return r;

   }

  return null;

 }

private ActivityRecord findTaskLocked(Intentintent, ActivityInfo info) {

  ComponentName cls = intent.getComponent();

   if(info.targetActivity != null)

        cls= new ComponentName(info.packageName, info.targetActivity);

  TaskRecord cp = null;

   final intN = mHistory.size();

   for (inti=(N-1); i>=0; i--) {

       ActivityRecord r = mHistory.get(i);

       //r.task!=cp，表示不搜尋屬於同一個Task的ActivityRecord

        if(!r.finishing && r.task != cp

                   && r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE) {

              cp = r.task;

              //如果Task的affinity相同，則返回這條ActivityRecord

              if(r.task.affinity != null) {

               if(r.task.affinity.equals(info.taskAffinity))  return r;

               }else if (r.task.intent != null

                        &&r.task.intent.getComponent().equals(cls)) {

                 //如果Task Intent的ComponentName相同

                     return r;

                }else if (r.task.affinityIntent != null

                        &&r.task.affinityIntent.getComponent().equals(cls)) {

                   //Task affinityIntent考慮

                       return r;

               }//if (r.task.affinity != null)判斷結束

         }//if(!r.finishing && r.task != cp......)判斷結束

     }//for迴圈結束

    returnnull;

 }

提示這些啟動模式和標誌，在筆者看來很像洗撲克牌時的手法，因此可以稱之為小把戲。雖是小把戲，但是相關程式碼的邏輯及分支卻異常繁雜，我們應從更高的角度來看待它們。

final int startActivityMayWait(IApplicationThreadcaller, int callingUid,

        Intentintent, String resolvedType, Uri[] grantedUriPermissions,

        intgrantedMode, IBinder resultTo,

        StringresultWho, int requestCode, boolean onlyIfNeeded,

        booleandebug, String profileFile, ParcelFileDescriptor profileFd,

        booleanautoStopProfiler, WaitResult outResult, Configuration config) {

    ......

    //在本例中，已經指明瞭Component，這樣可省去為Intent匹配搜尋之苦

    booleancomponentSpecified = intent.getComponent() != null;

    //建立一個新的Intent，防止客戶傳入的Intent被修改

    intent =new Intent(intent);

    //查詢滿足條件的ActivityInfo，在resolveActivity內部和PKMS互動，讀者不妨自己

   //嘗試分析該函式

    ActivityInfoaInfo = resolveActivity(intent, resolvedType, debug,

                     profileFile, profileFd,autoStopProfiler);

    synchronized(mService) {

      int callingPid;

      if (callingUid >= 0) {

          callingPid= -1;

      } else if (caller == null) {//本例中，caller為null

           callingPid= Binder.getCallingPid();//取出呼叫程式的Pid

           //取出呼叫程式的Uid。在本例中，呼叫程式是am，它由shell啟動

           callingUid= Binder.getCallingUid();

       } else {

           callingPid= callingUid = -1;

       }// if (callingUid >= 0)判斷結束

     //在本例中config為null

     mConfigWillChange= config != null

                  && mService.mConfiguration.diff(config) != 0;

    finallong origId = Binder.clearCallingIdentity();

    if (mMainStack && aInfo != null&&  (aInfo.applicationInfo.flags&

                  ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0){

        /*

        AndroidManifest.xml中的Application標籤可以宣告一個cantSaveState

        屬性，設定了該屬性的Application將不享受系統提供的狀態儲存/恢復功能。

        當一個Application退到後臺時，系統會為它儲存狀態，當排程其到前臺執行時，        將恢復它之前的狀態，以保證使用者體驗的連續性。宣告瞭該屬性的Application被稱為

        “heavy weight process”。可惜系統目前不支援該屬性，因為PackageParser

        將不解析該屬性。詳情請見PackageParser.java parseApplication函式

       */

    }

   ......//待續

    //呼叫此函式啟動Activity，將返回值儲存到res

   int res = startActivityLocked(caller, intent,resolvedType,

            grantedUriPermissions, grantedMode, aInfo,

            resultTo, resultWho, requestCode, callingPid, callingUid,

            onlyIfNeeded, componentSpecified, null);

     //如果configuration發生變化，則呼叫AMS的updateConfigurationLocked

    //進行處理。關於這部分內容，讀者學完本章後可自行分析

    if(mConfigWillChange && mMainStack) {

            mService.enforceCallingPermission(

                  android.Manifest.permission.CHANGE_CONFIGURATION,

                  "updateConfiguration()");

            mConfigWillChange= false;

            mService.updateConfigurationLocked(config,null, false);

   }

    if(outResult != null) {

      outResult.result = res;//設定啟動結果

       if(res == IActivityManager.START_SUCCESS) {

          //將該結果加到mWaitingActivityLaunched中儲存

           mWaitingActivityLaunched.add(outResult);

           do {

                try {

                         mService.wait();//等待啟動結果

                       }      

                } while (!outResult.timeout && outResult.who == null);

          }else if (res == IActivityManager.START_TASK_TO_FRONT) {

              ......//處理START_TASK_TO_FRONT結果，讀者可自行分析

          }

       }//if(outResult!= null)結束

           return res;

     }

 }

final int startActivityLocked(IApplicationThreadcaller,

           Intent intent, String resolvedType,

           Uri[] grantedUriPermissions,

           int grantedMode, ActivityInfo aInfo, IBinder resultTo,

           String resultWho, int requestCode,

           int callingPid, int callingUid, boolean onlyIfNeeded,

             boolean componentSpecified, ActivityRecord[]outActivity) {

   int err = START_SUCCESS;

  ProcessRecord callerApp = null;

  //如果caller不為空，則需要從AMS中找到它的ProcessRecord。本例的caller為null

   if(caller != null) {

      callerApp = mService.getRecordForAppLocked(caller);

       //其實就是想得到呼叫程式的pid和uid

       if(callerApp != null) {

           callingPid = callerApp.pid;//一定要保證呼叫程式的pid和uid正確

           callingUid = callerApp.info.uid;

          }else {//如呼叫程式沒有在AMS中註冊，則認為其是非法的

               err = START_PERMISSION_DENIED;

         }

     }// if (caller != null)判斷結束

   //下面兩個變數意義很重要。sourceRecord用於描述啟動目標Activity的那個Activity，

 //resultRecord用於描述接收啟動結果的Activity，即該Activity的onActivityResult

  //將被呼叫以通知啟動結果，讀者可先閱讀SDK中startActivityForResult函式的說明

   ActivityRecordsourceRecord = null;

  ActivityRecord resultRecord = null;

   if(resultTo != null) {

      //本例resultTo為null，

   }

   //獲取Intent設定的啟動標誌，它們是和Launch Mode相類似的“小把戲”，

  //所以，讀者務必理解“關於Launch Mode的介紹”一節的知識點

   intlaunchFlags = intent.getFlags();

   if((launchFlags&Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0

       && sourceRecord != null) {

       ......

       /*

         前面介紹的Launch Mode和Activity的啟動有關，實際上還有一部分標誌用於控制

         Activity啟動結果的通知。有關FLAG_ACTIVITY_FORWARD_RESULT的作用，讀者可

         參考SDK中的說明。使用這個標籤有個前提，即A必須先存在，正如if中sourceRecord

         不為null的判斷所示。另外，讀者自己可嘗試編寫例子，以測試FLAG_ACTIVITY_FORWARD_

         RESULT標誌的作用

      */

    }

   //檢查err值及Intent的情況

    if (err== START_SUCCESS && intent.getComponent() == null)

           err = START_INTENT_NOT_RESOLVED;

    ......

    //如果err不為0，則呼叫sendActivityResultLocked返回錯誤

    if (err!= START_SUCCESS) {

        if(resultRecord != null) {// resultRecord接收啟動結果

          sendActivityResultLocked(-1,esultRecord, resultWho, requestCode,

            Activity.RESULT_CANCELED, null);

        }

       .......

        returnerr;

    }

    //檢查許可權

    finalint perm = mService.checkComponentPermission(aInfo.permission,

            callingPid,callingUid,aInfo.applicationInfo.uid, aInfo.exported);

    ......//許可權檢查失敗的處理，不必理會

   if (mMainStack) {

       //可為AMS設定一個IActivityController型別的監聽者，AMS有任何動靜都會回撥該

       //監聽者。不過誰又有如此本領去監聽AMS呢？在進行Monkey測試的時候，Monkey會

       //設定該回撥物件。這樣，Monkey就能根據AMS放映的情況進行相應處理了

        if(mService.mController != null) {

             boolean abort = false;

            try {

                   Intent watchIntent = intent.cloneFilter();

                   //交給回撥物件處理，由它判斷是否能繼續後面的行程

                   abort = !mService.mController.activityStarting(watchIntent,

                           aInfo.applicationInfo.packageName);

               }......

            //回撥物件決定不啟動該Activity。在進行Monkey測試時，可設定黑名單，位於

            //黑名單中的Activity將不能啟動

             if (abort) {

                .......//通知resultRecord

                return START_SUCCESS;

             }

           }

      }// if(mMainStack)判斷結束

  //建立一個ActivityRecord物件

   ActivityRecordr = new ActivityRecord(mService, this, callerApp, callingUid,

               intent, resolvedType, aInfo, mService.mConfiguration,

               resultRecord, resultWho, requestCode, componentSpecified);

   if(outActivity != null)

        outActivity[0] = r;//儲存到輸入引數outActivity陣列中

   if(mMainStack) {

       //mResumedActivity代表當前介面顯示的Activity

       if(mResumedActivity == null

         || mResumedActivity.info.applicationInfo.uid!= callingUid) {

           //檢查呼叫程式是否有許可權切換Application，相關知識見下文的解釋

           if(!mService.checkAppSwitchAllowedLocked(callingPid, callingUid,

               "Activity start")) {

              PendingActivityLaunch pal = new PendingActivityLaunch();

             //如果呼叫程式沒有許可權切換Activity，則只能把這次Activity啟動請求儲存起來，

             //後續有機會時再啟動它

              pal.r = r;

              pal.sourceRecord = sourceRecord;

              ......

              //所有Pending的請求均儲存到AMS mPendingActivityLaunches變數中

              mService.mPendingActivityLaunches.add(pal);

              mDismissKeyguardOnNextActivity = false;

              return START_SWITCHES_CANCELED;

           }

      }//if(mResumedActivity == null...)判斷結束

     if (mService.mDidAppSwitch) {//用於控制app switch，見下文解釋

      mService.mAppSwitchesAllowedTime = 0;

     } else{

        mService.mDidAppSwitch = true;

     }

    //啟動處於Pending狀態的Activity

    mService.doPendingActivityLaunchesLocked(false);

   }// if(mMainStack)判斷結束

   //呼叫startActivityUncheckedLocked函式

   err =startActivityUncheckedLocked(r, sourceRecord,

            grantedUriPermissions, grantedMode, onlyIfNeeded, true);

   ......

   return err;

}

public void stopAppSwitches() {

    ......//檢查呼叫程式是否有STOP_APP_SWITCHES許可權

  synchronized(this) {

      //設定一個超時時間，過了該時間，AMS可以重新切換App（switch app）了

     mAppSwitchesAllowedTime = SystemClock.uptimeMillis()

                   + APP_SWITCH_DELAY_TIME;

     mDidAppSwitch = false;//設定mDidAppSwitch為false

     mHandler.removeMessages(DO_PENDING_ACTIVITY_LAUNCHES_MSG);

     Message msg =//防止應用程式呼叫了stop卻沒呼叫resume，5秒後處理該訊息

           mHandler.obtainMessage(DO_PENDING_ACTIVITY_LAUNCHES_MSG);

     mHandler.sendMessageDelayed(msg, APP_SWITCH_DELAY_TIME);

   }

}

 public voidresumeAppSwitches() {

    ......//檢查呼叫程式是否有STOP_APP_SWITCHES許可權

    synchronized(this) {

       mAppSwitchesAllowedTime = 0;

     }

    //注意，系統並不在此函式內啟動那些被阻止的Activity

}

final intstartActivityUncheckedLocked(ActivityRecord r,

   ActivityRecord sourceRecord, Uri[] grantedUriPermissions,

    intgrantedMode, boolean onlyIfNeeded, boolean doResume) {

   //在本例中，sourceRecord為null，onlyIfNeeded為false，doResume為true

   finalIntent intent = r.intent;

   final intcallingUid = r.launchedFromUid;

   intlaunchFlags = intent.getFlags();

   //判斷是否需要呼叫因本次Activity啟動而被系統移到後臺的當前Activity的

  //onUserLeaveHint函式。可閱讀SDK文件中關於Activity onUserLeaveHint函式的說明

  mUserLeaving = (launchFlags&Intent.FLAG_ACTIVITY_NO_USER_ACTION) ==0;

   //設定ActivityRecord的delayedResume為true，本例中的doResume為true

   if (!doResume)   r.delayedResume = true;

    //在本例中，notTop為null

    ActivityRecord notTop = (launchFlags&Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP)

               != 0 ? r : null;

    if(onlyIfNeeded) {....//在本例中，該變數為false，故略去相關程式碼

    }

   //根據sourceRecord的情況進行對應處理，能理解下面這段if/else的判斷語句嗎

   if(sourceRecord == null) {

      //如果請求的發起者為空，則當然需要新建一個Task

      if((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) == 0)

         launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;

   }else if (sourceRecord.launchMode ==ActivityInfo.LAUNCH_SINGLE_INSTANCE){

      //如果sourceRecord單獨佔一個Instance，則新的Activity必然處於另一個Task中

     launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;

   } else if(r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE

               || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) {

      //如果啟動模式設定了singleTask或singleInstance，則也要建立新Task

      launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;

   }//if(sourceRecord== null)判斷結束

   //如果新Activity和接收結果的Activity不在一個Task中，則不能啟動新的Activity

   if(r.resultTo!= null && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {

      sendActivityResultLocked(-1,r.resultTo, r.resultWho, r.requestCode,

                                     Activity.RESULT_CANCELED, null);

      r.resultTo = null;

   }

   booleanaddingToTask = false;

  TaskRecord reuseTask = null;

   if(((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0 &&

         (launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK)== 0)

               || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK

               || r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {

          if(r.resultTo == null) {

              //搜尋mHistory，得到一個ActivityRecord

                ActivityRecord taskTop = r.launchMode !=

                                   ActivityInfo.LAUNCH_SINGLE_INSTANCE

                        ?findTaskLocked(intent, r.info)

                        : findActivityLocked(intent,r.info);

               if (taskTop != null ){

                   ......//一堆複雜的邏輯處理，無非就是找到一個合適的Task，然後對應做一些

                  //處理。此處不討論這段程式碼，讀者可根據工作中的具體情況進行研究

               }

         }//if(r.resultTo == null)判斷結束

 }

   if(r.packageName != null) {

        //判斷目標Activity是否已經在棧頂，如果是，需要判斷是建立一個新的Activity

        //還是呼叫onNewIntent（singleTop模式的處理）

       ActivityRecord top = topRunningNonDelayedActivityLocked(notTop);

        if (top != null && r.resultTo == null){

            ......//不討論此段程式碼

        }//if(top != null...)結束

    } else {

         ......//通知錯誤

         returnSTART_CLASS_NOT_FOUND;

   }

  //在本例中，肯定需要建立一個Task

   booleannewTask = false;

   booleankeepCurTransition = false;

   if(r.resultTo == null && !addingToTask

               && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {

       if(reuseTask == null) {

          mService.mCurTask++;//AMS中儲存了當前Task的數量

          if (mService.mCurTask <= 0) mService.mCurTask = 1;

          //為該AactivityRecord設定一個新的TaskRecord

          r.setTask(new TaskRecord(mService.mCurTask, r.info, intent),

                                          null,true);

       }else   r.setTask(reuseTask, reuseTask,true);

      newTask = true;

      //下面這個函式為Android 4.0新增的，用於處理FLAG_ACTIVITY_TASK_ON_HOME的情況，

      //請閱讀SDK文件對Intent的相關說明

      moveHomeToFrontFromLaunchLocked(launchFlags);

   }elseif......//其他處理情況

  //授權控制。在SDK中啟動Activity的函式沒有授權設定方面的引數。在實際工作中，筆者曾碰

  //到過一個有趣的情況：在開發的一款定製系統中，用瀏覽器下載了受DRM保護的圖片，

  //此時要啟動Gallery3D來檢視該圖片，但是由於為DRM目錄設定了讀寫許可權，而Gallery3D

  //並未宣告相關許可權，結果丟擲異常，導致不能瀏覽該圖片。由於startActivity等函式不能設定

  //授權，最終只能修改Gallery3D併為其新增use-permissions項了

  if(grantedUriPermissions != null && callingUid > 0) {

         for(int i=0; i<grantedUriPermissions.length; i++) {

            mService.grantUriPermissionLocked(callingUid, r.packageName,

              grantedUriPermissions[i],grantedMode,

             r.getUriPermissionsLocked());

   }

  mService.grantUriPermissionFromIntentLocked(callingUid, r.packageName,

               intent, r.getUriPermissionsLocked());

   //呼叫startActivityLocked，此時ActivityRecord和TaskRecord均建立完畢

  startActivityLocked(r, newTask, doResume, keepCurTransition);

   return START_SUCCESS;

}//startActivityUncheckLocked函式結束

private final voidstartActivityLocked(ActivityRecord r, boolean newTask,

           boolean doResume, boolean keepCurTransition) {

   final intNH = mHistory.size();

   intaddPos = -1;

   if(!newTask){//如果不是新Task，則從mHistory中找到對應的ActivityRecord的位置

   ......

   }

   if(addPos < 0)  addPos = NH;

   //否則加到mHistory陣列的最後

   mHistory.add(addPos,r);

   //設定ActivityRecord的inHistory變數為true，表示已經加到mHistory陣列中了

  r.putInHistory();

  r.frontOfTask = newTask;

   if (NH> 0) {

    //判斷是否顯示Activity切換動畫之類的事情，需要與WindowManagerService互動

  }

   //最終呼叫resumeTopActivityLocked

   if (doResume) resumeTopActivityLocked(null);//重點分析這個函式

 }

提示筆者認為，此處將Activity切換和動畫處理這兩個邏輯揉到一起並不合適，但是似乎也沒有更合適的地方來進行該工作了。讀者不妨自行研讀一下該段程式碼以加深體會。

 finalboolean resumeTopActivityLocked(ActivityRecord prev) {

   //從mHistory中找到第一個需要啟動的ActivityRecord

  ActivityRecord next = topRunningActivityLocked(null);

   finalboolean userLeaving = mUserLeaving;

  mUserLeaving = false;

   if (next== null) {

      //如果mHistory中沒有要啟動的Activity，則啟動Home

      if(mMainStack)    returnmService.startHomeActivityLocked();

   }

   //在本例中，next將是目標Activity

   next.delayedResume= false;

   ......//和WMS互動，略去

   //將該ActivityRecord從下面幾個佇列中移除

   mStoppingActivities.remove(next);

  mGoingToSleepActivities.remove(next);

  next.sleeping = false;

  mWaitingVisibleActivities.remove(next);

   //如果當前正在中斷一個Activity，需先等待那個Activity pause完畢，然後系統會重新

   //呼叫resumeTopActivityLocked函式以找到下一個要啟動的Activity

   if(mPausingActivity != null)  return false;

   /************************請讀者注意***************************/

   //①mResumedActivity指向上一次啟動的Activity，也就是當前介面顯示的這個Activity

  //在本例中，當前Activity就是Home介面

   if(mResumedActivity != null) {

      //先中斷 Home。這種情況放到最後進行分析

      startPausingLocked(userLeaving,false);

      return true;

   }

   //②如果mResumedActivity為空，則一定是系統第一個啟動的Activity，讀者應能猜測到它就

   //是Home

   ......//如果prev不為空，則需要通知WMS進行與Activity切換相關的工作

   try {

           //通知PKMS修改該Package stop狀態，詳細資訊參考第4章“readLPw的‘佐料’”

           //一節的說明

           AppGlobals.getPackageManager().setPackageStoppedState(

                   next.packageName, false);

    }......

   if(prev!= null){

   ......//還是和WMS有關，通知它停止繪畫

   }

  if(next.app != null && next.app.thread != null) {

   //如果該ActivityRecord已有對應的程式存在，則只需要重啟Activity。就本例而言，

   //此程式還不存在，所以要先建立一個應用程式

  }  else {

           //第一次啟動

           if (!next.hasBeenLaunched) {

               next.hasBeenLaunched = true;

           } else {

               ......//通知WMS顯示啟動介面

           }

       //呼叫另外一個startSpecificActivityLocked函式

      startSpecificActivityLocked(next, true, true);

    }

    returntrue;

}

private final voidstartSpecificActivityLocked(ActivityRecord r,

           boolean andResume, boolean checkConfig) {

   //從AMS中查詢是否已經存在滿足要求的程式（根據processName和uid來查詢）

  //在本例中，查詢結果應該為null

  ProcessRecord app = mService.getProcessRecordLocked(r.processName,

               r.info.applicationInfo.uid);

   //設定啟動時間等資訊

   if(r.launchTime == 0) {

        r.launchTime = SystemClock.uptimeMillis();

       if(mInitialStartTime == 0)  mInitialStartTime = r.launchTime;

   } else if(mInitialStartTime == 0) {

           mInitialStartTime = SystemClock.uptimeMillis();

   }

   //如果該程式存在並已經向AMS註冊（例如之前在該程式中啟動了其他Activity）

   if (app!= null && app.thread != null) {

       try {

           app.addPackage(r.info.packageName);

           //通知該程式中的啟動目標Activity

           realStartActivityLocked(r, app, andResume, checkConfig);

           return;

         }......

    }

    //如果該程式不存在，則需要呼叫AMS的startProcessLocked建立一個應用程式

    mService.startProcessLocked(r.processName, r.info.applicationInfo,

              true, 0,"activity",r.intent.getComponent(), false);

}

final ProcessRecord startProcessLocked(StringprocessName,

           ApplicationInfo info, boolean knownToBeDead, int intentFlags,

           String hostingType, ComponentName hostingName,

            boolean allowWhileBooting) {

   //根據processName和uid尋找是否已經存在ProcessRecord

   ProcessRecordapp = getProcessRecordLocked(processName, info.uid);

   if (app!= null && app.pid > 0) {

       ......//處理相關情況

   }

    StringhostingNameStr = hostingName != null

               ? hostingName.flattenToShortString() : null;

   //①處理FLAG_FROM_BACKGROUND標誌，見下文解釋

   if((intentFlags&Intent.FLAG_FROM_BACKGROUND) != 0) {

       if(mBadProcesses.get(info.processName, info.uid) != null)

            return null;

     } else {

        mProcessCrashTimes.remove(info.processName,info.uid);

        if(mBadProcesses.get(info.processName, info.uid) != null) {

            mBadProcesses.remove(info.processName, info.uid);

            if (app != null)    app.bad =false;

         }

   }

    if (app== null) {

        //建立一個ProcessRecord，並儲存到mProcessNames中。注意，此時還沒有建立實際程式

        app= newProcessRecordLocked(null, info, processName);

       mProcessNames.put(processName, info.uid, app);

    }else   app.addPackage(info.packageName);

       ......

    //②呼叫另外一個startProcessLocked函式

   startProcessLocked(app, hostingType, hostingNameStr);

     return(app.pid != 0) ? app : null;

 }

提示這其實是一種安全機制，防止不健全的程式不斷啟動可能會崩潰的元件，但是這種機制並不限制使用者的行為。

private final voidstartProcessLocked(ProcessRecord app,

                            String hostingType, StringhostingNameStr) {

   if(app.pid > 0 && app.pid != MY_PID) {

       synchronized (mPidsSelfLocked) {

        mPidsSelfLocked.remove(app.pid);

        mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);

       }

      app.pid = 0;

  }

   //mProcessesOnHold用於儲存那些在系統還沒有準備好就提前請求啟動的ProcessRecord

   mProcessesOnHold.remove(app);

   updateCpuStats();

  System.arraycopy(mProcDeaths, 0, mProcDeaths, 1, mProcDeaths.length-1);

   mProcDeaths[0] = 0;

    try {

         intuid = app.info.uid;

        int[] gids = null;

           try {//從PKMS中查詢該程式所屬的gid

               gids = mContext.getPackageManager().getPackageGids(

                        app.info.packageName);

           }......

       ......//工廠測試

      intdebugFlags = 0;

      if((app.info.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {

                debugFlags |=Zygote.DEBUG_ENABLE_DEBUGGER;

              debugFlags |= Zygote.DEBUG_ENABLE_CHECKJNI;

         }......//設定其他一些debugFlags

     //傳送訊息給Zygote，它將派生一個子程式，該子程式執行ActivityThread的main函式

    //注意，我們傳遞給Zygote的引數並沒有包含任何與Activity相關的資訊。現在僅僅啟動

    //一個應用程式

    Process.ProcessStartResult startResult =

                   Process.start("android.app.ActivityThread",

                   app.processName, uid, uid, gids, debugFlags,

                   app.info.targetSdkVersion, null);

     //電量統計項

    BatteryStatsImpl bs = app.batteryStats.getBatteryStats();

    synchronized (bs) {

          if(bs.isOnBattery()) app.batteryStats.incStartsLocked();

     }

      //如果該程式為persisitent，則需要通知Watchdog，實際上processStarted內部只

      //關心剛才建立的程式是不是com.android.phone

     if(app.persistent) {

         Watchdog.getInstance().processStarted(app.processName,

                                    startResult.pid);

     }

    app.pid= startResult.pid;

   app.usingWrapper = startResult.usingWrapper;

   app.removed = false;

   synchronized (mPidsSelfLocked) {

          //以pid為key，將代表該程式的ProcessRecord物件加入到mPidsSelfLocked中保管

         this.mPidsSelfLocked.put(startResult.pid, app);

          //傳送一個超時訊息，如果這個新建立的應用程式10秒內沒有和AMS互動，則可斷定

         //該應用程式啟動失敗

         Message msg = mHandler.obtainMessage(PROC_START_TIMEOUT_MSG);

         msg.obj = app;

          //正常的超時時間為10秒。不過如果該應用程式通過valgrind載入，則延長到300秒

        //valgrind是Linux平臺上一款檢查記憶體洩露的程式，被載入的應用將在它的環境中工作，

         //這項工作需耗費較長時間。讀者可查詢valgrind的用法

          mHandler.sendMessageDelayed(msg,startResult.usingWrapper

                        ?PROC_START_TIMEOUT_WITH_WRAPPER : PROC_START_TIMEOUT);

    }......

 }

注意圖6-14中的呼叫順序及功能說明只是針對本例而言的。讀者以後可結合具體情況再深入研究其中的內容。

public static void main(String[] args) {

   SamplingProfilerIntegration.start();

   //和除錯及strictMode有關

  CloseGuard.setEnabled(false);

   //設定程式名為"<pre-initialized>"

  Process.setArgV0("<pre-initialized>");

   //準備主執行緒訊息迴圈

  Looper.prepareMainLooper();

   if(sMainThreadHandler == null)

      sMainThreadHandler = new Handler();

   //建立一個ActivityThread物件

  ActivityThread thread = new ActivityThread();

   //①呼叫attach函式，注意其引數值為false

  thread.attach(false);

  Looper.loop(); //進入主執行緒訊息迴圈

   throw newRuntimeException("Main thread loop unexpectedly exited");

}

private void attach(boolean system) {

  sThreadLocal.set(this);

  mSystemThread = system;

   if(!system) {

      ViewRootImpl.addFirstDrawHandler(new Runnable() {

          public void run() {

             ensureJitEnabled();

           }

         });

       //設定在DDMS中看到的本程式的名字為"<pre-initialized>"

      android.ddm.DdmHandleAppName.setAppName("<pre-initialized>");

       //設定RuntimeInit的mApplicationObject引數，後續會介紹RuntimeInit類

      RuntimeInit.setApplicationObject(mAppThread.asBinder());

       //獲取和AMS互動的Binder客戶端

      IActivityManager mgr = ActivityManagerNative.getDefault();

       try {

            //①呼叫AMS的attachApplication，mAppThread為ApplicationThread型別，

            //它是應用程式和AMS互動的介面

             mgr.attachApplication(mAppThread);

         }......

   } else......// system process的處理

   ViewRootImpl.addConfigCallback(newComponentCallbacks2()

   {.......//新增回撥函式});

}

private final booleanattachApplicationLocked(IApplicationThread thread,

           int pid) {//此pid代表呼叫程式的pid

   ProcessRecord app;

    if (pid != MY_PID && pid >= 0) {

        synchronized (mPidsSelfLocked) {

           app = mPidsSelfLocked.get(pid);//根據pid查詢對應的ProcessRecord物件

        }

    }else    app = null;

    /*

    如果該應用程式由AMS啟動，則它一定在AMS中有對應的ProcessRecord，讀者可回顧前面建立

    應用程式的程式碼：AMS先建立了一個ProcessRecord物件，然後才發命令給Zygote。

    如果此處app為null，表示AMS沒有該程式的記錄，故需要“殺死”它

   */

    if (app== null) {

       if(pid > 0 && pid != MY_PID) //如果pid大於零，且不是SystemServer程式，則

           //Quietly（即不列印任何輸出）”殺死”process

           Process.killProcessQuiet(pid);

       else{

           //呼叫ApplicationThread的scheduleExit函式。應用程式完成處理工作後

           //將退出執行

           //為何不像上面一樣直接殺死它呢？可查閱linux pid相關的知識並自行解答

          thread.scheduleExit();

        }

      returnfalse;

   }

   /*

     判斷app的thread是否為空，如果不為空，則表示該ProcessRecord物件還未和一個

     應用程式繫結。注意，app是根據pid查詢到的，如果舊程式沒有被殺死，系統則不會重用

     該pid。為什麼此處會出現ProcessRecord thread不為空的情況呢？見下面程式碼的註釋說明

   */

   if(app.thread != null)  handleAppDiedLocked(app, true, true);

   StringprocessName = app.processName;

   try {

          /*

          建立一個應用程式訃告接收物件。當應用程式退出時，該物件的binderDied將被調

          用。這樣，AMS就能做相應處理。binderDied函式將在另外一個執行緒中執行，其內部也會

          呼叫handleAppDiedLocked。假如使用者在binderDied被呼叫之前又啟動一個程式，

          那麼就會出現以上程式碼中app.thread不為null的情況。這是多執行緒環境中常出現的

          情況，不熟悉多執行緒程式設計的讀者要仔細體會。

          */

         AppDeathRecipient adr = new AppDeathRecipient(pp, pid, thread);

         thread.asBinder().linkToDeath(adr, 0);

         app.deathRecipient = adr;

    }......

   //設定該程式的排程優先順序和oom_adj等成員

   app.thread= thread;

  app.curAdj = app.setAdj = -100;

  app.curSchedGroup = Process.THREAD_GROUP_DEFAULT;

  app.setSchedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;

  app.forcingToForeground = null;

  app.foregroundServices = false;

  app.hasShownUi = false;

  app.debugging = false;

   //啟動成功，從訊息佇列中撤銷PROC_START_TIMEOUT_MSG訊息

  mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);

   ......

   //SystemServer早就啟動完畢，所以normalMode為true

   booleannormalMode = mProcessesReady || isAllowedWhileBooting(app.info);

   /*

    我們在6.2.3的標題1中分析過generateApplicationProvidersLocked函式，

    在該函式內部將查詢（根據程式名，uid確定）PKMS以獲取需執行在該程式中的ContentProvider

   */

   Listproviders = normalMode ? generateApplicationProvidersLocked(app) : null;

   try {

         int testMode = IApplicationThread.DEBUG_OFF;

          if(mDebugApp != null && mDebugApp.equals(processName)) {

               ......//處理debug選項

          }

          ......//處理Profile

          boolean isRestrictedBackupMode = false;

          ......//

          //dex化對應的apk包

          ensurePackageDexOpt(app.instrumentationInfo!= null ?

                app.instrumentationInfo.packageName : app.info.packageName);

         //如果設定了Instrumentation類，該類所在的Package也需要dex化

         if(app.instrumentationClass != null)

              ensurePackageDexOpt(app.instrumentationClass.getPackageName());

          ApplicationInfo appInfo =app.instrumentationInfo != null

                             ? app.instrumentationInfo :app.info;

         //查詢該Application使用的CompatibiliyInfo

         app.compat =compatibilityInfoForPackageLocked(appInfo);

         if (profileFd != null) //用於記錄效能檔案

               profileFd = profileFd.dup();

           //①通過ApplicationThread和應用程式互動，呼叫其bindApplication函式

            thread.bindApplication(processName,appInfo, providers,

                   app.instrumentationClass, profileFile, profileFd,

                    profileAutoStop,app.instrumentationArguments,

                    app.instrumentationWatcher,testMode,

                   isRestrictedBackupMode || !normalMode, app.persistent,

                   mConfiguration, app.compat, getCommonServicesLocked(),

                   mCoreSettingsObserver.getCoreSettingsLocked());

           //updateLruProcessLocked函式以後再作分析

           updateLruProcessLocked(app,false, true);

           //記錄兩個時間

           app.lastRequestedGc= app.lastLowMemory = SystemClock.uptimeMillis();

   }......//try結束

..//從mProcessesOnHold和mPersistentStartingProcesses中刪除相關資訊

   mPersistentStartingProcesses.remove(app);

  mProcessesOnHold.remove(app);

/*

   正如我們在前面分析時提到的，剛建立的這個程式並不知道自己的歷史使命是什麼，甚至連自己的

   程式名都不知道，只能設為"<pre-initialized>"。其實，Android應用程式的歷史使命是

   AMS在其啟動後才賦予它的，這一點和我們理解的一般意義上的程式不太一樣。根據之前的介紹，   Android的元件應該執行在Android執行環境中。從OS角度來說，該執行環境需要和一個程式繫結。

   所以，建立應用程式這一步只是建立了一個能執行Android執行環境的容器，而我們的工作實際上

   還遠未結束。

   bindApplication的功能就是建立並初始化位於該程式中的Android執行環境

*/

public final void bindApplication(

       StringprocessName,//程式名，一般是package名

      ApplicationInfo appInfo,//該程式對應的ApplicationInfo

       List<ProviderInfo> providers,//在該APackage中宣告的Provider資訊

       ComponentName instrumentationName,//和instrumentation有關

       //下面3個引數和效能統計有關

       StringprofileFile,

      ParcelFileDescriptor profileFd, boolean autoStopProfiler,

      //這兩個和Instrumentation有關，在本例中，這幾個引數暫時都沒有作用

      Bundle instrumentationArgs,

       IInstrumentationWatcherinstrumentationWatcher,

       intdebugMode,//除錯模式

       boolean isRestrictedBackupMode,

       boolean persistent,//該程式是否是persist

       Configuration config,//當前的配置資訊，如螢幕大小和語言等

       CompatibilityInfocompatInfo,//相容資訊

       //AMS將常用的Service資訊傳遞給應用程式，目前傳遞的Service資訊只有PKMS、

       //WMS及AlarmManagerService。讀者可參看AMS getCommonServicesLocked函式

       Map<String,IBinder> services,

       BundlecoreSettings)//核心配置引數，目前僅有“long_press”值

   booleanbadApp = false;

   booleandidSomething = false;

   /*

   至此，應用程式已經準備好了Android執行環境，下面這句呼叫程式碼將返回ActivityStack中

   第一個需要執行的ActivityRecord。由於多執行緒的原因，難道能保證得到的hr就是我們的目標

   Activity嗎？

   */

  ActivityRecord hr = mMainStack.topRunningActivityLocked(null);

  if (hr !=null && normalMode) {

       //需要根據processName和uid等確定該Activity是否執行與目標程式有關

       if(hr.app == null && app.info.uid == hr.info.applicationInfo.uid

            && processName.equals(hr.processName)) {

            try {

               //呼叫AS的realStartActivityLocked啟動該Activity，最後兩個引數為true

                if (mMainStack.realStartActivityLocked(hr, app, true, true)) {

                      didSomething = true;

                 }

            } catch (Exception e) {

                  badApp = true; //設定badApp為true

            }

      } else{

         //如果hr和目標程式無關，則呼叫ensureActivitiesVisibleLocked函式處理它

        mMainStack.ensureActivitiesVisibleLocked(hr, null, processName, 0);

       }

 }// if (hr!= null && normalMode)判斷結束

   //mPendingServices儲存那些因目標程式還未啟動而處於等待狀態的ServiceRecord

   if(!badApp && mPendingServices.size() > 0) {

       ServiceRecord sr = null;

        try{

           for (int i=0; i<mPendingServices.size(); i++) {

                sr = mPendingServices.get(i);

                //和Activity不一樣的是，如果Service不屬於目標程式，則暫不處理

                if (app.info.uid != sr.appInfo.uid

                     ||!processName.equals(sr.processName)) continue;//繼續迴圈

                   //該Service將執行在目標程式中，所以從mPendingService中移除它

                   mPendingServices.remove(i);

                   i--;

                   //處理此service的啟動，以後再作分析

                   realStartServiceLocked(sr, app);

                   didSomething = true;//設定該值為true

               }

           }

      }......

   ......//啟動等待的BroadcastReceiver

   ......//啟動等待的BackupAgent，相關程式碼類似Service的啟動

  if(badApp) {

   //如果以上幾個元件啟動有錯誤，則設定badApp為true。此處將呼叫handleAppDiedLocked

   //進行處理。該函式我們以後再作分析

   handleAppDiedLocked(app, false, true);

    returnfalse;

  }

   /*

   調整程式的oom_adj值。didSomething表示在以上流程中是否啟動了Acivity或其他元件。

   如果啟動了任一元件，則didSomething為true。讀者以後會知道，這裡的啟動只是向

   應用程式發出對應的指令，客戶端程式是否成功處理還是未知數。基於這種考慮，所以此處不宜

   馬上調節程式的oom_adj。

   讀者可簡單地把oom_adj看做一種優先順序。如果一個應用程式沒有執行任何元件，那麼當記憶體

   出現不足時，該程式是最先被系統殺死的。反之，如果一個程式執行的元件越多，那麼它就越不易被

   系統殺死以回收記憶體。updateOomAdjLocked就是根據該程式中元件的情況對應調節程式的

   oom_adj值的。

  */

   if(!didSomething)  updateOomAdjLocked();

   returntrue;

 }

提示還記得AMS中System Context執行的兩次init嗎？第二次init的功能就是將Context和對應的Application繫結在一起。

public final void bindApplication(......) {

   if(services != null)//儲存AMS傳遞過來的系統Service資訊

       ServiceManager.initServiceCache(services);

    //向主執行緒訊息佇列新增SET_CORE_SETTINGS訊息

   setCoreSettings(coreSettings);

     //建立一個AppBindData物件，其實就是用來儲存一些引數

    AppBindData data = new AppBindData();

    data.processName = processName;

    data.appInfo = appInfo;

    data.providers = providers;

    data.instrumentationName = instrumentationName;

    ......//將AMS傳過來的引數儲存到AppBindData中

     //向主執行緒傳送H.BIND_APPLICATION訊息

    queueOrSendMessage(H.BIND_APPLICATION, data);

 }

private void handleBindApplication(AppBindDatadata) {

   mBoundApplication = data;

   mConfiguration = new Configuration(data.config);

   mCompatConfiguration = new Configuration(data.config);

    //初始化效能統計物件

   mProfiler = new Profiler();

   mProfiler.profileFile = data.initProfileFile;

   mProfiler.profileFd = data.initProfileFd;

   mProfiler.autoStopProfiler = data.initAutoStopProfiler;

    //設定程式名。從此，之前那個默默無名的程式終於有了自己的名字

   Process.setArgV0(data.processName);

   android.ddm.DdmHandleAppName.setAppName(data.processName);

    if(data.persistent) {

       //對於persistent的程式，在低記憶體裝置上，不允許其使用硬體加速顯示

       Display display =

                 WindowManagerImpl.getDefault().getDefaultDisplay();

       //當記憶體大於512MB，或者螢幕尺寸大於1024*600，可以使用硬體加速

       if(!ActivityManager.isHighEndGfx(display))

           HardwareRenderer.disable(false);

     }

    //啟動效能統計

     if(mProfiler.profileFd != null)   mProfiler.startProfiling();

   //如果目標SDK版本小於12，則設定AsyncTask使用pool executor，否則使用

   //serializedexecutor。這些executor涉及Java Concurrent類，對此不熟悉的讀者

   //請自行學習和研究。

   if(data.appInfo.targetSdkVersion <= 12)

           AsyncTask.setDefaultExecutor(AsyncTask.THREAD_POOL_EXECUTOR);

    //設定timezone

   TimeZone.setDefault(null);

    //設定語言

    Locale.setDefault(data.config.locale);

     //設定資源及相容模式

    applyConfigurationToResourcesLocked(data.config, data.compatInfo);

    applyCompatConfiguration();

      //根據傳遞過來的ApplicationInfo建立一個對應的LoadApk物件

     data.info = getPackageInfoNoCheck(data.appInfo, data.compatInfo);

     //對於系統APK，如果當前系統為userdebug/eng版，則需要記錄log資訊到dropbox的日誌記錄

     if((data.appInfo.flags &

            (ApplicationInfo.FLAG_SYSTEM |

             ApplicationInfo.FLAG_UPDATED_SYSTEM_APP)) != 0) {

           StrictMode.conditionallyEnableDebugLogging();

    }

    /*

    如目標SDK版本大於9，則不允許在主執行緒使用網路操作（如Socketconnect等），否則丟擲

    NetworkOnMainThreadException，這麼做的目的是防止應用程式在主執行緒中因網路操作執行

    時間過長而造成使用者體驗下降。說實話，沒有必要進行這種限制，在主執行緒中是否網路操作

    是應用的事情。再說，Socket也可作為程式間通訊的手段，在這種情況下，網路操作耗時很短。

    作為系統，不應該設定這種限制。另外，Goolge可以提供一些開發指南或規範來指導開發者，

    而不應如此蠻橫地強加限制。

    */

    if (data.appInfo.targetSdkVersion> 9)

        StrictMode.enableDeathOnNetwork();

    //如果沒有設定螢幕密度，則為Bitmap設定預設的螢幕密度

   if((data.appInfo.flags

               &ApplicationInfo.FLAG_SUPPORTS_SCREEN_DENSITIES) == 0)

    Bitmap.setDefaultDensity(DisplayMetrics.DENSITY_DEFAULT);

   if(data.debugMode != IApplicationThread.DEBUG_OFF){

    ......//除錯模式相關處理

   }

   IBinder b= ServiceManager.getService(Context.CONNECTIVITY_SERVICE);

  IConnectivityManager service =

                        IConnectivityManager.Stub.asInterface(b);

  try {

       //設定Http代理資訊

       ProxyPropertiesproxyProperties = service.getProxy();

      Proxy.setHttpProxySystemProperty(proxyProperties);

   } catch(RemoteException e) {}

   if(data.instrumentationName != null){

        //在正常情況下，此條件不滿足

   } else {

      //建立Instrumentation物件，在正常情況都再這個條件下執行

     mInstrumentation = new Instrumentation();

   }

   //如果Package中宣告瞭FLAG_LARGE_HEAP，則可跳過虛擬機器的記憶體限制，放心使用記憶體

   if((data.appInfo.flags&ApplicationInfo.FLAG_LARGE_HEAP) != 0)

        dalvik.system.VMRuntime.getRuntime().clearGrowthLimit();

   //建立一個Application，data.info為LoadedApk型別，在其內部會通過Java反射機制

   //建立一個在該APK AndroidManifest.xml中宣告的Application物件

   Applicationapp = data.info.makeApplication(

                                     data.restrictedBackupMode, null);

 //mInitialApplication儲存該程式中第一個建立的Application

  mInitialApplication = app;

   //安裝本Package中攜帶的ContentProvider

   if(!data.restrictedBackupMode){

      List<ProviderInfo> providers = data.providers;

        if(providers != null) {

               //installContentProviders我們已經分析過了

               installContentProviders(app, providers);

               mH.sendEmptyMessageDelayed(H.ENABLE_JIT, 10*1000);

           }

  }

   //呼叫Application的onCreate函式，做一些初始工作

  mInstrumentation.callApplicationOnCreate(app);

}

提示從以上程式碼可知，ContentProvider的建立就在bindApplication函式中，其時機早於其他元件的建立。

提示這個流程有點類似生孩子，一般生之前需要到醫院去登記，生完後又需去註冊戶口，如此這般，這個孩子才會在社會有合法的身份。

//注意，在本例中該函式的最後兩個引數的值都為true

final booleanrealStartActivityLocked(ActivityRecord r, ProcessRecord app,

       boolean andResume, boolean checkConfig)   throws RemoteException {

   r.startFreezingScreenLocked(app, 0);

    mService.mWindowManager.setAppVisibility(r,true);

    if(checkConfig) {

       ......//處理Config發生變化的情況

      mService.updateConfigurationLocked(config, r, false);

    }

    r.app =app;

   app.waitingToKill = null;

    //將ActivityRecord加到ProcessRecord的activities中儲存

    int idx= app.activities.indexOf(r);

    if (idx< 0)   app.activities.add(r);

    //更新程式的排程優先順序等，以後再分析該函式

    mService.updateLruProcessLocked(app, true, true);

     try {

        List<ResultInfo> results = null;

        List<Intent> newIntents = null;

         if(andResume) {

               results = r.results;

               newIntents = r.newIntents;

           }

          if(r.isHomeActivity)  mService.mHomeProcess = app;

        //看看是否有dex對應Package的需要

         mService.ensurePackageDexOpt(

                   r.intent.getComponent().getPackageName());

        r.sleeping = false;

        r.forceNewConfig = false;

       ......

          //①通知應用程式啟動Activity

           app.thread. scheduleLaunchActivity (new Intent(r.intent), r,

                   System.identityHashCode(r), r.info, mService.mConfiguration,

                   r.compat, r.icicle, results, newIntents, !andResume,

                   mService.isNextTransitionForward(), profileFile, profileFd,

                    profileAutoStop);

           if ((app.info.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {

               ......//處理heavy-weight的情況

               }

           }

     } ......//try結束

    r.launchFailed = false;

     ......

     if(andResume) {

         r.state = ActivityState.RESUMED;

         r.stopped = false;

        mResumedActivity = r;//設定mResumedActivity為目標Activity

        r.task.touchActiveTime();

         //新增該任務到近期任務列表中

         if(mMainStack)  mService.addRecentTaskLocked(r.task);

         //②關鍵函式，見下文分析

        completeResumeLocked(r);

         //如果在這些過程中，使用者按了Power鍵，怎麼辦？

        checkReadyForSleepLocked();

        r.icicle = null;

        r.haveState = false;

    }......

    //啟動系統設定嚮導Activity，當系統更新或初次使用時需要進行配置

    if(mMainStack)  mService.startSetupActivityLocked();

    returntrue;

 }

public final void scheduleLaunchActivity(Intentintent, IBinder token, int ident,

     ActivityInfo info, Configuration curConfig,CompatibilityInfo compatInfo,

     Bundlestate, List<ResultInfo> pendingResults,

    List<Intent> pendingNewIntents, boolean notResumed, booleanisForward,

     StringprofileName, ParcelFileDescriptor profileFd,

     booleanautoStopProfiler) {

  ActivityClientRecord r = new ActivityClientRecord();

   ......//儲存AMS傳送過來的引數資訊

   //向主執行緒傳送訊息，該訊息的處理在handleLaunchActivity中進行

  queueOrSendMessage(H.LAUNCH_ACTIVITY, r);

 }

public void handleMessage(Message msg) {

  switch(msg.what) {

       case LAUNCH_ACTIVITY: {

        ActivityClientRecord r = (ActivityClientRecord)msg.obj;

        //根據ApplicationInfo得到對應的PackageInfo

        r.packageInfo = getPackageInfoNoCheck(

                           r.activityInfo.applicationInfo, r.compatInfo);

         //呼叫handleLaunchActivity處理

        handleLaunchActivity(r, null);

       }break;

......

}

private voidhandleLaunchActivity(ActivityClientRecord r,

                             Intent customIntent){

   unscheduleGcIdler();

   if (r.profileFd != null) {......//略去}

  handleConfigurationChanged(null, null);

   /*

   ①建立Activity，通過Java反射機制建立目標Activity，將在內部完成Activity生命週期

   的前兩步，即呼叫其onCreate和onStart函式。至此，我們的目標com.dfp.test.TestActivity

   建立完畢

   */

   Activitya = performLaunchActivity(r, customIntent);

   if (a !=null) {

     r.createdConfig = new Configuration(mConfiguration);

      BundleoldState = r.state;

      //②呼叫handleResumeActivity，其內部有個關鍵點，見下文分析

     handleResumeActivity(r.token, false, r.isForward);

      if(!r.activity.mFinished && r.startsNotResumed) {

         .......//

.       r.paused = true;

       }else {

            //如果啟動錯誤，通知AMS

           ActivityManagerNative.getDefault()

                    .finishActivity(r.token,Activity.RESULT_CANCELED, null);

      }

  }

final void handleResumeActivity(IBinder token,boolean clearHide,

                                     booleanisForward) {

 unscheduleGcIdler();

  //內部呼叫目標Activity的onResume函式

 ActivityClientRecord r = performResumeActivity(token, clearHide);

  if (r !=null) {

   finalActivity a = r.activity;

   final int forwardBit = isForward ?

          WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;

   ......

   if(!r.onlyLocalRequest) {

       //將上面完成onResume的Activity儲存到mNewActivities中

      r.nextIdle = mNewActivities;

      mNewActivities = r;

      //①向訊息佇列中新增一個Idler物件

     Looper.myQueue().addIdleHandler(new Idler());

   }

   r.onlyLocalRequest = false;

   ......

 }

private class Idler implements MessageQueue.IdleHandler{

    publicfinal boolean queueIdle() {

   ActivityClientRecord a = mNewActivities;

    booleanstopProfiling = false;

    ......

   if (a !=null) {

    mNewActivities = null;

    IActivityManager am = ActivityManagerNative.getDefault();

    ActivityClientRecord prev;

    do {

       if(a.activity != null && !a.activity.mFinished) {

          //呼叫AMS的activityIdle

          am.activityIdle(a.token, a.createdConfig, stopProfiling);

          a.createdConfig = null;

      }

     prev =a;

     a =a.nextIdle;

    prev.nextIdle = null;

    } while(a != null); //do迴圈結束

  }//if(a!=null)判斷結束

   ......

   ensureJitEnabled();

    returnfalse;

   }// queueIdle函式結束

 }

private final voidcompleteResumeLocked(ActivityRecord next) {

   next.idle = false;

   next.results = null;

   next.newIntents = null;

   //傳送一個超時處理訊息，預設為10秒。IDLE_TIMEOUT_MSG就是針對acitivityIdle函式的

    Messagemsg = mHandler.obtainMessage(IDLE_TIMEOUT_MSG);

    msg.obj= next;

   mHandler.sendMessageDelayed(msg, IDLE_TIMEOUT);

     //通知AMS

     if(mMainStack)   mService.reportResumedActivityLocked(next);

     ......//略去其他邏輯的程式碼

}

final ActivityRecord activityIdleInternal(IBindertoken, boolean fromTimeout,

                                      Configuration config) {

   /*

   如果應用程式在超時時間內呼叫了activityIdleInternal函式，則fromTimeout為false

   否則，一旦超時，在IDLE_TIMEOUT_MSG的訊息處理中也會呼叫該函式，並設定fromTimeout

   為true

   */

   ActivityRecord res = null;

  ArrayList<ActivityRecord> stops = null;

  ArrayList<ActivityRecord> finishes = null;

  ArrayList<ActivityRecord> thumbnails = null;

   int NS =0;

   int NF =0;

   int NT =0;

  IApplicationThread sendThumbnail = null;

   booleanbooting = false;

   booleanenableScreen = false;

  synchronized (mService) {

     //從訊息佇列中撤銷IDLE_TIMEOUT_MSG

     if(token != null)   mHandler.removeMessages(IDLE_TIMEOUT_MSG, token);

      int index= indexOfTokenLocked(token);

      if(index >= 0) {

        ActivityRecord r = mHistory.get(index);

         res =r;

        //注意，只有fromTimeout為true，才會走執行下面的條件語句

        if(fromTimeout) reportActivityLaunchedLocked(fromTimeout, r, -1, -1);

        if(config != null)  r.configuration =config;

        /*

        mLaunchingActivity是一個WakeLock，它能防止在操作Activity過程中掉電，同時

        這個WakeLock又不能長時間使用，否則有可能耗費過多電量。所以，系統設定了一個超時

        處理訊息LAUNCH_TIMEOUT_MSG，超時時間為10秒。一旦目標Activity啟動成功，

        就需要需要釋放 WakeLock

        */

        if(mResumedActivity == r && mLaunchingActivity.isHeld()) {

            mHandler.removeMessages(LAUNCH_TIMEOUT_MSG);

            mLaunchingActivity.release();

         }

       r.idle = true;

       mService.scheduleAppGcsLocked();

       ......

       ensureActivitiesVisibleLocked(null, 0);

     if(mMainStack) {

         if(!mService.mBooted) {

            mService.mBooted = true;

             enableScreen = true;

          }

       }//if (mMainStack)判斷結束

   } else if(fromTimeout) {//注意，只有fromTimeout為true，才會走下面的case

       reportActivityLaunchedLocked(fromTimeout, null, -1, -1);

  }

  /*

   ①processStoppingActivitiesLocked函式返回那些因本次Activity啟動而

   被暫停（paused）的Activity

  */

  stops =processStoppingActivitiesLocked(true);

 ......

   for (i=0;i<NS; i++) {

      ActivityRecord r = (ActivityRecord)stops.get(i);

       synchronized (mService) {

      //如果這些Acitivity 處於finishing狀態，則通知它們執行Destroy操作，最終它們

     //的onDestroy函式會被呼叫

       if(r.finishing) finishCurrentActivityLocked(r, FINISH_IMMEDIATELY);

       else  //否則將通知它們執行stop操作，最終Activity的onStop被呼叫

         stopActivityLocked(r);

       }//synchronized結束

  }//for迴圈結束

   ......//處理等待結束的Activities

   //傳送ACTION_BOOT_COMPLETED廣播

   if(booting)  mService.finishBooting();

   ......

   returnres;

 }

提示本例的分析結束了嗎？沒有。因為am設定了-W選項，所以其實我們還在startActivityAndWait函式中等待結果。ActivityStack中有兩個函式能夠觸發AMS notifyAll，一個是reportActivityLaunchedLocked，另一個是reportActivityVisibleLocked。前面介紹的activityInternal函式只在fromTimeout為true時才會呼叫reportActivityLaunchedLocked，而本例中fromTimeout為false，如何是好？該問題的解答非常複雜，姑且先一語帶過：當Activity顯示出來時，其在AMS中對應ActivityRecord物件的windowVisible函式將被呼叫，其內部會觸發reportActivityLaunchedLocked函式，這樣我們的startActivityAndWait才能被喚醒。

private final void startPausingLocked(booleanuserLeaving, boolean uiSleeping) {

   //mResumedActivity儲存當前正顯示的Activity，

  ActivityRecord prev = mResumedActivity;

  mResumedActivity = null;

   //設定mPausingActivity為當前Activity

  mPausingActivity = prev;

  mLastPausedActivity = prev;

  prev.state = ActivityState.PAUSING;//設定狀態為PAUSING

  prev.task.touchActiveTime();

   ......

   if(prev.app != null && prev.app.thread != null) {

     try {

        //①呼叫當前Activity所在程式的schedulePauseActivity函式

        prev.app.thread.schedulePauseActivity(prev,prev.finishing,

                                userLeaving,prev.configChangeFlags);

       if(mMainStack) mService.updateUsageStats(prev, false);

     } ......//catch分支

    }......//else分支

   if(!mService.mSleeping && !mService.mShuttingDown) {

        //獲取WakeLock，以防止在Activity切換過程中掉電

       mLaunchingActivity.acquire();

        if(!mHandler.hasMessages(LAUNCH_TIMEOUT_MSG)) {

            Message msg = mHandler.obtainMessage(LAUNCH_TIMEOUT_MSG);

            mHandler.sendMessageDelayed(msg, LAUNCH_TIMEOUT);

        }

   }

    if(mPausingActivity != null) {

      //暫停輸入事件派發

      if(!uiSleeping) prev.pauseKeyDispatchingLocked();

     //設定PAUSE超時，時間為500毫秒，這個時間相對較短

     Message msg = mHandler.obtainMessage(PAUSE_TIMEOUT_MSG);

     msg.obj = prev;

     mHandler.sendMessageDelayed(msg, PAUSE_TIMEOUT);

    }......//else分支

 }

private void handlePauseActivity(IBinder token,boolean finished,

                               boolean userLeaving, int configChanges){

  //當Activity處於finishing狀態時，finished引數為true，不過在本例中該值為false

  ActivityClientRecord r = mActivities.get(token);

   if (r !=null) {

      //呼叫Activity的onUserLeaving函式，

      if(userLeaving) performUserLeavingActivity(r);

      r.activity.mConfigChangeFlags |=configChanges;

      //呼叫Activity的onPause函式

     performPauseActivity(token, finished, r.isPreHoneycomb());

      ......

      try {

             //呼叫AMS的activityPaused函式

             ActivityManagerNative.getDefault().activityPaused(token);

         }......

    }

 }

public final void activityPaused(IBinder token) {

   ......

   mMainStack.activityPaused(token, false);

}

final void activityPaused(IBinder token, booleantimeout) {

 ActivityRecord r = null;

  synchronized (mService) {

   int index= indexOfTokenLocked(token);

   if (index>= 0) {

        r =mHistory.get(index);

         //從訊息佇列中撤銷PAUSE_TIMEOUT_MSG訊息

        mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);

         if(mPausingActivity == r) {

            r.state = ActivityState.PAUSED;//設定ActivityRecord的狀態

            completePauseLocked();//完成本次Pause操作

        }......

   }

 }

private final void completePauseLocked() {

  ActivityRecord prev = mPausingActivity;

   if (prev!= null) {

     if(prev.finishing) {

          prev = finishCurrentActivityLocked(prev, FINISH_AFTER_VISIBLE);

      } elseif (prev.app != null) {

        if(prev.configDestroy) {

             destroyActivityLocked(prev, true, false);

         } else {

          //①將剛才被暫停的Activity儲存到mStoppingActivities中

          mStoppingActivities.add(prev);

          if(mStoppingActivities.size() > 3) {

            //如果被暫停的Activity超過3個，則傳送IDLE_NOW_MSG訊息，該訊息最終

           //由我們前面介紹的activeIdleInternal處理

             scheduleIdleLocked();

            }

         }

      //設定mPausingActivity為null，這是圖6-14②、③分支的分割點

       mPausingActivity = null;

    }

     //②resumeTopActivityLocked將啟動目標Activity

    if(!mService.isSleeping()) resumeTopActivityLocked(prev);

   ......

}

 privatefinal void stopActivityLocked(ActivityRecord r) {

   if((r.intent.getFlags()&Intent.FLAG_ACTIVITY_NO_HISTORY) != 0

           || (r.info.flags&ActivityInfo.FLAG_NO_HISTORY) != 0) {

       if(!r.finishing) {

           requestFinishActivityLocked(r, Activity.RESULT_CANCELED, null,

                       "no-history");

         }

     } elseif (r.app != null && r.app.thread != null) {

         try {

         r.stopped = false;

          //設定STOPPING狀態，並呼叫對應的scheduleStopActivity函式

          r.state = ActivityState.STOPPING;

          r.app.thread.scheduleStopActivity(r, r.visible,

                     r.configChangeFlags);

    }......

  }

private void handleStopActivity(IBinder token,boolean show, int configChanges) {

 ActivityClientRecord r = mActivities.get(token);

 r.activity.mConfigChangeFlags |= configChanges;

  StopInfoinfo = new StopInfo();

  //呼叫Activity的onStop函式

 performStopActivityInner(r, info, show, true);

 ......

  try { //呼叫AMS的activityStopped函式

        ActivityManagerNative.getDefault().activityStopped(

               r.token, r.state, info.thumbnail, info.description);

   }

}

建議在研究程式碼前，先仔細閱讀SDK文件相關內容，以獲取必要的感性認識，否則直接看程式碼很容易迷失方向。

/*

  在SDK中輸出該函式，這也是最常用的函式。當廣播到來時，BroadcastReceiver物件的onReceive

  函式將在主執行緒中被呼叫

*/

public Intent registerReceiver(BroadcastReceiverreceiver, IntentFilter filter) {

    returnregisterReceiver(receiver, filter, null, null);

 }

/*

   功能和前面類似，但增加了兩個引數，分別是broadcastPermission和scheduler，作用有

   兩個：

   其一：對廣播者的許可權增加了控制，只有擁有相應許可權的廣播者發出的廣播才能被此接收者接收

   其二：BroadcastReceiver物件的onReceiver函式可排程到scheduler所在的執行緒中執行

*/

 publicIntent registerReceiver(BroadcastReceiver receiver,

       IntentFilterfilter, String broadcastPermission, Handler scheduler) {

/*

 注意，下面所呼叫函式的最後一個引數為getOuterContext的返回值。前面曾說過，ContextImpl為Context家族中真正幹活的物件，而它對外的代理人可以是Application和Activity等，

getOuterContext就返回這個對外代理人。一般在Activity中呼叫registerReceiver函式，故此處getOuterContext返回的對外代理人的型別就是Activity。

*/

     returnregisterReceiverInternal(receiver, filter, broadcastPermission,

               scheduler, getOuterContext());

}

 privateIntent registerReceiverInternal(BroadcastReceiver receiver,

      IntentFilter filter, String broadcastPermission, Handler scheduler,

      Context context) {

   IIntentReceiver rd = null;

   if(receiver != null) {

        //①準備一個IIntentReceiver物件

        if(mPackageInfo != null && context != null) {

          //如果沒有設定scheduler，則預設使用主執行緒的Handler

          if (scheduler == null)   scheduler= mMainThread.getHandler();

          //通過getReceiverDispatcher函式得到一個IIntentReceiver型別的物件

          rd = mPackageInfo.getReceiverDispatcher(

             receiver, context, scheduler, mMainThread.getInstrumentation(),

             true);

        } else {

          if (scheduler == null)  scheduler= mMainThread.getHandler();

          //直接建立LoadedApk.ReceiverDispatcher物件

          rd = new LoadedApk.ReceiverDispatcher(receiver, context, scheduler,

                   null, true).getIIntentReceiver();

         }//if (mPackageInfo != null && context != null)結束

     }// if(receiver != null)結束

  try {

        //②呼叫AMS的registerReceiver函式

       return ActivityManagerNative.getDefault().registerReceiver(

                     mMainThread.getApplicationThread(),mBasePackageName,

                     rd, filter,broadcastPermission);

        } ......

 }

public Intent registerReceiver(IApplicationThreadcaller, String callerPackage,

           IIntentReceiver receiver, IntentFilter filter, String permission) {

  synchronized(this) {

      ProcessRecord callerApp = null;

      if(caller != null) {

         callerApp = getRecordForAppLocked(caller);

         ....... //如果callerApp為null，則丟擲異常，即系統不允許未登記照冊的程式註冊

         //動態廣播接收者

          //檢查呼叫程式是否有callerPackage的資訊，如果沒有，也拋異常

          if(callerApp.info.uid != Process.SYSTEM_UID &&

             !callerApp.pkgList.contains(callerPackage)){

                throw new SecurityException(......);

             }

       }......//if(caller != null)判斷結束

     List allSticky = null;

      //下面這段程式碼的功能是從系統中所有Sticky Intent中查詢匹配IntentFilter的Intent，

     //匹配的Intent儲存在allSticky中

     Iterator actions = filter.actionsIterator();

      if(actions != null) {

        while (actions.hasNext()) {

              String action = (String)actions.next();

              allSticky = getStickiesLocked(action, filter, allSticky);

           }

       } ......

     //如果存在sticky的Intent，則選取第一個Intent作為本函式的返回值

     Intentsticky = allSticky != null ? (Intent)allSticky.get(0) : null;

     //如果沒有設定接收者，則直接返回sticky 的intent

     if(receiver == null)  return sticky;

    //新的資料型別ReceiverList及mRegisteredReceivers成員變數，見下文的解釋

  //receiver.asBinder將返回IIntentReceiver的Bp端

    ReceiverList rl

               = (ReceiverList)mRegisteredReceivers.get(receiver.asBinder());

     //如果是首次呼叫，則此處rl的值將為null

     if (rl== null) {

       rl =new ReceiverList(this, callerApp, Binder.getCallingPid(),

                     Binder.getCallingUid(),receiver);

       if (rl.app != null) {

           rl.app.receivers.add(rl);

       }else {

         try {

                 //監聽廣播接收者所在程式的死亡訊息

                 receiver.asBinder().linkToDeath(rl, 0);

             }......

          rl.linkedToDeath = true;

        }// if(rl.app != null)判斷結束

           //將rl儲存到mRegisterReceivers中

          mRegisteredReceivers.put(receiver.asBinder(), rl);

     }

    //新建一個BroadcastFilter物件

    BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage,

                                                        permission);

    rl.add(bf);//將其儲存到rl中

     // mReceiverResolver成員變數，見下文解釋

    mReceiverResolver.addFilter(bf);

    //如果allSticky不為空，則表示有Sticky的Intent，需要立即排程廣播傳送

     if(allSticky != null) {

        ArrayList receivers = new ArrayList();

         receivers.add(bf);

         intN = allSticky.size();

         for(int i=0; i<N; i++) {

            Intent intent = (Intent)allSticky.get(i);

            //為每一個需要傳送的廣播建立一個BroadcastRecord（暫稱之為廣播記錄）物件

            BroadcastRecord r = new BroadcastRecord(intent, null,

                            null, -1, -1, null,receivers, null, 0, null, null,

                            false, true, true);

            //如果mParallelBroadcasts當前沒有成員，則需要觸發AMS傳送廣播

            if (mParallelBroadcasts.size() == 0)

                 scheduleBroadcastsLocked();//向AMS傳送BROADCAST_INTENT_MSG訊息

             //所有非ordered廣播記錄都儲存在mParallelBroadcasts中

             mParallelBroadcasts.add(r);

          }//for迴圈結束

    }//if (allSticky != null)判斷結束

    returnsticky;

   }//synchronized結束

}

public void sendBroadcast(Intent intent) {

   StringresolvedType = intent.resolveTypeIfNeeded(getContentResolver());

   try {

       intent.setAllowFds(false);

         //呼叫AMS的brodcastIntent，在SDK中定義的廣播傳送函式最終都會呼叫它

        ActivityManagerNative.getDefault().broadcastIntent(

               mMainThread.getApplicationThread(), intent, resolvedType, null,

               Activity.RESULT_OK, null, null, null, false, false);

        }......

 }

private final int broadcastIntentLocked(ProcessRecordcallerApp,

      StringcallerPackage, Intent intent, String resolvedType,

     IIntentReceiver resultTo, int resultCode, String resultData,

      Bundlemap, String requiredPermission,

     boolean ordered, boolean sticky, int callingPid, int callingUid) {

   intent =new Intent(intent);

   //為Intent增加FLAG_EXCLUDE_STOPPED_PACKAGES標誌，表示該廣播不會傳遞給被STOPPED

   //的Package

  intent.addFlags(Intent.FLAG_EXCLUDE_STOPPED_PACKAGES);

   //處理一些特殊的廣播，包括UID_REMOVED,PACKAGE_REMOVED和PACKAGE_ADDED等

   finalboolean uidRemoved = Intent.ACTION_UID_REMOVED.equals(

                                                        intent.getAction());

   ......//處理特殊的廣播，主要和PACKAGE相關，例如接收到PACKAGE_REMOVED廣播後,AMS

   //需將該Package的元件從相關成員中刪除，相關程式碼可自行閱讀

   //處理TIME_ZONE變化廣播

   if(intent.ACTION_TIMEZONE_CHANGED.equals(intent.getAction()))

        mHandler.sendEmptyMessage(UPDATE_TIME_ZONE);

   //處理CLEAR_DNS_CACHE廣播

   if(intent.ACTION_CLEAR_DNS_CACHE.equals(intent.getAction()))

        mHandler.sendEmptyMessage(CLEAR_DNS_CACHE);

   //處理PROXY_CHANGE廣播

   if(Proxy.PROXY_CHANGE_ACTION.equals(intent.getAction())) {

        ProxyProperties proxy = intent.getParcelableExtra("proxy");

         mHandler.sendMessage(mHandler.obtainMessage(

                                  UPDATE_HTTP_PROXY,proxy));

   }

   //處理髮送sticky廣播的情況

  if(sticky) {

   ......//檢查傳送程式是否有BROADCAST_STICKY許可權

   if(requiredPermission != null) {

       //在傳送Sticky廣播的時候，不能攜帶許可權資訊

        returnBROADCAST_STICKY_CANT_HAVE_PERMISSION;

     }

   //在傳送Stikcy廣播的時候，也不能指定特定的接收物件

   if(intent.getComponent() != null) ......//拋異常

   //將這個Sticky的Intent儲存到mStickyBroadcasts中

  ArrayList<Intent> list =mStickyBroadcasts.get(intent.getAction());

   if (list== null) {

        list= new ArrayList<Intent>();

        mStickyBroadcasts.put(intent.getAction(), list);

    }

    ......//如果list中已經有該intent，則直接用新的intent替換舊的intent

    //否則將該intent加入到list中儲存

    if (i >= N) list.add(new Intent(intent));

  }

    //定義兩個變數，其中receivers用於儲存匹配該Intent的所有廣播接收者，包括靜態或動態

    //註冊的廣播接收者，registeredReceivers用於儲存符合該Intent的所有動態註冊者

   Listreceivers = null;

   List<BroadcastFilter>registeredReceivers = null;

   try {

       if(intent.getComponent() != null) {

        ......//如果指定了接收者，則從PKMS中查詢它的資訊

       }else {

          //FLAG_RECEIVER_REGISTERED_ONLY標籤表明該廣播只能發給動態註冊者

          if ((intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY)== 0) {

            //如果沒有設定前面的標籤，則需要查詢PKMS，獲得那些在AndroidManifest.xml

           //中宣告的廣播接收者，即靜態廣播接收者的資訊，並儲存到receivers中

             receivers =

                   AppGlobals.getPackageManager().queryIntentReceivers(

                          intent, resolvedType,STOCK_PM_FLAGS);

            }

          //再從AMS的mReceiverResolver中查詢符合條件的動態廣播接收者

            registeredReceivers =mReceiverResolver.queryIntent(intent,

                                                resolvedType, false);

         }

        }......

  /*

   判斷該廣播是否設定了REPLACE_PENDING標籤。如果設定了該標籤，並且之前的那個Intent還

   沒有被處理，則可以用新的Intent替換舊的Intent。這麼做的目的是為了減少不必要的廣播傳送，

   但筆者感覺，這個標籤的作用並不靠譜，因為只有舊的Intent沒被處理的時候，它才能被替換。

   因為舊Intent被處理的時間不能確定，所以不能保證廣播傳送者的一番好意能夠實現。因此，

   在傳送廣播時，千萬不要以為設定了該標誌就一定能節約不必要的廣播傳送。

  */

   final boolean replacePending =

        (intent.getFlags()&Intent.FLAG_RECEIVER_REPLACE_PENDING) != 0;

  //先處理動態註冊的接收者

   int NR =registeredReceivers != null ? registeredReceivers.size() : 0;

   //如果此次廣播為非序列化傳送，並且符合條件的動態註冊接收者個數不為零

   if(!ordered && NR > 0) {

      //建立一個BroadcastRecord物件即可，注意，一個BroadcastRecord物件可包括所有的

     //接收者（可參考圖6-19）

     BroadcastRecord r = new BroadcastRecord(intent, callerApp,

                   callerPackage, callingPid, callingUid, requiredPermission,

                   registeredReceivers, resultTo, resultCode, resultData, map,

                   ordered, sticky, false);

       boolean replaced = false;

       if (replacePending) {

       ......//從mParalledBroadcasts中查詢是否有舊的Intent，如果有就替代它，並設定

      //replaced為true

     }

       if(!replaced) {//如果沒有被替換，則儲存到mParallelBroadcasts中

          mParallelBroadcasts.add(r);

          scheduleBroadcastsLocked();//排程一次廣播傳送

       }

       //至此，動態註冊的廣播接收者已處理完畢，設定registeredReceivers為null

      registeredReceivers = null;//

       NR =0;

  }

   int ir = 0;

   if(receivers != null) {

      StringskipPackages[] = null;

     ......//處理PACKAGE_ADDED的Intent，系統不希望有些應用程式一安裝就啟動。

      //這類程式的工作原理是什麼呢？即在該程式內部監聽PACKAGE_ADDED廣播。如果系統

     //沒有這一招防備，則PKMS安裝完程式後所傳送的PAKCAGE_ADDED訊息將觸發該應用的啟動

    ......//處理ACTION_EXTERNAL_APPLICATIONS_AVAILABLE廣播

   ......//將動態註冊的接收者registeredReceivers的元素合併到receivers中去

   //處理完畢後，所有的接收者（無論動態還是靜態註冊的）都儲存到receivers變數中了

   if((receivers != null && receivers.size() > 0) || resultTo != null) {

         //建立一個BroadcastRecord物件，注意它的receivers中包括所有的接收者

        BroadcastRecord r = new BroadcastRecord(intent, callerApp,

              callerPackage, callingPid, callingUid, requiredPermission,

              receivers, resultTo, resultCode, resultData, map, ordered,

              sticky, false);

       booleanreplaced = false;

       if (replacePending) {

        ......//替換mOrderedBroadcasts中舊的Intent

        }//

     if(!replaced) {//如果沒有替換，則新增該條廣播記錄到mOrderedBroadcasts中

        mOrderedBroadcasts.add(r);

        scheduleBroadcastsLocked();//排程AMS進行廣播傳送工作

     }

  }

  returnBROADCAST_SUCCESS;

}

private final void processNextBroadcast(booleanfromMsg) {

   //如果是BROADCAST_INTENT_MSG訊息觸發該函式，則fromMsg為true

  synchronized(this) {

    BroadcastRecord r;

   updateCpuStats();//更新CPU使用情況

    if(fromMsg)  mBroadcastsScheduled = false;

    //先處理mParallelBroadcasts中的成員。如前所述，AMS在一個迴圈中處理它們

    while(mParallelBroadcasts.size() > 0) {

         r =mParallelBroadcasts.remove(0);

         r.dispatchTime =SystemClock.uptimeMillis();

         r.dispatchClockTime =System.currentTimeMillis();

        final int N = r.receivers.size();

         for(int i=0; i<N; i++) {

           Object target = r.receivers.get(i);

            //①mParallelBroadcasts中的成員全為BroadcastFilter型別，所以下面的函式

           //將target直接轉換成BroadcastFilter型別。注意，最後一個引數為false

           deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target,

                                                         false);

        }

        //將這條處理過的記錄儲存到mHistoryBroadcast中，供除錯使用

        addBroadcastToHistoryLocked(r);

  }

private final voiddeliverToRegisteredReceiverLocked(BroadcastRecord r,

                         BroadcastFilter filter, booleanordered) {

   booleanskip = false;

   //檢查傳送程式是否有filter要求的許可權

   if(filter.requiredPermission != null) {

       intperm = checkComponentPermission(filter.requiredPermission,

                   r.callingPid, r.callingUid, -1, true);

       if(perm != PackageManager.PERMISSION_GRANTED) skip = true;

  }

   //檢查接收者是否有傳送者要求的許可權

   if(r.requiredPermission != null) {

       intperm = checkComponentPermission(r.requiredPermission,

               filter.receiverList.pid, filter.receiverList.uid, -1, true);

       if(perm != PackageManager.PERMISSION_GRANTED) skip = true;

    }

   if(!skip) {

     if(ordered) {

     ......//設定一些狀態，成員變數等資訊，不涉及廣播傳送

      }

     try {

         //傳送廣播

        performReceiveLocked(filter.receiverList.app,   

              filter.receiverList.receiver,new Intent(r.intent), r.resultCode,

              r.resultData, r.resultExtras, r.ordered, r.initialSticky);

         if(ordered) r.state = BroadcastRecord.CALL_DONE_RECEIVE;

       }......

     }

   }

 }

static void performReceiveLocked(ProcessRecordapp, IIntentReceiver receiver,

      Intentintent, int resultCode, String data, Bundle extras,

     boolean ordered, boolean sticky) throws RemoteException {

      if(app != null && app.thread != null) {

         //如果app及app.thread不為null，則排程scheduleRegisteredReceiver，

        //注意這個函式名為scheduleRegisteredReceiver，它只針對動態註冊的廣播接收者

        app.thread.scheduleRegisteredReceiver(receiver,intent, resultCode,

                   data, extras, ordered, sticky);

      } else{

       //否則呼叫IIntentReceiver的performReceive函式

      receiver.performReceive(intent, resultCode, data, extras,

                                     ordered, sticky);

   }

 }

   /*

    現在要處理mOrderedBroadcasts中的成員。如前所述，它要處理一個接一個的接受者，如果

    接收者所在程式還未啟動，則需要等待。mPendingBroadcast變數用於標識因為應用程式還未

    啟動而處於等待狀態的BroadcastRecord。

   */

  if(mPendingBroadcast != null) {

     boolean isDead;

     synchronized (mPidsSelfLocked) {

        isDead= (mPidsSelfLocked.get(mPendingBroadcast.curApp.pid) == null);

      }

      /*重要說明

       判斷要等待的程式是否為dead程式，如果沒有dead程式，則繼續等待。仔細思考，此處直接

       返回會有什麼問題。

       問題不小！假設有兩個ordered廣播A和B，有兩個接收者，AR和BR，並且BR所

       在程式已經啟動並完成初始化Android執行環境。如果processNextBroadcast先處理A，

       再處理B，那麼此處B的處理將因為mPendingBroadcast不為空而被延後。雖然B和A

       之間沒有任何關係（例如完全是兩個不同的廣播訊息），

       但是事實上，大多數開發人員理解的order是針對單個廣播的，例如A有5個接收者，那麼對這

       5個接收者的廣播的處理是序列的。通過此處的程式碼發現，系統竟然序列處理A和B廣播，即

       B廣播要待到A的5個接收者都處理完了才能處理。

      */

      if(!isDead)   return;

      else {

       mPendingBroadcast.state = BroadcastRecord.IDLE;

       mPendingBroadcast.nextReceiver = mPendingBroadcastRecvIndex;

       mPendingBroadcast = null;

     }

   }

  boolean looped = false;

  do {

        // mOrderedBroadcasts處理完畢

        if (mOrderedBroadcasts.size() == 0) {

            scheduleAppGcsLocked();

            if (looped)  updateOomAdjLocked();

             return;

        }

        r =mOrderedBroadcasts.get(0);

       boolean forceReceive = false;

        //下面這段程式碼用於判斷此條廣播是否處理時間過長

        //先得到該條廣播的所有接收者

        intnumReceivers = (r.receivers != null) ? r.receivers.size() : 0;

        if(mProcessesReady && r.dispatchTime > 0) {

            long now = SystemClock.uptimeMillis();

           //如果總耗時超過2倍的接收者個數*每個接收者最長處理時間（10秒），則

           //強制結束這條廣播的處理

            if ((numReceivers > 0) &&

                   (now > r.dispatchTime +

                              (2*BROADCAST_TIMEOUT*numReceivers))){

               broadcastTimeoutLocked(false);//讀者閱讀完本節後可自行研究該函式

              forceReceive = true;

              r.state = BroadcastRecord.IDLE;

            }

      }//if(mProcessesReady...)判斷結束

     if (r.state != BroadcastRecord.IDLE)   return;

     //如果下面這個if條件滿足，則表示該條廣播要麼已經全部被處理，要麼被中途取消

     if(r.receivers == null || r.nextReceiver >= numReceivers

            || r.resultAbort || forceReceive) {

         if(r.resultTo != null) {

          try {

               //將該廣播的處理結果傳給設定了resultTo的接收者

               performReceiveLocked(r.callerApp, r.resultTo,

                  new Intent(r.intent), r.resultCode,

                 r.resultData, r.resultExtras, false, false);

               r.resultTo = null;

            }......

       }

      cancelBroadcastTimeoutLocked();

       addBroadcastToHistoryLocked(r);

      mOrderedBroadcasts.remove(0);

       r = null;

      looped = true;

       continue;

     }

  } while (r== null);

  int recIdx= r.nextReceiver++;

 r.receiverTime = SystemClock.uptimeMillis();

  if (recIdx== 0) {

     r.dispatchTime = r.receiverTime;//記錄本廣播第一次處理開始的時間

      r.dispatchClockTime= System.currentTimeMillis();

  }

  //設定廣播處理超時時間，BROADCAST_TIMEOUT為10秒

  if (!mPendingBroadcastTimeoutMessage) {

        longtimeoutTime = r.receiverTime + BROADCAST_TIMEOUT;

       setBroadcastTimeoutLocked(timeoutTime);

  }

  //取該條廣播下一個接收者

  ObjectnextReceiver = r.receivers.get(recIdx);

  if(nextReceiver instanceof BroadcastFilter) {

     //如果是動態接收者，則直接呼叫deliverToRegisteredReceiverLocked處理

    BroadcastFilter filter = (BroadcastFilter)nextReceiver;

    deliverToRegisteredReceiverLocked(r, filter, r.ordered);

     if(r.receiver == null || !r.ordered) {

        r.state = BroadcastRecord.IDLE;

        scheduleBroadcastsLocked();

       }

     return;//已經通知一個接收者去處理該廣播，需要等它的處理結果，所以此處直接返回

  }

 //如果是靜態接收者，則它的真實型別是ResolveInfo

 ResolveInfo info =  (ResolveInfo)nextReceiver;

  booleanskip = false;

  //檢查許可權

  int perm =checkComponentPermission(info.activityInfo.permission,

        r.callingPid, r.callingUid, info.activityInfo.applicationInfo.uid,

        info.activityInfo.exported);

  if (perm!= PackageManager.PERMISSION_GRANTED) skip = true;

  if(info.activityInfo.applicationInfo.uid != Process.SYSTEM_UID &&

        r.requiredPermission != null) {

        ......

       }

   //設定skip為true

   if(r.curApp != null && r.curApp.crashing) skip = true;

   if (skip){

     r.receiver = null;

     r.curFilter = null;

     r.state = BroadcastRecord.IDLE;

     scheduleBroadcastsLocked();//再排程一次廣播處理

     return;

   }

    r.state= BroadcastRecord.APP_RECEIVE;

    StringtargetProcess = info.activityInfo.processName;

   r.curComponent = new ComponentName(

             info.activityInfo.applicationInfo.packageName,

             info.activityInfo.name);

  r.curReceiver = info.activityInfo;

   try {

          //設定Package stopped的狀態為false

          AppGlobals.getPackageManager().setPackageStoppedState(

                       r.curComponent.getPackageName(),false);

         } ......

  ProcessRecord app = getProcessRecordLocked(targetProcess,

                         info.activityInfo.applicationInfo.uid);

   //如果該接收者對應的程式已經存在

   if (app!= null && app.thread != null) {

    try {

           app.addPackage(info.activityInfo.packageName);

           //該函式內部呼叫應用程式的scheduleReceiver函式，讀者可自行分析

           processCurBroadcastLocked(r, app);

           return;//已經觸發該接收者處理本廣播，需要等待處理結果

        }......

     }

   //最糟的情況就是該程式還沒有啟動

   if((r.curApp=startProcessLocked(targetProcess,

          info.activityInfo.applicationInfo, true,......)!= 0)) == null) {

          ......//程式啟動失敗的處理

         return;

   }

  mPendingBroadcast = r; //設定mPendingBroadcast

  mPendingBroadcastRecvIndex = recIdx;

 }

public voidscheduleRegisteredReceiver(IIntentReceiver receiver, Intent intent,

       intresultCode, String dataStr, Bundle extras, boolean ordered,

      boolean sticky) throws RemoteException {

  //又把receiver物件傳了回來。還記得註冊時傳遞的一個IIntentReceiver型別

  //的物件嗎？

   receiver.performReceive(intent,resultCode, dataStr, extras, ordered,

                               sticky);

 }

public void performReceive(Intent intent, intresultCode,

   Stringdata, Bundle extras, boolean ordered, boolean sticky) {

   //Args是一個runnable物件

   Args args= new Args(intent, resultCode, data, extras, ordered, sticky);

      // mActivityThread是一個Handler，還記得SDK提供的兩個同名的registerReceiver

     //函式嗎？如果沒有傳遞Handler，則使用主執行緒的Handler。

  if(!mActivityThread.post(args)) {

      if(mRegistered && ordered) {

        IActivityManager mgr = ActivityManagerNative.getDefault();

        args.sendFinished(mgr);

      }

   }

}

   publicvoid run() {

     finalBroadcastReceiver receiver = mReceiver;

     final boolean ordered = mOrdered;

     finalIActivityManager mgr = ActivityManagerNative.getDefault();

     finalIntent intent = mCurIntent;

    mCurIntent = null;

     ......

    try {

          //獲取ClassLoader物件，千萬注意，此處並沒有通過反射機制建立一個廣播接收者，

          //對於動態接收者來說，在註冊前就已經建立完畢

           ClassLoadercl = mReceiver.getClass().getClassLoader();

          intent.setExtrasClassLoader(cl);

          setExtrasClassLoader(cl);

          receiver.setPendingResult(this);//設定pendingResult

          //呼叫該動態接收者的onReceive函式

          receiver.onReceive(mContext, intent);

    }......

     //呼叫finish完成工作

     if(receiver.getPendingResult() != null) finish();

    }

public void finishReceiver(IBinder who, intresultCode, String resultData,

           Bundle resultExtras, boolean resultAbort) {

      ......

    booleandoNext;

    final long origId =Binder.clearCallingIdentity();

    synchronized(this){

        //判斷是否還需要繼續排程後續的廣播傳送

       doNext = finishReceiverLocked(

             who, resultCode, resultData, resultExtras, resultAbort, true);

        }

        if(doNext) { //發起下一次廣播傳送

           processNextBroadcast(false);

        }

       trimApplications();

   Binder.restoreCallingIdentity(origId);

}

注意任何廣播對於靜態註冊者來說，都是ordered，而且該order是全域性性的，並非只針對該廣播的接收者，故從廣播發出到靜態註冊者的onReceive函式被呼叫中間經歷的這段時間相對較長。

注意生命週期控制一般都涉及引用計數的使用。如果某Service物件同時支援這兩種請求方式，那麼當總引用計數減為零時，其生命就走向終點。

注意圖6-21和圖6-22中也包含了bindService的處理流程。在實際分析時，讀者可分開研究bindService和startService的處理流程。

提示可簡單認為，排程優先順序及排程策略二者一起影響了系統分配CPU資源給應用程式。注意，此處的措詞為“影響”，而非“控制”。因為對於使用者空間可以呼叫的API來說，如果二者能控制CPU資源分配，那麼該系統的安全性會大打折扣。

int setpriority(int which, int who, int prio);

int sched_setscheduler(pid_t pid, int policy,conststruct sched_param *param);

注意這兩個引數的典型設定為：

minfree，2048,3072,4096,6144,7168,8192 用於描述不同級別的記憶體閾值，單位為KB。

adj，0,1,2,4,7,15 用於描述對應記憶體閾值的oom_adj值。

表示當剩餘記憶體為2048KB時，LMK將殺死oom_adj大於等於0的程式。

提示lowmemorykiller的程式碼在kernel/drivers/staging/android/lowmemorykiller.c中，感興趣的讀者可嘗試自行閱讀。

建議讀者可閱讀SDK/docs/guide/topics/fundamentals/processes-and-threads.html以獲取更為詳細的資訊。

//設定執行緒的排程優先順序，Linux kernel並不區分執行緒和程式，二者對應同一個資料結構Task

public static final native void setThreadPriority(inttid, int priority)

           throws IllegalArgumentException, SecurityException;

/*

   設定執行緒的Group，實際上就是設定執行緒的排程策略，目前Android定義了三種Group。

   由於缺乏相關資料，加之筆者感覺對應的註釋也只可意會不可言傳，故此處直接照搬了英文

   註釋，敬請讀者諒解。

   THREAD_GROUP_DEFAULT：Default thread group - gets a 'normal'share of the CPU

   THREAD_GROUP_BG_NONINTERACTIVE：Background non-interactive thread group.

   Allthreads in this group are scheduled with a reduced share of the CPU

   THREAD_GROUP_FG_BOOST：Foreground 'boost' thread group - Allthreads in

   this group are scheduled with an increasedshare of the CPU.

   目前程式碼中還沒有地方使用THREAD_GROUP_FG_BOOST這種Group

*/

public static final native void setThreadGroup(inttid, int group)

           throws IllegalArgumentException, SecurityException;

//設定程式的排程策略，包括該程式的所有執行緒

public static final native voidsetProcessGroup(int pid, int group)

           throws IllegalArgumentException, SecurityException;

//設定執行緒的排程優先順序

public static final native voidsetThreadPriority(int priority)

           throws IllegalArgumentException, SecurityException;

//調整程式的oom_adj值

public static final native boolean setOomAdj(intpid, int amt);

注意Process.java中的大多數函式是由JNI層實現的，其中Android在排程策略設定這一功能上還有一些特殊的地方，感興趣的讀者不妨閱讀system/core/libcutils/sched_policy.c檔案。

class ProcessList {

    //當一個程式連續發生Crash的間隔小於60秒時，系統認為它是為Bad程式

    staticfinal int MIN_CRASH_INTERVAL = 60*1000;

   //下面定義各種狀態下程式的oom_adj

   //不可見程式的oom_adj，最大15，最小為7。殺死這些程式一般不會帶來使用者能夠察覺的影響

    staticfinal int HIDDEN_APP_MAX_ADJ = 15;

    staticint HIDDEN_APP_MIN_ADJ = 7;

   /*

   位於B List中Service所在程式的oom_adj。什麼樣的Service會在BList中呢？其中的

   解釋只能用原文來表達” these are the old anddecrepit services that aren't as

   shiny andinteresting as the ones in the A list“

   */

    staticfinal int SERVICE_B_ADJ = 8;

   /*

   前一個程式的oom_adj，例如從A程式的Activity跳轉到位於B程式的Activity，

   B程式是當前程式，而A程式就是previous程式了。因為從當前程式A退回B程式是一個很簡單

   卻很頻繁的操作（例如按back鍵退回上一個Activity），所以previous程式的oom_adj

   需要單獨控制。這裡不能簡單按照五大類來劃分previous程式，還需要綜合考慮

   */

   staticfinal int PREVIOUS_APP_ADJ = 7;

   //Home程式的oom_adj為6，使用者經常和Home程式互動，故它的oom_adj也需要單獨控制

    staticfinal int HOME_APP_ADJ = 6;

   //Service類中程式的oom_adj為5

    staticfinal int SERVICE_ADJ = 5;

   //正在執行backup操作的程式，其oom_adj為4

    staticfinal int BACKUP_APP_ADJ = 4;

   //heavyweight的概念前面曽提到過，該類程式的oom_adj為3

    staticfinal int HEAVY_WEIGHT_APP_ADJ = 3;

   //Perceptible程式指那些當前並不在前端顯示而使用者能感覺到它在執行的程式，例如正在

   //後臺播放音樂的Music

    staticfinal int PERCEPTIBLE_APP_ADJ = 2;

   //Visible類程式，oom_adj為1

    staticfinal int VISIBLE_APP_ADJ = 1;

   //Forground類程式，oom_adj為0

    staticfinal int FOREGROUND_APP_ADJ = 0;

   //persistent類程式（即退出後，系統需要重新啟動的重要程式），其oom_adj為-12

    staticfinal int PERSISTENT_PROC_ADJ = -12;

    //核心服務所在程式，oom_adj為-12

    staticfinal int CORE_SERVER_ADJ = -12;

    //系統程式，其oom_adj為-16

    staticfinal int SYSTEM_ADJ = -16;

    //記憶體頁大小定義為4KB

    staticfinal int PAGE_SIZE = 4*1024;

    //系統中能容納的不可見程式數最少為2，最多為15。在Android 4.0系統中，可通過設定程式來

    //調整

    staticfinal int MIN_HIDDEN_APPS = 2;

    staticfinal int MAX_HIDDEN_APPS = 15;

  //下面兩個引數用於調整程式的LRU權重。注意，它們的註釋和具體程式碼中的用法不能統一起來

  staticfinal long CONTENT_APP_IDLE_OFFSET = 15*1000;

  staticfinal long EMPTY_APP_IDLE_OFFSET = 120*1000;

  //LMK設定了6個oom_adj閾值

  privatefinal int[] mOomAdj = new int[] {

           FOREGROUND_APP_ADJ, VISIBLE_APP_ADJ, PERCEPTIBLE_APP_ADJ,

           BACKUP_APP_ADJ, HIDDEN_APP_MIN_ADJ, EMPTY_APP_ADJ

  };

   //用於記憶體較低機器（例如小於512MB）中LMK的記憶體閾值配置

    privatefinal long[] mOomMinFreeLow = new long[] {

           8192, 12288, 16384,

           24576, 28672, 32768

    };

   //用於較高記憶體機器（例如大於1GB）的LMK記憶體閾值配置

   privatefinal long[] mOomMinFreeHigh = new long[] {

           32768, 40960, 49152,

           57344, 65536, 81920

    };

說明在ProcessList中定義的大部分變數在Android 2.3程式碼中定義於ActivityManagerService.java中，但這段程式碼的開發者僅把程式碼複製了過來，其中的註釋並未隨著系統升級而更新。

//用於LRU列表控制

long lastActivityTime;   // For managing the LRU list

long lruWeight;      // Weight for ordering in LRU list

//和oom_adj有關

int maxAdj;           // Maximum OOM adjustment for thisprocess

int hiddenAdj;       // If hidden, this is the adjustment touse

int curRawAdj;       // Current OOM unlimited adjustment forthis process

int setRawAdj;       // Last set OOM unlimited adjustment forthis process

int curAdj;           // Current OOM adjustment for thisprocess

int setAdj;           // Last set OOM adjustment for thisprocess

//和排程優先順序有關

int curSchedGroup;   // Currently desired scheduling class

int setSchedGroup;   // Last set to background scheduling class

//回收記憶體級別，見後文解釋

int trimMemoryLevel; // Last selected memorytrimming level

//判斷該程式的狀態，主要和其中執行的Activity，Service有關

boolean keeping;     // Actively running code sodon't kill due to that?

boolean setIsForeground;    // Running foreground UI when last set?

boolean foregroundServices; // Running anyservices that are foreground?

boolean foregroundActivities; // Running anyactivities that are foreground?

boolean systemNoUi;   // This is a system process, but notcurrently showing UI.

boolean hasShownUi;  // Has UI been shown in this process since itwas started?

boolean pendingUiClean;     // Want to clean up resources from showingUI?

boolean hasAboveClient;     // Bound using BIND_ABOVE_CLIENT, so wantto be lower

//是否處於系統BadProcess列表

boolean bad;                // True if disabled in the badprocess list

//描述該程式因為是否有太多後臺元件而被殺死

boolean killedBackground;   // True when proc has been killed due to toomany bg

String waitingToKill;       // Process is waiting to be killed whenin the bg; reason

//序號，每次調節程式優先順序或者LRU列表位置時，這些序號都會遞增

int adjSeq;                 // Sequence id for identifyingoom_adj assignment cycles

int lruSeq;                 // Sequence id for identifyingLRU update cycles

提示程式管理和排程一向比較複雜，從ProcessRecord定義的這些變數中可見一斑。需要提醒讀者的是，對這部分功能的相關說明非常少，程式碼讀起來會感覺比較晦澀。

注意AMS一共定義了3個updateOomAdjLocked函式，此處將其歸為一類。

提示不熟悉的讀者可閱讀6.3.3節的第5小節。

//attachApplication主要工作由attachApplicationLocked完成，故直接分析它

private final booleanattachApplicationLocked(IApplicationThread thread,

                                                      int pid) {

 ProcessRecord app;

  //根據之前的介紹的內容，AMS在建立應用程式前已經將對應的ProcessRecord儲存到

  //mPidsSelfLocked中了

  ...... //其他一些處理

  //初始化ProcessRecord中的一些成員變數

  app.thread= thread;

  app.curAdj= app.setAdj = -100;

 app.curSchedGroup = Process.THREAD_GROUP_DEFAULT;

  app.setSchedGroup= Process.THREAD_GROUP_BG_NONINTERACTIVE;

 app.forcingToForeground = null;

 app.foregroundServices = false;

 app.hasShownUi = false;

  ......

  //呼叫應用程式的bindApplication，以初始化其內部的Android執行環境

  thread.bindApplication(......);

  //①呼叫updateLruProcessLocked函式

 updateLruProcessLocked(app, false, true);

 app.lastRequestedGc = app.lastLowMemory = SystemClock.uptimeMillis();

  ......//啟動Activity等操作

  //②didSomething為false，則呼叫updateOomAdjLocked函式

  if(!didSomething) {

      updateOomAdjLocked();

 }

final void updateLruProcessLocked(ProcessRecordapp,

           boolean oomAdj, boolean updateActivityTime) {

  mLruSeq++;//每一次調整LRU列表，系統都會分配一個唯一的編號

  updateLruProcessInternalLocked(app, oomAdj, updateActivityTime, 0);

 }

private final voidupdateLruProcessInternalLocked(ProcessRecord app,

           boolean oomAdj, boolean updateActivityTime, int bestPos) {

  //獲取app在mLruProcesses中的索引位置，對於本例而言，返回值lrui為-1

  int lrui =mLruProcesses.indexOf(app);

  //如果之前有記錄，則先從陣列中刪掉，因為此處需要重新調整位置

  if (lrui>= 0) mLruProcesses.remove(lrui);

  //獲取mLruProcesses中陣列索引的最大值，從0開始

  int i =mLruProcesses.size()-1;

  intskipTop = 0;

  app.lruSeq= mLruSeq;  //將系統全域性的lru調整編號賦給ProcessRecord的lruSeq

  //更新lastActivityTime值，其實就是獲取一個時間

  if(updateActivityTime) {

        app.lastActivityTime =SystemClock.uptimeMillis();

  }

  if(app.activities.size() > 0) {

      //如果該app含Activity，則lruWeight為當前時間

      app.lruWeight = app.lastActivityTime;

   } else if(app.pubProviders.size() > 0) {

       /*

        如果有釋出的ContentProvider，則lruWeight要減去一個OFFSET。

        對此的理解需結合CONTENT_APP_IDLE_OFFSET的定義。讀者暫時把它

        看做一個常數

        */

       app.lruWeight = app.lastActivityTime -

                            ProcessList.CONTENT_APP_IDLE_OFFSET;

        //設定skipTop。這個變數實際上沒有用，放在此處讓人很頭疼

        skipTop = ProcessList.MIN_HIDDEN_APPS;

   } else {

         app.lruWeight = app.lastActivityTime -

                              ProcessList.EMPTY_APP_IDLE_OFFSET;

         skipTop = ProcessList.MIN_HIDDEN_APPS;

   }

  //從陣列最後一個元素開始迴圈

  while (i>= 0) {

     ProcessRecord p = mLruProcesses.get(i);

     //下面這個if語句沒有任何意義，因為skipTop除了做自減操作外，不影響其他任何內容

      if(skipTop > 0 && p.setAdj >= ProcessList.HIDDEN_APP_MIN_ADJ) {

          skipTop--;

       }

       //將app調整到合適的位置

       if(p.lruWeight <= app.lruWeight || i < bestPos) {

           mLruProcesses.add(i+1, app);

           break;

       }

       i--;

  }

  //如果沒有找到合適的位置，則把app加到佇列頭

  if (i <0)   mLruProcesses.add(0, app);

   //如果該將app 繫結到其他service，則要對應調整Service所在程式的LRU

   if (app.connections.size() > 0) {

       for(ConnectionRecord cr : app.connections) {

          if(cr.binding != null && cr.binding.service != null

                        && cr.binding.service.app!= null

                        &&cr.binding.service.app.lruSeq != mLruSeq) {

                        updateLruProcessInternalLocked(cr.binding.service.app,

                               oomAdj,updateActivityTime,i+1);

            }

        }

    }

  //conProviders也是一種Provider，相關資訊下一章再介紹

    if(app.conProviders.size() > 0) {

         for(ContentProviderRecord cpr : app.conProviders.keySet()) {

            ......//對ContentProvider所在程式做類似的調整

           }

        }

  //在本例中，oomAdj為false，故updateOomAdjLocked不會被呼叫

  if (oomAdj) updateOomAdjLocked(); //以後分析

}

提示在以上程式碼中， skipTop變數完全沒有實際作用，卻給為閱讀程式碼帶來了很大干擾。

final void updateOomAdjLocked() {

  //在一般情況下，resumedAppLocked返回 mResumedActivity，即當前正處於前臺的Activity

  finalActivityRecord TOP_ACT = resumedAppLocked();

  //得到前臺Activity所屬程式的ProcessRecord資訊

  finalProcessRecord TOP_APP = TOP_ACT != null ? TOP_ACT.app : null;

  mAdjSeq++;//oom_adj在進行調節時也會有唯一的序號

  mNewNumServiceProcs= 0;

  /*

    下面這幾句程式碼的作用如下：

    1 根據hidden adj劃分級別，一共有9個級別（即numSlots值）

    2 根據mLruProcesses的成員個數計算平均落在各個級別的程式數（即factor值）。但是這裡

      的魔數（magic number）4卻令人頭疼不已。如有清楚該內容的讀者，不妨讓分享一下

      研究結果

  */

  intnumSlots = ProcessList.HIDDEN_APP_MAX_ADJ -

                                          ProcessList.HIDDEN_APP_MIN_ADJ + 1;

  int factor= (mLruProcesses.size()-4)/numSlots;

  if (factor< 1) factor = 1;

  int step =0;

  intnumHidden = 0;

  int i =mLruProcesses.size();

  intcurHiddenAdj = ProcessList.HIDDEN_APP_MIN_ADJ;

 //從mLruProcesses陣列末端開始迴圈

  while (i> 0) {

     i--;

     ProcessRecordapp = mLruProcesses.get(i);

     //①呼叫另外一個updateOomAdjLocked函式

     updateOomAdjLocked(app,curHiddenAdj, TOP_APP, true);

     // updateOomAdjLocked函式會更新app的curAdj

    if(curHiddenAdj < ProcessList.HIDDEN_APP_MAX_ADJ

                              &&app.curAdj == curHiddenAdj) {

       /*

       這段程式碼的目的其實很簡單。即當某個adj級別的ProcessRecord處理個數超過均值後，

       就跳到下一級別進行處理。注意，這段程式碼的結果會影響updateOomAdjLocked的第二個引數

      */

           step++;

           if(step >= factor) {

               step = 0;

               curHiddenAdj++;

           }

       }// if(curHiddenAdj < ProcessList.HIDDEN_APP_MAX_ADJ...)判斷結束

     //app.killedBackground初值為false

     if(!app.killedBackground) {

          if (app.curAdj >= ProcessList.HIDDEN_APP_MIN_ADJ) {

                numHidden++;

              //mProcessLimit初始值為ProcessList.MAX（值為15），

             //可通過setProcessLimit函式對其進行修改

                if (numHidden > mProcessLimit) {

                      app.killedBackground =true;

                      //如果後臺程式個數超過限制，則會殺死對應的後臺程式

                     Process.killProcessQuiet(app.pid);

                }

            }

      }//if(!app.killedBackground)判斷結束

  }//while迴圈結束

 mNumServiceProcs = mNewNumServiceProcs;

 //numHidden表示處於hidden狀態的程式個數

  //當Hidden程式個數小於7時候（15/2的整型值）,執行if分支

  if(numHidden <= (ProcessList.MAX_HIDDEN_APPS/2)) {

       ......

     /*

      我們不討論這段缺乏文件及使用魔數的程式碼，但這裡有個知識點要注意：

      該知識點和Android 4.0新增介面ComponentCallbacks2有關，主要是通知應用程式進行

      記憶體清理，ComponentCallbacks2介面定了一個函式onTrimMemory(int level)，

      而四大元件除BroadcastReceiver外，均實現了該介面。系統定義了4個level以通知程式

      做對應處理：

      TRIM_MEMORY_UI_HIDDEN，提示程式當前不處於前臺，故可釋放一些UI資源

      TRIM_MEMORY_BACKGROUND，表明該程式已加入LRU列表，此時程式可以對一些簡單的資源

      進行清理

      TRIM_MEMORY_MODERATE，提示程式可以釋放一些資源，這樣其他程式的日子會好過些。

      即所謂的“我為人人，人人為我”

      TRIM_MEMORY_COMPLETE，該程式需儘可能釋放一些資源，否則當記憶體不足時，它可能被殺死

      */

   } else {//假設hidden程式數超過7，

      finalint N = mLruProcesses.size();

      for(i=0; i<N; i++) {

       ProcessRecord app = mLruProcesses.get(i);

        if ((app.curAdj >ProcessList.VISIBLE_APP_ADJ || app.systemNoUi)

              && app.pendingUiClean) {

            if (app.trimMemoryLevel <

                        ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN

                        && app.thread!= null) {

                   try {//呼叫應用程式ApplicationThread的scheduleTrimMemory函式

                        app.thread.scheduleTrimMemory(

                                    ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN);

                      }......

                }// if (app.trimMemoryLevel...)判斷結束

              app.trimMemoryLevel =

                             ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN;

                   app.pendingUiClean = false;

         }else {

              app.trimMemoryLevel = 0;

          }

       }//for迴圈結束

        }//else結束

   //Android4.0中設定有一個開發人員選項，其中有一項用於控制是否銷燬後臺的Activity。

   //讀者可自行研究destroyActivitiesLocked函式

   if (mAlwaysFinishActivities)

       mMainStack.destroyActivitiesLocked(null, false,"always-finish");

 }

建議真誠希望Google能給出一個明確的文件，說明這幾個函式該怎麼使用。

private final boolean updateOomAdjLocked( ProcessRecordapp, int hiddenAdj,

           ProcessRecord TOP_APP, boolean doingAll) {

  //設定該app的hiddenAdj

 app.hiddenAdj = hiddenAdj;

  if(app.thread == null)  return false;

  finalboolean wasKeeping = app.keeping;

  booleansuccess = true;

   //下面這個函式的呼叫極其關鍵。從名字上看，它會計算該程式的oom_adj及排程策略

  computeOomAdjLocked(app, hiddenAdj, TOP_APP, false, doingAll);

  if(app.curRawAdj != app.setRawAdj) {

      if (wasKeeping && !app.keeping) {

           .....//統計電量

          app.lastCpuTime = app.curCpuTime;

        }

     app.setRawAdj = app.curRawAdj;

  }

  //如果新舊oom_adj不同，則重新設定該程式的oom_adj

  if(app.curAdj != app.setAdj) {

       if(Process.setOomAdj(app.pid, app.curAdj)) //設定該程式的oom_adj

            app.setAdj = app.curAdj;

       .....

   }

  //如果新舊排程策略不同，則需重新設定該程式的排程策略

  if(app.setSchedGroup != app.curSchedGroup) {

      app.setSchedGroup = app.curSchedGroup;

        //waitingToKill是一個字串，用於描述殺掉該程式的原因

       if (app.waitingToKill != null &&

            app.setSchedGroup == Process.THREAD_GROUP_BG_NONINTERACTIVE) {

             Process.killProcessQuiet(app.pid);//

            success = false;

        } else{

          if (true) {//強制執行if分支

                long oldId = Binder.clearCallingIdentity();

                   try {//設定程式排程策略

                       Process.setProcessGroup(app.pid, app.curSchedGroup);

                   }......

               } ......

           }

        }

   returnsuccess;

 }

建議思考一個問題：為何AMS只設定程式的排程策略，而不設定程式的排程優先順序？

private final intcomputeOomAdjLocked(ProcessRecord app, int hiddenAdj,

           ProcessRecord TOP_APP, boolean recursed, boolean doingAll) {

  ......

  app.adjTypeCode= ActivityManager.RunningAppProcessInfo.REASON_UNKNOWN;

 app.adjSource = null;

 app.adjTarget = null;

  app.empty= false;

  app.hidden= false;

  //該應用程式包含Activity的個數

  final intactivitiesSize = app.activities.size();

  //如果maxAdj小於FOREGROUND_APP_ADJ，基本上沒什麼工作可以做了。這類程式優先順序相當高

  if(app.maxAdj <= ProcessList.FOREGROUND_APP_ADJ) {

       ......//讀者可自行閱讀這塊程式碼

      return(app.curAdj=app.maxAdj);

   }

  finalboolean hadForegroundActivities = app.foregroundActivities;

 app.foregroundActivities = false;

 app.keeping = false;

 app.systemNoUi = false;

  int adj;

  intschedGroup;

  //如果app為前臺Activity所在的那個應用程式

  if (app ==TOP_APP) {

       adj =ProcessList.FOREGROUND_APP_ADJ;

      schedGroup = Process.THREAD_GROUP_DEFAULT;

       app.adjType= "top-activity";

      app.foregroundActivities = true;

    } else if (app.instrumentationClass != null){

             ......//略過instrumentationClass不為null的情況

    } else if (app.curReceiver != null ||

         (mPendingBroadcast != null && mPendingBroadcast.curApp == app)){

         //此情況對應正在執行onReceive函式的廣播接收者所在程式，它的優先順序也很高

         adj = ProcessList.FOREGROUND_APP_ADJ;

         schedGroup = Process.THREAD_GROUP_DEFAULT;

         app.adjType = "broadcast";

   } else if(app.executingServices.size() > 0) {

        //正在執行Service生命週期函式的程式

        adj= ProcessList.FOREGROUND_APP_ADJ;

       schedGroup = Process.THREAD_GROUP_DEFAULT;

       app.adjType = "exec-service";

    } elseif (activitiesSize > 0) {

         adj = hiddenAdj;

        schedGroup =Process.THREAD_GROUP_BG_NONINTERACTIVE;

        app.hidden = true;

        app.adjType = "bg-activities";

    } else {//不含任何元件的程式，即所謂的Empty程式

         adj= hiddenAdj;

        schedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;

         app.hidden= true;

         app.empty = true;

        app.adjType = "bg-empty";

   }

   //下面幾段程式碼將根據情況重新調整前面計算處理的adj和schedGroup，我們以後面的

   //mHomeProcess判斷為例

   if(!app.foregroundActivities && activitiesSize > 0) {

         //對無前臺Activity所在程式的處理

   }

   if (adj> ProcessList.PERCEPTIBLE_APP_ADJ) {

        .......

    }

   //如果前面計算出來的adj大於HOME_APP_ADJ，並且該程式又是Home程式，則需要重新調整

   if (adj> ProcessList.HOME_APP_ADJ && app == mHomeProcess) {

        //重新調整adj和schedGroupde的值

        adj = ProcessList.HOME_APP_ADJ;

       schedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;

       app.hidden = false;

       app.adjType = "home";//描述調節adj的原因

   }

   if (adj> ProcessList.PREVIOUS_APP_ADJ && app == mPreviousProcess

           && app.activities.size() > 0) {

          ......

   }

  app.adjSeq = mAdjSeq;

  app.curRawAdj = adj;

    ......

   //下面這幾段程式碼處理那些程式中含有Service，ContentProvider元件情況下的adj調節

   if(app.services.size() != 0 && (adj > ProcessList.FOREGROUND_APP_ADJ

          || schedGroup == Process.THREAD_GROUP_BG_NONINTERACTIVE)) {

   }

   if(s.connections.size() > 0 && (adj >ProcessList.FOREGROUND_APP_ADJ

             || schedGroup == Process.THREAD_GROUP_BG_NONINTERACTIVE)) {

   }

   if(app.pubProviders.size() != 0 && (adj >ProcessList.FOREGROUND_APP_ADJ

              || schedGroup == Process.THREAD_GROUP_BG_NONINTERACTIVE)) {

           ......

   }

   //終於計算完畢

  app.curRawAdj = adj;

   if (adj> app.maxAdj) {

        adj= app.maxAdj;

        if(app.maxAdj <= ProcessList.PERCEPTIBLE_APP_ADJ)

           schedGroup = Process.THREAD_GROUP_DEFAULT;

    }

    if (adj< ProcessList.HIDDEN_APP_MIN_ADJ)

        app.keeping = true;

     ......

   app.curAdj = adj;

   app.curSchedGroup = schedGroup;

   ......

   returnapp.curRawAdj;

}

提示筆者覺得，AMS中這部分程式碼不是特別高效，不知各位讀者是否有同感,？

private static final void commonInit() {

   //呼叫完畢後，該應用中所有執行緒丟擲的未處理異常都會由UncaughtHandler來處理

   Thread.setDefaultUncaughtExceptionHandler(newUncaughtHandler());

  ......

}

 privatestatic class UncaughtHandler implements

                                           Thread.UncaughtExceptionHandler{

   publicvoid uncaughtException(Thread t, Throwable e) {

    try {

          if (mCrashing) return;

           mCrashing = true;

         //呼叫AMS的handleApplicationCrash函式。第一個引數mApplicationObject其實

        //就是前面經常見到的ApplicationThread物件

          ActivityManagerNative.getDefault().handleApplicationCrash(

               mApplicationObject, new  ApplicationErrorReport.CrashInfo(e));

     } ......

    finally{

           //這裡有一句註釋很有意思：Try everything to make surethis process goes

          //away.從下面這兩句呼叫來看，該應用程式確實想方設法要離開Java世界

          Process.killProcess(Process.myPid());//把自己殺死

          System.exit(10);//如果上面那句話不成功，再嘗試exit方法

     }

   }

}

public void handleApplicationCrash(IBinder app,

                             ApplicationErrorReport.CrashInfocrashInfo) {

  //找到對應的ProcessRecord資訊，後面那個字串“Crash”用於列印輸出

 ProcessRecord r = findAppProcess(app, "Crash");

  finalString processName = app == null ? "system_server"

                        : (r == null ? "unknown": r.processName);

   //新增crash資訊到dropbox中

 ddErrorToDropBox("crash", r, processName, null, null, null,null, null,

                         crashInfo);

  //呼叫crashApplication函式

 crashApplication(r, crashInfo);

}

private void crashApplication(ProcessRecord r,

                   ApplicationErrorReport.CrashInfocrashInfo) {

   longtimeMillis = System.currentTimeMillis();

   //從應用程式傳遞過來的crashInfo中獲取相關資訊

   StringshortMsg = crashInfo.exceptionClassName;

   StringlongMsg = crashInfo.exceptionMessage;

   StringstackTrace = crashInfo.stackTrace;

   if(shortMsg != null && longMsg != null) {

      longMsg = shortMsg + ": " + longMsg;

     } elseif (shortMsg != null) {

      longMsg = shortMsg;

   }

  AppErrorResult result = new AppErrorResult();

  synchronized (this) {

      if(mController != null) {

         //通知監視者。目前僅MonkeyTest中會為AMS設定監聽者。測試過程中可設定是否一檢測

         //到App Crash即停止測試。另外，Monkey測試也會將App Crash資訊儲存起來

        //供開發人員分析

       }

      final long origId =Binder.clearCallingIdentity();

      if (r!= null && r.instrumentationClass != null) {

       ......// instrumentationClass不為空的情況

      }

      //①呼叫makeAppCrashingLocked處理，如果返回false，則整個處理流程完畢

     if (r == null || !makeAppCrashingLocked(r,shortMsg, longMsg,

                        stackTrace)) {

         ......

       return;

      }

     Message msg = Message.obtain();

     msg.what = SHOW_ERROR_MSG;

     HashMap data = new HashMap();

     data.put("result", result);

     data.put("app", r);

     msg.obj = data;

    //傳送SHOW_ERROR_MSG訊息給mHandler，預設處理是彈出一個對話方塊，提示使用者某程式   //崩潰（Crash），使用者可以選擇“退出”或 “退出並報告”

     mHandler.sendMessage(msg);

      ......

   }//synchronized(this)結束

   //下面這個get函式是阻塞的，直到使用者處理了對話方塊為止。注意，此處涉及兩個執行緒：

 //handleApplicationCrash函式是在Binder呼叫執行緒中處理的，而對話方塊則是在mHandler所

  //線上程中處理的

   int res =result.get();

   IntentappErrorIntent = null;

  synchronized (this) {

     if (r!= null)

        mProcessCrashTimes.put(r.info.processName, r.info.uid,

                       SystemClock.uptimeMillis());

   if (res== AppErrorDialog.FORCE_QUIT_AND_REPORT)

      //createAppErrorIntentLocked返回一個Intent，該Intent的Action是

      //"android.intent.action.APP_ERROR"，指定接收者是app. errorReportReceiver

      //成員，該成員變數在關鍵點makeAppCrashingLocked中被設定

       appErrorIntent =createAppErrorIntentLocked(r, timeMillis,

                       crashInfo);

   }//synchronized(this)結束

   if(appErrorIntent != null) {

       try {//啟動能處理APP_ERROR的應用程式，目前的原始碼中還沒有地方處理它

             mContext.startActivity(appErrorIntent);

       } ......

    }

 }

private booleanmakeAppCrashingLocked(ProcessRecord app,

           String shortMsg, String longMsg, String stackTrace) {

  app.crashing = true;

   //生成一個錯誤報告，存放在crashingReport變數中

  app.crashingReport = generateProcessError(app,

               ActivityManager.ProcessErrorStateInfo.CRASHED, null, shortMsg,

               longMsg, stackTrace);

   /*

    在上邊程式碼中，我們知道系統會通過APP_ERROR Intent啟動一個Activity去處理錯誤報告，

    實際上在此之前，系統需要為它找到指定的接收者（如果有）。程式碼在startAppProblemLocked

    中，此處簡單描述該函式的處理過程如下：

    1 先查詢Settings Secure表中“send_action_app_error”是否使能，如果沒有使能，則

      不能設定指定接收者

    2 通過PKMS查詢安裝此Crash應用的應用是否能接收APP_ERROR Intent。必須注意

     安裝此應用的應用（例如通過“安卓市場”安裝了該Crash應用）。如果沒有，則轉下一步處理

    3 查詢系統屬性“ro.error.receiver.system.apps”是否指定了APP_ERROR處理者，如果

      沒有，則轉下一步處理

    4 查詢系統屬性“ro.error.receiver.default”是否指定了預設的處理者

    5 處理者的資訊儲存在app的errorReportReceiver變數中

    另外，如果該Crash應用正好是序列廣播傳送處理中的一員，則需要結束它的處理流程以

    保證後續廣播處理能正常執行。讀者可參考skipCurrentReceiverLocked函式

  */

  startAppProblemLocked(app);

  app.stopFreezingAllLocked();

   //呼叫handleAppCrashLocked做進一步處理。讀者可自行閱讀

   returnhandleAppCrashLocked(app);

 }

public void binderDied() {

  //注意，該函式也是通過Binder執行緒呼叫的，所以此處要加鎖

 synchronized(ActivityManagerService.this) {

       appDiedLocked(mApp, mPid, mAppThread);

   }

 }

final void appDiedLocked(ProcessRecord app, intpid,

                                                IApplicationThread thread) {

   ......

   if(app.pid == pid && app.thread != null &&

          app.thread.asBinder() == thread.asBinder()) {

   //當記憶體低到水位線時，LMK模組也會殺死程式。對AMS來說，需要區分程式死亡是LMK導致的

   //還是其他原因導致的。App instrumentationClass一般都為空，故此處doLowMem為true

    booleandoLowMem = app.instrumentationClass == null;

    //①下面這個函式非常重要

   handleAppDiedLocked(app, false, true);

    if(doLowMem) {

      boolean haveBg = false;

      //如果系統中還存在oom_adj大於HIDDEN_APP_MIN_ADJ的程式，就表明不是LMK模組因

      //記憶體不夠而導致程式死亡的

       for(int i=mLruProcesses.size()-1; i>=0; i--) {

          ProcessRecord rec = mLruProcesses.get(i);

          if (rec.thread != null && rec.setAdj >=

                                           ProcessList.HIDDEN_APP_MIN_ADJ){

                haveBg = true;//還有後臺程式，故可確定系統記憶體尚未吃緊

                break;

            }

        }//for迴圈結束

      //如果沒有後臺程式，表明系統記憶體已吃緊

      if(!haveBg) {

         long now = SystemClock.uptimeMillis();

          for(int i=mLruProcesses.size()-1; i>=0; i--) {

               .....//將這些程式按一定規則加到mProcessesToGc中，儘量保證

              //heavy/important/visible/foreground的程式位於mProcessesToGc陣列

              //的前端

          }//for迴圈結束

          /*

           傳送GC_BACKGROUND_PROCESSES_MSG訊息給mHandler，該訊息的處理過程就是：

           呼叫應用程式的scheduleLowMemory或processInBackground函式。其中，

           scheduleLowMemory將觸發onLowMemory回撥被呼叫，而processInBackground將

           觸發應用程式進行一次垃圾回收

           讀者可自行閱讀該訊息的處理函式performAppGcsIfAppropriateLocked

          */

         scheduleAppGcsLocked();

       }// if(!haveBg)判斷結束

    }//if(doLowMem)判斷結束

 }

private final voidhandleAppDiedLocked(ProcessRecord app,

           boolean restarting, boolean allowRestart) {

   //①在本例中，傳入的引數為restarting=false, allowRestart=true

  cleanUpApplicationRecordLocked(app, restarting, allowRestart, -1);

   if(!restarting) {

       mLruProcesses.remove(app);

   }

   ......//下面還有一部分程式碼處理和Activity相關的收尾工作，讀者可自行閱讀

}

 privatefinal void cleanUpApplicationRecordLocked(ProcessRecord app,

       boolean restarting, boolean allowRestart, int index) {

   if (index>= 0) mLruProcesses.remove(index);

   mProcessesToGc.remove(app);

   //如果該Crash程式有對應開啟的對話方塊，則關閉它們，這些對話方塊包括crash、anr和wait等

   if(app.crashDialog != null) {

       app.crashDialog.dismiss();

       app.crashDialog = null;

   }

   ......//處理anrDialog、waitDialog

   //清理app的一些引數

  app.crashing = false;

  app.notResponding = false;

   ......

   //處理該程式中所駐留的Service或它和別的程式中的Service建立的Connection關係

   //該函式是AMS Service處理流程中很重要的一環，讀者要仔細閱讀

   killServicesLocked(app,allowRestart);

   booleanrestart = false;

   int NL = mLaunchingProviders.size();

   if(!app.pubProviders.isEmpty()) {

       //得到該程式中釋出的ContentProvider資訊

       Iterator<ContentProviderRecord> it =

                          app.pubProviders.values().iterator();

       while(it.hasNext()) {

         ContentProviderRecord cpr = it.next();

          cpr.provider = null;

         cpr.proc = null;

         int i = 0;

          if(!app.bad && allowRestart) {

              for (; i<NL; i++) {

                 /*

                   如果有客戶端程式在等待這個已經死亡的ContentProvider,則系統會

                   嘗試重新啟動它，即設定restart變數為true

                */

                 if (mLaunchingProviders.get(i) == cpr) {

                       restart = true;

                        break;

                  }

              }//for迴圈結束

          } else  i = NL;

          if(i >= NL) {

             /*

              如果沒有客戶端程式等待這個ContentProvider，則呼叫下面這個函式處理它，我們

              在卷I的第10章曾提過一個問題，即ContentProvider程式被殺死

              後，系統該如何處理那些使用了該ContentProvider的客戶端程式。例如，Music和

              MediaProvider之間有互動，如果殺死了MediaProvider，Music會怎樣呢？

              答案是系統會殺死Music，證據就在removeDyingProviderLocked函式

              中，讀者可自行閱讀其內部處理流程

             */

             removeDyingProviderLocked(app, cpr);

             NL = mLaunchingProviders.size();

           }

      }// while(it.hasNext())迴圈結束

    app.pubProviders.clear();

   }

   //下面這個函式的功能是檢查本程式中的ContentProvider是否存在於

  // mLaunchingProviders中，如果存在，則表明有客戶端在等待，故需考慮是否重啟本程式或者

  //殺死客戶端（當死亡程式變成bad process的時，需要殺死客戶端）

   if(checkAppInLaunchingProvidersLocked(app, false)) restart = true;

   ......

  skipCurrentReceiverLocked(app);

    //從AMS中去除接收者

   if(app.receivers.size() > 0) {

      Iterator<ReceiverList> it = app.receivers.iterator();

       while(it.hasNext()) {

          removeReceiverLocked(it.next());

        }

       app.receivers.clear();

   }

   if(mBackupTarget != null && app.pid == mBackupTarget.app.pid) {

         //處理Backup資訊

    }

    mHandler.obtainMessage(DISPATCH_PROCESS_DIED, app.pid,

                                   app.info.uid,null).sendToTarget();

    //注意該變數名為restarting，前面設定為restart.

    if(restarting) return;

    if(!app.persistent) {

        mProcessNames.remove(app.processName, app.info.uid);

         if(mHeavyWeightProcess == app) {

             ......//處理HeavyWeightProcess

           }

      } elseif (!app.removed) {

         if(mPersistentStartingProcesses.indexOf(app) < 0) {

              mPersistentStartingProcesses.add(app);

               restart = true;

          }

      }

    mProcessesOnHold.remove(app);

     if (app== mHomeProcess)  mHomeProcess = null;

     if(restart) {//如果需要重啟，則呼叫startProcessLocked處理它

          mProcessNames.put(app.processName, app.info.uid, app);

         startProcessLocked(app, "restart", app.processName);

     } elseif (app.pid > 0 && app.pid != MY_PID) {

        synchronized (mPidsSelfLocked) {

             mPidsSelfLocked.remove(app.pid);

             mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);

          }

         app.setPid(0);

     }

 }