提示讀者在原始碼中可能找不到IPackageManager.java檔案。該檔案在編譯過程中是經aidl工具處理IPackageManager.aidl後得到，最終的檔案位置在Android原始碼/out/target

/common/obj/JAVA_LIBRARIES/framework_intermediates/src/core/java/android/content/pm/目錄中。如果讀者沒有整體編譯過原始碼，也可使用aidl工具單獨處理IPackageManager.aidl。

public interface IPackageManager extendsandroid.os.IInterface {

     //定義內部類Stub，派生自Binder，實現IPackageManager介面

      publicstatic abstract class Stub extends android.os.Binder

                      implements  android.content.pm.IPackageManager {

            privatestatic final java.lang.String DESCRIPTOR =

                                   "android.content.pm.IPackageManager";

            publicStub() {

                 this.attachInterface(this,DESCRIPTOR);

             }

            ......

               //定義Stub的內部類Proxy，實現IPackageManager介面

            privatestatic class Proxy implements

                                   android.content.pm.IPackageManager{

                  //通過mRemote變數和服務端互動

                 private android.os.IBinder mRemote;

                         Proxy(android.os.IBinderremote) {

                         mRemote = remote;

                        }

                           ......

              }

          ......

}

......//ServerThread的run函式

 /*

 4.0新增的一個功能，即裝置加密（encrypting the device）,該功能由

 系統屬性vold.decrypt指定。這部分功能比較複雜，本書暫不討論。

 該功能對PKMS的影響就是通過onlyCore實現的，該變數用於判斷是否只掃描系統庫

 （包括APK和Jar包）

 */

 StringcryptState = SystemProperties.get("vold.decrypt");

 booleanonlyCore = false;

 //ENCRYPTING_STATE的值為"trigger_restart_min_framework"

 if(ENCRYPTING_STATE.equals(cryptState)) {

       ......

      onlyCore = true;

 } else if(ENCRYPTED_STATE.equals(cryptState)) {

       ......//ENCRYPTED_STATE的值為"1"

     onlyCore = true;

 }

 //①呼叫PKMS的main函式，第二個引數用於判斷是否為工廠測試，我們不討論的這種情況，

 //假定onlyCore的值為false

 pm =PackageManagerService.main(context,

           factoryTest !=SystemServer.FACTORY_TEST_OFF,onlyCore);

 booleanfirstBoot = false;

 try {

         //判斷本次是否為初次啟動。當Zygote或SystemServer退出時，init會再次啟動

        //它們，所以這裡的FirstBoot是指開機後的第一次啟動

        firstBoot = pm.isFirstBoot();

 }

......

  try {

        //②做dex優化。dex是Android上針對Java位元組碼的一種優化技術，可提高執行效率

       pm.performBootDexOpt();

  }

 ......

  try {

        pm.systemReady();//③通知系統進入就緒狀態

 }

......

}//run函式結束

public static final IPackageManager main(Contextcontext, boolean factoryTest,

           boolean onlyCore) {

        //呼叫PKMS的建構函式，factoryTest和onlyCore的值均為false

       PackageManagerService m = new PackageManagerService(context,

                                            factoryTest, onlyCore);

        //向ServiceManager註冊PKMS

       ServiceManager.addService("package", m);

       return m;

 }

public PackageManagerService(Context context,boolean factoryTest,

                                  booleanonlyCore) {

       ......

        if(mSdkVersion <= 0) {

           /*

             mSdkVersion是PKMS的成員變數，定義的時候進行賦值，其值取自系統屬性

             “ro.build.version.sdk”，即編譯的SDK版本。如果沒有定義，則APK

             就無法知道自己執行在Android哪個版本上

          */

           Slog.w(TAG, "**** ro.build.version.sdk not set!");//列印一句警告

        }

       mContext = context;

        mFactoryTest= factoryTest;//假定為false，即執行在非工廠模式下

       mOnlyCore = onlyCore;//假定為false，即執行在普通模式下

        //如果此係統是eng版，則掃描Package後，不對package做dex優化

       mNoDexOpt ="eng".equals(SystemProperties.get("ro.build.type"));

       //mMetrics用於儲存與螢幕相關的一些屬性，例如螢幕的寬/高尺寸，解析度等資訊

       mMetrics = new DisplayMetrics();

       //Settings是一個非常重要的類，該類用於儲存系統執行過程中的一些設定，

        //下面進行詳細分析        mSettings = new Settings();

       //①addSharedUserLPw是什麼？馬上來分析

       mSettings.addSharedUserLPw("android.uid.system",

               Process.SYSTEM_UID, ApplicationInfo.FLAG_SYSTEM);

       mSettings.addSharedUserLPw("android.uid.phone",

               MULTIPLE_APPLICATION_UIDS  //該變數的預設值是true

                        ? RADIO_UID :FIRST_APPLICATION_UID,

               ApplicationInfo.FLAG_SYSTEM);

       mSettings.addSharedUserLPw("android.uid.log",

               MULTIPLE_APPLICATION_UIDS

                        ? LOG_UID :FIRST_APPLICATION_UID,

               ApplicationInfo.FLAG_SYSTEM);

       mSettings.addSharedUserLPw("android.uid.nfc",

               MULTIPLE_APPLICATION_UIDS

                        ? NFC_UID :FIRST_APPLICATION_UID,

               ApplicationInfo.FLAG_SYSTEM);

       ......//第一段結束

mSettings.addSharedUserLPw("android.uid.system",//字串

              Process.SYSTEM_UID, //系統程式使用的使用者id，值為1000

              ApplicationInfo.FLAG_SYSTEM//標誌系統Package

);

提示Linux的UID/GID還可細分為幾種型別，此處我們僅考慮普適意義的UID/GID。

   //系統程式使用的UID/GID，值為1000

   publicstatic final int SYSTEM_UID = 1000;

   //Phone程式使用的UID/GID，值為1001

   publicstatic final int PHONE_UID = 1001;

   //shell程式使用的UID/GID，值為2000

   publicstatic final int SHELL_UID = 2000;

   //使用LOG的程式所在的組的UID/GID為1007

   publicstatic final int LOG_UID = 1007;

   //供WIF相關程式使用的UID/GID為1010

   publicstatic final int WIFI_UID = 1010;

  //mediaserver程式使用的UID/GID為1013

   publicstatic final int MEDIA_UID = 1013;

   //設定能讀寫SD卡的程式的GID為1015

   publicstatic final int SDCARD_RW_GID = 1015;

   //NFC相關的程式的UID/GID為1025

   publicstatic final int NFC_UID = 1025;

   //有許可權讀寫內部儲存的程式的GID為1023

   publicstatic final int MEDIA_RW_GID = 1023;

   //第一個應用Package的起始UID為10000

   publicstatic final int FIRST_APPLICATION_UID = 10000;

   //系統所支援的最大的應用Package的UID為99999

   publicstatic final int LAST_APPLICATION_UID = 99999;

   //和藍芽相關的程式的GID為2000

   publicstatic final int BLUETOOTH_GID = 2000;

提示讀者可用adb shell（將什麼？）登入到自己的手機，然後用busybox提供的ps命令檢視程式的UID。

SharedUserSetting addSharedUserLPw(String name,int uid, int pkgFlags) {

      /*

        注意這裡的引數：name為字串”android.uid.system”,uid為1000，pkgFlags為

        ApplicationInfo.FLAG_SYSETM(以後簡寫為FLAG_SYSTEM)

      */

       //mSharedUsers是一個HashMap，key為字串，值為SharedUserSetting物件

       SharedUserSetting s = mSharedUsers.get(name);

        if(s != null) {

           if (s.userId == uid) {

               return s;

           }......

           return null;

        }

        //建立一個新的SharedUserSettings物件，並設定的userId為uid，

       //SharedUserSettings是什麼？有什麼作用？

        s =new SharedUserSetting(name, pkgFlags);

       s.userId = uid;

        if(addUserIdLPw(uid, s, name)) {

           mSharedUsers.put(name, s);//將name與s鍵值對新增到mSharedUsers中儲存

           return s;

        }

       return null;

    }

<manifestxmlns:android="http://schemas.android.com/apk/res/android"

       package="com.android.systemui"

       coreApp="true"

        android:sharedUserId="android.uid.system"

       android:process="system">

 ......

提示除了在AndroidManifest.xml中宣告sharedUserId外，APK在編譯時還必須使用對應的證照進行簽名。例如本例的SystemUI，在其Android.mk中需要額外宣告LOCAL_CERTIFICATE := platform，如此，才可獲得指定的UID。

提示 根據以上對mUserIds和mOtherUserIds的描述，可知這是典型的以空間換時間的做法。

private boolean addUserIdLPw(int uid, Object obj, Objectname) {

         //uid不能超出限制。Android對UID進行了分類，應用APK所在程式的UID從10000開始，

        //而系統APK所在程式小於10000

        if(uid >= PackageManagerService.FIRST_APPLICATION_UID +

                            PackageManagerService.MAX_APPLICATION_UIDS){

           return false;

        }

        if(uid >= PackageManagerService.FIRST_APPLICATION_UID) {

           int N = mUserIds.size();

          //計算索引，其值是uid和FIRST_APPLICATION_UID的差

           final int index = uid - PackageManagerService.FIRST_APPLICATION_UID;

           while (index >= N) {

               mUserIds.add(null);

               N++;

           }

            ......//判斷該索引位置的內容是否為空，為空才儲存

           mUserIds.set(index, obj);//mUserIds儲存應用Package的UID

        }else {

           ......

            mOtherUserIds.put(uid, obj);//系統Package的UID由mOtherUserIds儲存

        }

       return true;

}

       ......//接前一段

       String separateProcesses = //該值和除錯有關。一般不設定該屬性

                          SystemProperties.get("debug.separate_processes");

        if(separateProcesses != null && separateProcesses.length() > 0) {

          ......

        }else {

           mDefParseFlags = 0;

           mSeparateProcesses = null;

        }

        //建立一個Installer物件，該物件和Native程式installd互動，以後分析installd

        //時再來討論它的作用

       mInstaller = new Installer();

       WindowManager wm =  //得到一個WindowManager物件

              (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);

       Display d = wm.getDefaultDisplay();

       d.getMetrics(mMetrics); //獲取當前裝置的螢幕資訊

       synchronized (mInstallLock) {

       synchronized (mPackages) {

           //建立一個ThreadHandler物件，實際就是建立一個帶訊息迴圈處理的執行緒，該執行緒

           //的工作是：程式的和解除安裝等。以後分析程式安裝時會和它親密接觸

           mHandlerThread.start();

          //以ThreadHandler執行緒的訊息迴圈(Looper物件)為引數建立一個PackageHandler，

           //可知該Handler的handleMessage函式將執行在此執行緒上

           mHandler = new PackageHandler(mHandlerThread.getLooper());

            File dataDir = Environment.getDataDirectory();

          // mAppDataDir指向/data/data目錄

           mAppDataDir = new File(dataDir, "data");

           // mUserAppDataDir指向/data/user目錄

           mUserAppDataDir = new File(dataDir, "user");

           // mDrmAppPrivateInstallDir指向/data/app-private目錄

           mDrmAppPrivateInstallDir = new File(dataDir, "app-private");

           /*

            建立一個UserManager物件，目前沒有什麼作用，但其前途將不可限量。

             根據Google的設想，未來手機將支援多個User，每個User將安裝自己的應用，

             該功能為Andorid智慧手機推向企業使用者打下堅實基礎

            */

           mUserManager = new UserManager(mInstaller, mUserAppDataDir);

           //①從檔案中讀許可權

           readPermissions();

           //②readLPw分析

           mRestoredSettings = mSettings.readLPw();

           long startTime = SystemClock.uptimeMillis();

void readPermissions() {

        // 指向/system/etc/permission目錄，該目錄中儲存了和裝置相關的一些許可權資訊

        FilelibraryDir = new File(Environment.getRootDirectory(),

                                        "etc/permissions");

        ......

        for(File f : libraryDir.listFiles()) {

           //先處理該目錄下的非platform.xml檔案

           if (f.getPath().endsWith("etc/permissions/platform.xml")) {

               continue;

           }

            ......//呼叫readPermissionFromXml解析此XML檔案

           readPermissionsFromXml(f);

        }

       finalFile permFile = new File(Environment.getRootDirectory(),

               "etc/permissions/platform.xml");

        //解析platform.xml檔案，看來該檔案優先順序最高

       readPermissionsFromXml(permFile);

}

<permissions>

   <!--建立許可權名與gid的對映關係。如下面宣告的BLUTOOTH_ADMIN許可權，它對應的使用者組是

    net_bt_admin。注意，該檔案中的permission標籤只對那些需要通過讀寫裝置（藍芽/camera）

     /建立socket等程式劃分了gid。因為這些許可權涉及和Linux核心互動，所以需要在底層

     許可權（由不同的使用者組界定）和Android層許可權（由不同的字串界定）之間建立對映關係

  -->

 <permission name="android.permission.BLUETOOTH_ADMIN" >

       <group gid="net_bt_admin" />

 </permission>

 <permission name="android.permission.BLUETOOTH" >

       <group gid="net_bt" />

  </permission>

  ......

   <!--

     賦予對應uid相應的許可權。如果下面一行表示uid為shell，那麼就賦予

       它SEND_SMS的許可權，其實就是把它加到對應的使用者組中-->

   <assign-permission name="android.permission.SEND_SMS"uid="shell" />

   <assign-permission name="android.permission.CALL_PHONE"uid="shell" />

   <assign-permission name="android.permission.READ_CONTACTS"uid="shell" />

   <assign-permission name="android.permission.WRITE_CONTACTS"uid="shell" />

    <assign-permissionname="android.permission.READ_CALENDAR" uid="shell" />

......

    <!-- 系統提供的Java庫，應用程式執行時候必須要連結這些庫，該工作由系統自動完成 -->

    <libraryname="android.test.runner"

           file="/system/frameworks/android.test.runner.jar" />

    <library name="javax.obex"

           file="/system/frameworks/javax.obex.jar"/>

</permissions>

<permissions>

   <feature name="android.hardware.camera" />

   <feature name="android.hardware.location" />

   <feature name="android.hardware.location.network" />

   <feature name="android.hardware.sensor.compass" />

   <feature name="android.hardware.sensor.accelerometer" />

   <feature name="android.hardware.bluetooth" />

   <feature name="android.hardware.touchscreen" />

   <feature name="android.hardware.microphone" />

   <feature name="android.hardware.screen.portrait" />

   <feature name="android.hardware.screen.landscape" />

   </permissions>

注意對於不同的硬體特性，還需要包含其他的xml檔案。例如，要支援前置攝像頭，還需要包含android.hardware.camera.front.xml檔案。這些檔案內容大體一樣，都通過feature標籤表明自己的硬體特性。相關說明可參考handheld-core-hardware.xml中的註釋。

注意4.0原始碼中並沒有htc相關的檔案，這是筆者從2.3原始碼中移植過去的。讀者可參考筆者一篇關於如何移植4.0到G7的博文，地址為http://blog.csdn.net/innost/article/details/6977167。

private void readPermissionsFromXml(File permFile){

       FileReader permReader = null;

        try{

           permReader = new FileReader(permFile);

        } ......

        try{

           XmlPullParser parser = Xml.newPullParser();

           parser.setInput(permReader);

           XmlUtils.beginDocument(parser, "permissions");

           while (true) {

               ......

               String name = parser.getName();

               //解析group標籤，前面介紹的XML檔案中沒有單獨使用該標籤的地方

               if ("group".equals(name)) {

                   String gidStr = parser.getAttributeValue(null, "gid");

                   if (gidStr != null) {

                        int gid =Integer.parseInt(gidStr);

                        //轉換XML中的gid字串為整型，並儲存到mGlobalGids中

                        mGlobalGids =appendInt(mGlobalGids, gid);

                   } ......

               } else if ("permission".equals(name)) {//解析permission標籤

                   String perm = parser.getAttributeValue(null, "name");

                  ......

                   perm = perm.intern();

                     //呼叫readPermission處理

                   readPermission(parser, perm);

                 //下面解析的是assign-permission標籤

                } else if("assign-permission".equals(name)) {

                   String perm = parser.getAttributeValue(null, "name");

                   ......

                   String uidStr = parser.getAttributeValue(null, "uid");

                   ......

                   //如果是assign-permission，則取出uid字串，然後獲得Linux平臺上

                   //的整型uid值

                   int uid = Process.getUidForName(uidStr);

                  ......

                   perm = perm.intern();

                   //和assign相關的資訊儲存在mSystemPermissions中

                   HashSet<String> perms = mSystemPermissions.get(uid);

                   if (perms == null) {

                        perms = newHashSet<String>();

                       mSystemPermissions.put(uid, perms);

                   }

                   perms.add(perm);......

                  } else if ("library".equals(name)) {//解析library標籤

                   String lname = parser.getAttributeValue(null, "name");

                   String lfile = parser.getAttributeValue(null, "file");

                   if (lname == null) {

                        ......

                   } else if (lfile == null) {

                        ......

                   } else {

                        //將XML中的name和library屬性值儲存到mSharedLibraries中

                       mSharedLibraries.put(lname,lfile);

                   } ......

               } else if ("feature".equals(name)) {//解析feature標籤

                   String fname = parser.getAttributeValue(null, "name");

                    ......{

                        //在XML中定義的feature由FeatureInfo表達

                        FeatureInfo fi = newFeatureInfo();

                        fi.name = fname;

                        //儲存feature名和對應的FeatureInfo到mAvailableFeatures中

                       mAvailableFeatures.put(fname, fi);

                   }......

                } ......

        } ......

    }

Settings() {

        FiledataDir = Environment.getDataDirectory();

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

       systemDir.mkdirs();//建立該目錄

        ......

        /*

        一共有5個檔案，packages.xml和packages-backup.xml為一組，用於描述系統中

        所安裝的Package的資訊，其中backup是臨時檔案。PKMS先把資料寫到backup中，

        資訊都寫成功後再改名成非backup的檔案。其目的是防止在寫檔案過程中出錯，導致資訊丟失。

         packages-stopped.xml和packages-stopped-backup.xml為一組，用於描述系統中

         強制停止執行的pakcage的資訊，backup也是臨時檔案。如果此處存在該臨時檔案，表明

        此前系統因為某種原因中斷了正常流程

        packages.list列出當前系統中應用級（即UID大於10000）Package的資訊

        */

       mSettingsFilename = new File(systemDir, "packages.xml");

       mBackupSettingsFilename = new File(systemDir,"packages-backup.xml");

       mPackageListFilename = new File(systemDir, "packages.list");

       mStoppedPackagesFilename = new File(systemDir,"packages-stopped.xml");

       mBackupStoppedPackagesFilename = new File(systemDir,

                                            "packages-stopped-backup.xml");

}

提示讀者看完本章後，可自行分析該函式。在此之前，建議讀者不必關注該函式。

......

 mRestoredSettings= mSettings.readLPw();//接第一段的結尾

 longstartTime = SystemClock.uptimeMillis();//記錄掃描開始的時間

//定義掃描引數

 intscanMode = SCAN_MONITOR | SCAN_NO_PATHS | SCAN_DEFER_DEX;

 if(mNoDexOpt) {

    scanMode|= SCAN_NO_DEX; //在控制掃描過程中是否對APK檔案進行dex優化

  }

 finalHashSet<String> libFiles = new HashSet<String>();

 // mFrameworkDir指向/system/frameworks目錄

 mFrameworkDir = newFile(Environment.getRootDirectory(),"framework");

 // mDalvikCacheDir指向/data/dalvik-cache目錄

 mDalvikCacheDir= new File(dataDir, "dalvik-cache");

 booleandidDexOpt = false;

 /*

  獲取Java啟動類庫的路徑，在init.rc檔案中通過BOOTCLASSPATH環境變數輸出，該值如下

  /system/framework/core.jar:/system/frameworks/core-junit.jar:

  /system/frameworks/bouncycastle.jar:/system/frameworks/ext.jar:

  /system/frameworks/framework.jar:/system/frameworks/android.policy.jar:

  /system/frameworks/services.jar:/system/frameworks/apache-xml.jar:

  /system/frameworks/filterfw.jar

  該變數指明瞭framework所有核心庫及檔案位置

 */

 StringbootClassPath = System.getProperty("java.boot.class.path");

 if(bootClassPath != null) {

     String[] paths = splitString(bootClassPath, ':');

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

        try{  //判斷該jar包是否需要重新做dex優化

             if (dalvik.system.DexFile.isDexOptNeeded(paths[i])) {

                  /*

                   將該jar包檔案路徑儲存到libFiles中，然後通過mInstall物件傳送

                   命令給installd，讓其對該jar包進行dex優化

                  */

                  libFiles.add(paths[i]);

                  mInstaller.dexopt(paths[i], Process.SYSTEM_UID, true);

                  didDexOpt = true;

                }

              } ......

           }

      } ......

   /*

    讀者還記得mSharedLibrarires的作用嗎？它儲存的是platform.xml中宣告的系統庫的資訊。

    這裡也要判斷系統庫是否需要做dex優化。處理方式同上

   */

if (mSharedLibraries.size() > 0) {

     ......

 }

     //將framework-res.apk新增到libFiles中。framework-res.apk定義了系統常用的

    //資源，還有幾個重要的Activity，如長按Power鍵後彈出的選擇框

    libFiles.add(mFrameworkDir.getPath() + "/framework-res.apk");

     //列舉/system/frameworks目錄中的檔案

    String[] frameworkFiles = mFrameworkDir.list();

     if(frameworkFiles != null) {

         ......//判斷該目錄下的apk或jar檔案是否需要做dex優化。處理方式同上

 }

   /*

   上面程式碼對系統庫（BOOTCLASSPATH指定，或 platform.xml定義，或

  /system/frameworks目錄下的jar包與apk檔案）進行一次仔細檢查，該優化的一定要優化。

  如果發現期間對任何一個檔案進行了優化，則設定didDexOpt為true

  */

     if (didDexOpt) {

      String[] files = mDalvikCacheDir.list();

        if (files != null) {

          /*

         如果前面對任意一個系統庫重新做過dex優化，就需要刪除cache檔案。原因和

         dalvik虛擬機器的執行機制有關。本書暫不探討dex及cache檔案的作用。

         從刪除cache檔案這個操作來看，這些cache檔案應該使用了dex優化後的系統庫

         所以當系統庫重新做dex優化後，就需要刪除舊的cache檔案。可簡單理解為快取失效

        */

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

                   String fn = files[i];

                     if(fn.startsWith("data@app@")

                          ||fn.startsWith("data@app-private@")) {

                          (newFile(mDalvikCacheDir, fn)).delete();

        ......

 }

   //建立資料夾監控物件，監視/system/frameworks目錄。利用了Linux平臺的inotify機制

  mFrameworkInstallObserver = new AppDirObserver(

                      mFrameworkDir.getPath(),OBSERVER_EVENTS, true);

   mFrameworkInstallObserver.startWatching();

 /*

  呼叫scanDirLI函式掃描/system/frameworks目錄，這個函式很重要，稍後會再分析。

  注意，在第三個引數中設定了SCAN_NO_DEX標誌，因為該目錄下的package在前面的流程

  中已經過判斷並根據需要做過dex優化了

 */

   scanDirLI(mFrameworkDir, PackageParser.PARSE_IS_SYSTEM

            | PackageParser.PARSE_IS_SYSTEM_DIR,scanMode | SCAN_NO_DEX, 0);

     //建立資料夾監控物件，監視/system/app目錄

   mSystemAppDir = new File(Environment.getRootDirectory(),"app");

   mSystemInstallObserver = new AppDirObserver(

               mSystemAppDir.getPath(), OBSERVER_EVENTS, true);

    mSystemInstallObserver.startWatching();

 //掃描/system/app下的package

   scanDirLI(mSystemAppDir, PackageParser.PARSE_IS_SYSTEM

                   | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);

     //監視並掃描/vendor/app目錄

   mVendorAppDir = new File("/vendor/app");

   mVendorInstallObserver = new AppDirObserver(

               mVendorAppDir.getPath(), OBSERVER_EVENTS, true);

    mVendorInstallObserver.startWatching();

    //掃描/vendor/app下的package

   scanDirLI(mVendorAppDir, PackageParser.PARSE_IS_SYSTEM

                   | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);

    //和installd互動。以後單獨分析installd

   mInstaller.moveFiles();

注意本書把這三個目錄稱為系統Package目錄，以區分後面的非系統Package目錄。

private void scanDirLI(File dir, int flags, intscanMode, long currentTime) {

       String[] files = dir.list();//列舉該目錄下的檔案

       ......

        inti;

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

           File file = new File(dir, files[i]);

           if (!isPackageFilename(files[i])) {

                continue; //根據檔名字尾，判斷是否為APK 檔案。這裡只掃描APK 檔案

           }

           /*

            呼叫scanPackageLI函式掃描一個特定的檔案，返回值是PackageParser的內部類

            Package，該類的例項代表一個APK檔案，所以它就是和APK檔案對應的資料結構

          */

           PackageParser.Package pkg = scanPackageLI(file,

                flags|PackageParser.PARSE_MUST_BE_APK, scanMode, currentTime);

             if (pkg == null && (flags &PackageParser.PARSE_IS_SYSTEM) == 0 &&

               mLastScanError ==PackageManager.INSTALL_FAILED_INVALID_APK) {

               //注意此處flags的作用，只有非系統Package掃描失敗，才會刪除該檔案

               file.delete();

           }

   }

}

private PackageParser.Package scanPackageLI(FilescanFile, int parseFlags,

                                       int scanMode, long currentTime)

{

     mLastScanError = PackageManager.INSTALL_SUCCEEDED;

      StringscanPath = scanFile.getPath();

     parseFlags |= mDefParseFlags;//預設的掃描標誌，正常情況下為0

      //建立一個PackageParser物件

     PackageParser pp = new PackageParser(scanPath);

     pp.setSeparateProcesses(mSeparateProcesses);// mSeparateProcesses為空

     pp.setOnlyCoreApps(mOnlyCore);// mOnlyCore為false

      /*

       呼叫PackageParser的parsePackage函式解析APK檔案。注意，這裡把代表螢幕

       資訊的mMetrics物件也傳了進去

       */

      finalPackageParser.Package pkg = pp.parsePackage(scanFile,

               scanPath, mMetrics, parseFlags);

        ......

     PackageSetting ps = null;

     PackageSetting updatedPkg;

        ......

      /*

        這裡略去一大段程式碼，主要是關於Package升級方面的工作。讀者可能會比較好奇：既然是

        升級，一定有新舊之分，如果這裡剛解析後得到的Package資訊是新，那麼舊Package

        的資訊從何得來？還記得”readLPw的‘佐料’”這一小節提到的package.xml檔案嗎？此

        檔案中儲存的就是上一次掃描得到的Package資訊。對比這兩次的資訊就知道是否需要做

        升級了。這部分程式碼比較繁瑣，但不影響我們正常分析。感興趣的讀者可自行研究

      */

      //收集簽名資訊，這部分內容涉及signature，本書暫不擬討論[①]。

      if (!collectCertificatesLI(pp, ps, pkg,scanFile, parseFlags))

           returnnull;

     //判斷是否需要設定PARSE_FORWARD_LOCK標誌，這個標誌針對資原始檔和Class檔案

     //不在同一個目錄的情況。目前只有/vendor/app目錄下的掃描會使用該標誌。這裡不討論

     //這種情況。

      if (ps != null &&!ps.codePath.equals(ps.resourcePath))

           parseFlags|= PackageParser.PARSE_FORWARD_LOCK;

        String codePath = null;

       String resPath = null;

        if((parseFlags & PackageParser.PARSE_FORWARD_LOCK) != 0) {

            ......//這裡不考慮PARSE_FORWARD_LOCK的情況。

        }else {

           resPath = pkg.mScanPath;

        }

       codePath = pkg.mScanPath;//mScanPath指向該APK檔案所在位置

        //設定檔案路徑資訊，codePath和resPath都指向APK檔案所在位置

       setApplicationInfoPaths(pkg, codePath, resPath);

        //呼叫第二個scanPackageLI函式

       return scanPackageLI(pkg, parseFlags, scanMode | SCAN_UPDATE_SIGNATURE,

                                 currentTime);

}

 publicPackage parsePackage(File sourceFile, String destCodePath,

           DisplayMetrics metrics, int flags) {

       mParseError = PackageManager.INSTALL_SUCCEEDED;

       mArchiveSourcePath = sourceFile.getPath();

        ......//檢查是否為APK檔案

      XmlResourceParser parser = null;

       AssetManager assmgr = null;

       Resources res = null;

       boolean assetError = true;

        try{

           assmgr = new AssetManager();

           int cookie = assmgr.addAssetPath(mArchiveSourcePath);

           if (cookie != 0) {

               res = new Resources(assmgr, metrics, null);

               assmgr.setConfiguration(0, 0, null, 0, 0, 0, 0, 0, 0, 0, 0, 0,

                              0, 0, 0, 0,Build.VERSION.RESOURCES_SDK_INT);

          /*

           獲得一個XML資源解析物件，該物件解析的是APK中的AndroidManifest.xml檔案。

           以後再討論AssetManager、Resource及相關的知識

         */

            parser = assmgr.openXmlResourceParser(cookie,

                                                  ANDROID_MANIFEST_FILENAME);

               assetError = false;

           } ......//出錯處理

       String[] errorText = new String[1];

       Package pkg = null;

       Exception errorException = null;

        try {

           //呼叫另外一個parsePackage函式

           pkg = parsePackage(res, parser, flags, errorText);

        } ......

        ......//錯誤處理

       parser.close();

       assmgr.close();

       //儲存檔案路徑，都指向APK檔案所在的路徑

       pkg.mPath = destCodePath;

       pkg.mScanPath = mArchiveSourcePath;

       pkg.mSignatures = null;

       return pkg;

}

private Package parsePackage(

       Resources res, XmlResourceParser parser, int flags, String[] outError)

       throws XmlPullParserException, IOException {

       AttributeSet attrs = parser;

       mParseInstrumentationArgs = null;

       mParseActivityArgs = null;

        mParseServiceArgs= null;

       mParseProviderArgs = null;

       //得到Package的名字，其實就是得到AndroidManifest.xml中package屬性的值，

       //每個APK都必須定義該屬性

       String pkgName = parsePackageName(parser, attrs, flags, outError);

        ......

        inttype;

       ......

        //以pkgName名字為引數，建立一個Package物件。後面的工作就是解析XML並填充

       //該Package資訊

       finalPackage pkg = new Package(pkgName);

       boolean foundApp = false;

       ......//下面開始解析該檔案中的標籤，由於這段程式碼功能簡單，所以這裡僅列舉相關函式

      while(如果解析未完成){

      ......

       StringtagName = parser.getName(); //得到標籤名

       if(tagName.equals("application")){

          ......//解析application標籤

           parseApplication(pkg,res, parser, attrs, flags, outError);

       } elseif (tagName.equals("permission-group")) {

        ......//解析permission-group標籤

        parsePermissionGroup(pkg, res, parser, attrs, outError);

       } elseif (tagName.equals("permission")) {

        ......//解析permission標籤

        parsePermission(pkg, res, parser, attrs, outError);

       } else if(tagName.equals("uses-permission")){

          //從XML檔案中獲取uses-permission標籤的屬性

          sa= res.obtainAttributes(attrs,

            com.android.internal.R.styleable.AndroidManifestUsesPermission);

          //取出屬性值，也就是對應的許可權使用宣告

         String name = sa.getNonResourceString(com.android.internal.

                               R.styleable.AndroidManifestUsesPermission_name);

          //新增到Package的requestedPermissions陣列

          if(name != null && !pkg.requestedPermissions.contains(name)) {

               pkg.requestedPermissions.add(name.intern());

          }

       }elseif (tagName.equals("uses-configuration")){

        /*

           該標籤用於指明本package對硬體的一些設定引數，目前主要針對輸入裝置（觸控式螢幕、鍵盤

           等）。遊戲類的應用可能對此有特殊要求。

       */

         ConfigurationInfocPref = new ConfigurationInfo();

        ......//解析該標籤所支援的各種屬性

        pkg.configPreferences.add(cPref);//儲存到Package的configPreferences陣列

       }

      ......//對其他標籤解析和處理

}

注意讀者需要了解Java泛型類的相關知識。

private PackageParser.PackagescanPackageLI(PackageParser.Package pkg,

           int parseFlags, int scanMode, long currentTime) {

        FilescanFile = new File(pkg.mScanPath);

        ......

       mScanningPath = scanFile;

        //設定package物件中applicationInfo的flags標籤，用於標示該Package為系統

       //Package

        if((parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0) {

           pkg.applicationInfo.flags |= ApplicationInfo.FLAG_SYSTEM;

        }

        //①下面這句if判斷極為重要，見下面的解釋

        if(pkg.packageName.equals("android")) {

           synchronized (mPackages) {

               if (mAndroidApplication != null) {

                  ......

               mPlatformPackage = pkg;

               pkg.mVersionCode = mSdkVersion;

               mAndroidApplication = pkg.applicationInfo;

               mResolveActivity.applicationInfo = mAndroidApplication;

               mResolveActivity.name = ResolverActivity.class.getName();

               mResolveActivity.packageName = mAndroidApplication.packageName;

               mResolveActivity.processName = mAndroidApplication.processName;

               mResolveActivity.launchMode = ActivityInfo.LAUNCH_MULTIPLE;

               mResolveActivity.flags = ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS;

               mResolveActivity.theme =

                          com.android.internal.R.style.Theme_Holo_Dialog_Alert;

               mResolveActivity.exported = true;

               mResolveActivity.enabled = true;

               //mResoveInfo的activityInfo成員指向mResolveActivity

               mResolveInfo.activityInfo = mResolveActivity;

               mResolveInfo.priority = 0;

               mResolveInfo.preferredOrder = 0;

               mResolveInfo.match = 0;

               mResolveComponentName = new ComponentName(

                       mAndroidApplication.packageName, mResolveActivity.name);

           }

        }

注意在從PKMS中查詢滿足某個Intent的Activity時，返回的就是ResolveInfo，再根據ResolveInfo的資訊得到具體的Activity。

......//mPackages用於儲存系統內的所有Package，以packageName為key

   if(mPackages.containsKey(pkg.packageName)

               || mSharedLibraries.containsKey(pkg.packageName)) {

       return null;

   }

      File destCodeFile = newFile(pkg.applicationInfo.sourceDir);

      FiledestResourceFile = new File(pkg.applicationInfo.publicSourceDir);

      SharedUserSettingsuid = null;//代表該Package的SharedUserSetting物件

     PackageSetting pkgSetting = null;//代表該Package的PackageSetting物件

      synchronized(mPackages) {

         ......//此段程式碼大約有300行左右，主要做了以下幾方面工作

         /*

          ①如果該Packge宣告瞭” uses-librarie”話，那麼系統要判斷該library是否

            在mSharedLibraries中

          ②如果package宣告瞭SharedUser，則需要處理SharedUserSettings相關內容，

            由Settings的getSharedUserLPw函式處理

           ③處理pkgSetting，通過呼叫Settings的getPackageLPw函式完成

           ④呼叫verifySignaturesLP函式，檢查該Package的signature

          */

       }

      finallong scanFileTime = scanFile.lastModified();

      finalboolean forceDex = (scanMode&SCAN_FORCE_DEX) != 0;

      //確定執行該package的程式的程式名，一般用packageName作為程式名

     pkg.applicationInfo.processName = fixProcessName(

                         pkg.applicationInfo.packageName,

                         pkg.applicationInfo.processName,

                         pkg.applicationInfo.uid);

      if(mPlatformPackage == pkg) {

           dataPath = new File (Environment.getDataDirectory(),"system");

           pkg.applicationInfo.dataDir = dataPath.getPath();

        }else {

            /*

             getDataPathForPackage函式返回該package的目錄

            一般是/data/data/packageName/

           */

           dataPath = getDataPathForPackage(pkg.packageName, 0);

            if(dataPath.exists()){

             ......//如果該目錄已經存在，則要處理uid的問題

           } else {

             ......//向installd傳送install命令，實際上就是在/data/data下

                   //建立packageName目錄。後續將分析installd相關知識

               int ret = mInstaller.install(pkgName, pkg.applicationInfo.uid,

                       pkg.applicationInfo.uid);

              //為系統所有user安裝此程式

               mUserManager.installPackageForAllUsers(pkgName,

                                pkg.applicationInfo.uid);

               if (dataPath.exists()) {

                   pkg.applicationInfo.dataDir = dataPath.getPath();

               } ......

               if (pkg.applicationInfo.nativeLibraryDir == null &&

                      pkg.applicationInfo.dataDir!= null) {

               ......//為該Package確定native library所在目錄

              //一般是/data/data/packagename/lib

           }

}

    //如果該APK包含了native動態庫，則需要將它們從APK檔案中解壓並複製到對應目錄中

    if(pkg.applicationInfo.nativeLibraryDir != null) {

           try {

               final File nativeLibraryDir = new

                            File(pkg.applicationInfo.nativeLibraryDir);

               final String dataPathString = dataPath.getCanonicalPath();

               //從2.3開始，系統package的native庫統一放在/system/lib下。所以

               //系統不會提取系統Package目錄下APK包中的native庫

               if (isSystemApp(pkg) && !isUpdatedSystemApp(pkg)) {

                   NativeLibraryHelper.removeNativeBinariesFromDirLI(

                                            nativeLibraryDir)){

           } else if (nativeLibraryDir.getParentFile().getCanonicalPath()

                       .equals(dataPathString)) {

                   boolean isSymLink;

                   try {

                        isSymLink = S_ISLNK(Libcore.os.lstat(

                                        nativeLibraryDir.getPath()).st_mode);

                   } ......//判斷是否為連結，如果是，需要刪除該連結

                   if (isSymLink) {

                       mInstaller.unlinkNativeLibraryDirectory(dataPathString);

                   }

             //在lib下建立和CPU型別對應的目錄，例如ARM平臺的是arm/，MIPS平臺的是mips/

               NativeLibraryHelper.copyNativeBinariesIfNeededLI(scanFile,

                                   nativeLibraryDir);

               } else {

                   mInstaller.linkNativeLibraryDirectory(dataPathString,

                                       pkg.applicationInfo.nativeLibraryDir);

               }

           } ......

        }

     pkg.mScanPath= path;

     if((scanMode&SCAN_NO_DEX) == 0) {

            ......//對該APK做dex優化

        performDexOptLI(pkg,forceDex, (scanMode&SCAN_DEFER_DEX);

      }

     //如果該APK已經存在，要先殺掉執行該APK的程式

     if((parseFlags & PackageManager.INSTALL_REPLACE_EXISTING) != 0) {

           killApplication(pkg.applicationInfo.packageName,

                       pkg.applicationInfo.uid);

     }

......

     /*

     在此之前，四大元件資訊都屬於Package的私有財產，現在需要把它們登記註冊到PKMS內部的

     財產管理物件中。這樣，PKMS就可對外提供統一的元件資訊，而不必拘泥於具體的Package

     */

    synchronized(mPackages) {

   if ((scanMode&SCAN_MONITOR) != 0) {

        mAppDirs.put(pkg.mPath, pkg);

   }

  mSettings.insertPackageSettingLPw(pkgSetting, pkg);

   mPackages.put(pkg.applicationInfo.packageName,pkg);

   //處理該Package中的Provider資訊

   int N =pkg.providers.size();

   int i;

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

   PackageParser.Providerp = pkg.providers.get(i);

   p.info.processName=fixProcessName(

                               pkg.applicationInfo.processName,

                  p.info.processName, pkg.applicationInfo.uid);

    //mProvidersByComponent提供基於ComponentName的Provider資訊查詢

    mProvidersByComponent.put(new ComponentName(

                               p.info.packageName,p.info.name), p);

             ......

   }

   //處理該Package中的Service資訊

   N =pkg.services.size();

   r = null;

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

   PackageParser.Service s =pkg.services.get(i);

   mServices.addService(s);

   }

   //處理該Package中的BroadcastReceiver資訊

   N =pkg.receivers.size();

   r = null;

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

   PackageParser.Activity a =pkg.receivers.get(i);

   mReceivers.addActivity(a,"receiver");

   ......

   }

   //處理該Package中的Activity資訊

   N = pkg.activities.size();

   r =null;

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

   PackageParser.Activity a =pkg.activities.get(i);

   mActivities.addActivity(a,"activity");//後續將詳細分析該呼叫

  }

   //處理該Package中的PermissionGroups資訊

   N = pkg.permissionGroups.size();

   ......//permissionGroups處理

   N =pkg.permissions.size();

   ......//permissions處理

   N =pkg.instrumentation.size();

   ......//instrumentation處理

   if(pkg.protectedBroadcasts != null) {

      N = pkg.protectedBroadcasts.size();

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

        mProtectedBroadcasts.add(pkg.protectedBroadcasts.get(i));

      }

}

   ......//Package的私有財產終於完成了公有化改造

return pkg;

}

           if (!mOnlyCore) {//mOnlyCore用於控制是否掃描非系統Package

               Iterator<PackageSetting> psit =  

                            mSettings.mPackages.values().iterator();

               while (psit.hasNext()) {

                   ......//刪除系統package中那些不存在的APK

           }

             mAppInstallDir = new File(dataDir,"app");

            ......//刪除安裝不成功的檔案及臨時檔案

           if (!mOnlyCore) {

              //在普通模式下，還需要掃描/data/app以及/data/app_private目錄 

              mAppInstallObserver = new AppDirObserver(

                   mAppInstallDir.getPath(), OBSERVER_EVENTS, false);

              mAppInstallObserver.startWatching();

              scanDirLI(mAppInstallDir, 0, scanMode, 0);

               mDrmAppInstallObserver = newAppDirObserver(

                   mDrmAppPrivateInstallDir.getPath(), OBSERVER_EVENTS, false);

              mDrmAppInstallObserver.startWatching();

              scanDirLI(mDrmAppPrivateInstallDir,           

                            PackageParser.PARSE_FORWARD_LOCK,scanMode,0);

           } else {

               mAppInstallObserver = null;

               mDrmAppInstallObserver = null;

      }

......

  mSettings.mInternalSdkPlatform= mSdkVersion;

  //彙總並更新和Permission相關的資訊

  updatePermissionsLPw(null, null, true,

                           regrantPermissions,regrantPermissions);

   //將資訊寫到package.xml、package.list及package-stopped.xml檔案中

   mSettings.writeLPr();

   Runtime.getRuntime().gc();

    mRequiredVerifierPackage= getRequiredVerifierLPr();

......//PKMS建構函式返回

}

int adb_commandline(int argc, char **argv){

   ...... 

if(!strcmp(argv[0], "install")) {

       ......//呼叫install_app函式處理

       return install_app(ttype, serial, argc, argv);

}

......

}

int install_app(transport_type transport, char*serial, int argc, char** argv)

{

    //要安裝的APK現在還在Host機器上，要先把APK複製到手機中。

   //這裡需要設定複製目標的目錄，如果安裝在內部儲存中，則目標目錄為/data/local/tmp；

   //如果安裝在SD卡上，則目標目錄為/sdcard/tmp。

    staticconst char *const DATA_DEST = "/data/local/tmp/%s";

    staticconst char *const SD_DEST = "/sdcard/tmp/%s";

    constchar* where = DATA_DEST;

    charapk_dest[PATH_MAX];

    charverification_dest[PATH_MAX];

    char*apk_file;

    char*verification_file = NULL;

    intfile_arg = -1;

    int err;

    int i;

    for (i =1; i < argc; i++) {

        if(*argv[i] != '-') {

           file_arg = i;

           break;

        }else if (!strcmp(argv[i], "-i")) {

            i++;

        }else if (!strcmp(argv[i], "-s")) {

           where = SD_DEST; //-s引數指明該APK安裝到SD卡上

        }

    }

    ......

    apk_file= argv[file_arg];

    ......

    //獲取目標檔案的全路徑，如果安裝在內部儲存中，則目標全路徑為/data/local/tmp/安裝包名，

    //呼叫do_sync_push將此APK傳送到手機的目標路徑

    err =do_sync_push(apk_file, apk_dest, 1 /* verify APK */);

    ...... //①4.0新增了一個安裝包Verification功能，相關知識稍後分析

    //②執行pm命令，這個函式很有意思

    pm_command(transport,serial, argc, argv);

......

  cleanup_apk:

    //③在手機中執行shell rm 命令，刪除剛才傳送過去的目標APK檔案。為什麼要刪除呢

   delete_file(transport, serial, apk_dest);

    returnerr;

}

static int pm_command(transport_type transport,char* serial,

                      int argc, char** argv)

{

    charbuf[4096];

    snprintf(buf,sizeof(buf), "shell:pm");

  ......//準備引數

  //傳送"shell:pm install 引數"給手機端的adbd

   send_shellcommand(transport, serial, buf);

    return0;

}

提示讀者可以通過adb shell登入到自己手機，然後執行pm，看看會發現什麼。

# Script to start "pm" on the device,which has a very rudimentary

# shell.

#

base=/system

export CLASSPATH=$base/frameworks/pm.jar

exec app_process $base/bincom.android.commands.pm.Pm "$@"

注意Android系統中常用的monkeytest、pm、am等（這些都是指令碼檔案）都是以這種方式啟動的，所以嚴格地說，app_process才是Android Java程式的老祖宗。

public static void main(String[] args) {

        newPm().run(args);//建立一個Pm物件，並執行它的run函式

}

  //直接分析run函式

public void run(String[] args) {

       boolean validCommand = false;

        ......

        //獲取PKMS的binder客戶端

        mPm= IPackageManager.Stub.asInterface(

                        ServiceManager.getService("package"));

        ......

       mArgs = args;

       String op = args[0];

       mNextArg = 1;

       ......//處理其他命令，這裡僅考慮install的處理

        if("install".equals(op)) {

           runInstall();

           return;

        }

   ......

}

private void runInstall() {

        intinstallFlags = 0;

       String installerPackageName = null;

       String opt;

       while ((opt=nextOption()) != null) {

           if (opt.equals("-l")) {

               installFlags |= PackageManager.INSTALL_FORWARD_LOCK;

            } else if (opt.equals("-r")) {

               installFlags |= PackageManager.INSTALL_REPLACE_EXISTING;

           } else if (opt.equals("-i")) {

               installerPackageName = nextOptionData();

               ...... //引數解析

           } ......

        }

       final Uri apkURI;

       final Uri verificationURI;

       final String apkFilePath = nextArg();

       System.err.println("/tpkg: " + apkFilePath);

        if(apkFilePath != null) {

           apkURI = Uri.fromFile(new File(apkFilePath));

        }......

        //獲取Verification Package的檔案位置

       final String verificationFilePath = nextArg();

        if(verificationFilePath != null) {

          verificationURI = Uri.fromFile(new File(verificationFilePath));

        }else {

           verificationURI = null;

        }

        //建立PackageInstallObserver，用於接收PKMS的安裝結果

       PackageInstallObserver obs = new PackageInstallObserver();

        try{

          //①呼叫PKMS的installPackageWithVerification完成安裝

           mPm.installPackageWithVerification(apkURI, obs,

                                  installFlags,installerPackageName,

                                  verificationURI,null);

    synchronized (obs) {

      while(!obs.finished) {

          try{

                  obs.wait();//等待安裝結果

             } ......

         }

         if(obs.result == PackageManager.INSTALL_SUCCEEDED) {

             System.out.println("Success");//安裝成功，列印Success

         }......//安裝失敗，列印失敗原因

        } ......

    }

public void installPackageWithVerification(UripackageURI,

            IPackageInstallObserverobserver,

           int flags, String installerPackageName, Uri verificationURI,

           ManifestDigest manifestDigest) {

        //檢查客戶端程式是否具有安裝Package的許可權。在本例中，該客戶端程式是shell

       mContext.enforceCallingOrSelfPermission(

               android.Manifest.permission.INSTALL_PACKAGES,null);

       final int uid = Binder.getCallingUid();

       final int filteredFlags;

        if(uid == Process.SHELL_UID || uid == 0) {

             ......//如果通過shell pm的方式安裝，則增加INSTALL_FROM_ADB標誌

           filteredFlags = flags | PackageManager.INSTALL_FROM_ADB;

        }else {

           filteredFlags = flags & ~PackageManager.INSTALL_FROM_ADB;

        }

        //建立一個Message，code為INIT_COPY，將該訊息傳送給之前在PKMS建構函式中

       //建立的mHandler物件，將在另外一個工作執行緒中處理此訊息

       final Message msg = mHandler.obtainMessage(INIT_COPY);

        //建立一個InstallParams，其基類是HandlerParams

       msg.obj = new InstallParams(packageURI, observer,

                   filteredFlags,installerPackageName,

                  verificationURI,manifestDigest);

       mHandler.sendMessage(msg);

}

public void handleMessage(Message msg) {

  try {

         doHandleMessage(msg);//呼叫doHandleMessage函式

       } ......

 }

 voiddoHandleMessage(Message msg) {

 switch(msg.what) {

    caseINIT_COPY: {

      //①這裡記錄的是params的基類型別HandlerParams，實際型別為InstallParams

     HandlerParams params = (HandlerParams) msg.obj;

      //idx為當前等待處理的安裝請求的個數

      intidx = mPendingInstalls.size();

      if(!mBound) {

        /*

        很多讀者可能想不到，APK的安裝居然需要使用另外一個APK提供的服務，該服務就是

         DefaultContainerService，由DefaultCotainerService.apk提供，

         下面的connectToService函式將呼叫bindService來啟動該服務

        */

        if(!connectToService()) {

             return;

         }else {//如果已經連上，則以idx為索引，將params儲存到mPendingInstalls中

           mPendingInstalls.add(idx, params);

          }

        } else {

           mPendingInstalls.add(idx, params);

            if(idx == 0) {

            //如果安裝請求佇列之前的狀態為空，則表明要啟動安裝

            mHandler.sendEmptyMessage(MCS_BOUND);

           }

         }

        break;

        }

      ......//後續再分析

注意connectToService在呼叫bindService時會傳遞一個DefaultContainerConnection型別的物件，以接收服務啟動的結果。當該服務成功啟動後，此物件的onServiceConnected被呼叫，其內部也將傳送MCS_BOUND訊息給mHandler。

......//接doHandleMesage中的switch/case

case MCS_BOUND: {

  if(msg.obj != null) {

     mContainerService= (IMediaContainerService) msg.obj;

  }

  if(mContainerService == null) {

    ......//如果沒法啟動該service，則不能安裝程式

     mPendingInstalls.clear();

  } else if(mPendingInstalls.size() > 0) {

      HandlerParamsparams = mPendingInstalls.get(0);

      if(params != null) {

         //呼叫params物件的startCopy函式，該函式由基類HandlerParams定義

        if(params.startCopy()) {

           ......

            if(mPendingInstalls.size() > 0) {

               mPendingInstalls.remove(0);//刪除佇列頭

             }

          if (mPendingInstalls.size() == 0) {

            if (mBound) {

              ......//如果安裝請求都處理完了，則需要和Service斷絕聯絡,

              //通過傳送MSC_UNB訊息處理斷交請求。讀者可自行研究此情況的處理流程

               removeMessages(MCS_UNBIND);

               Message ubmsg = obtainMessage(MCS_UNBIND);

               sendMessageDelayed(ubmsg, 10000);

            }

            }else {

              //如果還有未處理的請求，則繼續傳送MCS_BOUND訊息。

              //為什麼不通過一個迴圈來處理所有請求呢

              mHandler.sendEmptyMessage(MCS_BOUND);

             }

            }

     } ......

    break;

提示讀者可以在介紹完MountService後，結合本章知識點，自行研究SdInstallArgs的處理流程。

final boolean startCopy() {

    booleanres;

    try {

    //MAX_RETIRES目前為4，表示嘗試4次安裝，如果還不成功，則認為安裝失敗

    if(++mRetries > MAX_RETRIES) {

        mHandler.sendEmptyMessage(MCS_GIVE_UP);

        handleServiceError();

        return false;

    } else {

         handleStartCopy();//①呼叫派生類的handleStartCopy函式

         res= true;

      }

    } ......

   handleReturnCode();//②呼叫派生類的handleReturnCode，返回處理結果

    returnres;

}

public void handleStartCopy() throwsRemoteException {

    int ret= PackageManager.INSTALL_SUCCEEDED;

    finalboolean fwdLocked = //本書不考慮fwdLocked的情況

        (flags &PackageManager.INSTALL_FORWARD_LOCK) != 0;

    //根據adb install的引數，判斷安裝位置

    finalboolean onSd = (flags & PackageManager.INSTALL_EXTERNAL) != 0;

    finalboolean onInt = (flags & PackageManager.INSTALL_INTERNAL) != 0;

   PackageInfoLite pkgLite = null;

    if(onInt && onSd) {

        //APK不能同時安裝在內部儲存和SD卡上

       ret =PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;

    } elseif (fwdLocked && onSd) {

    //fwdLocked的應用不能安裝在SD卡上

      ret =PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;

    } else {

       finallong lowThreshold;

       //獲取DeviceStorageMonitorService的binder客戶端

       finalDeviceStorageMonitorService dsm =                           

             (DeviceStorageMonitorService) ServiceManager.getService(

                                  DeviceStorageMonitorService.SERVICE);

       if(dsm == null) {

         lowThreshold = 0L;

       }else {

       //從DSMS查詢內部空間最小余量，預設是總空間的10%

     lowThreshold = dsm.getMemoryLowThreshold();

     }

     try {

        //授權DefContainerService URI讀許可權

      mContext.grantUriPermission(DEFAULT_CONTAINER_PACKAGE,

                  packageURI,Intent.FLAG_GRANT_READ_URI_PERMISSION);

       //①呼叫DCS的getMinimalPackageInfo函式，得到一個PackageLite物件

       pkgLite =mContainerService.getMinimalPackageInfo(packageURI,

                                   flags,lowThreshold);

     }finally ......//撤銷URI授權

    //PacakgeLite的recommendedInstallLocation成員變數儲存該APK推薦的安裝路徑

   int loc =pkgLite.recommendedInstallLocation;

   if (loc== PackageHelper.RECOMMEND_FAILED_INVALID_LOCATION) {

         ret= PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;

   } else if......{

   } else {

       //②根據DCS返回的安裝路徑，還需要呼叫installLocationPolicy進行檢查

       loc =installLocationPolicy(pkgLite, flags);

       if(!onSd && !onInt) {

          if(loc == PackageHelper.RECOMMEND_INSTALL_EXTERNAL) {

              flags |= PackageManager.INSTALL_EXTERNAL;

               flags &=~PackageManager.INSTALL_INTERNAL;

              } ......//處理安裝位置為內部儲存的情況

           }

       }

    }

  //③建立一個安裝引數物件，對於安裝位置為內部儲存的情況，args的真實型別為FileInstallArgs

    finalInstallArgs args = createInstallArgs(this);

    mArgs =args;

    if (ret== PackageManager.INSTALL_SUCCEEDED) {

        final int requiredUid = mRequiredVerifierPackage == null ? -1

                      :getPackageUid(mRequiredVerifierPackage);

        if(requiredUid != -1 && isVerificationEnabled()) {

            ......//④待會再討論verification的處理

         }else {

         //⑤呼叫args的copyApk函式

         ret= args.copyApk(mContainerService, true);

      }

   }

   mRet =ret;//確定返回值

}

public PackageInfoLite getMinimalPackageInfo(finalUri fileUri, int flags,

                                                      longthreshold) {

   //注意該函式的引數：fileUri指向該APK的檔案路徑（此時還在/data/local/tmp下）

  PackageInfoLite ret = new PackageInfoLite();

   ......

   Stringscheme = fileUri.getScheme();

   ......

   StringarchiveFilePath = fileUri.getPath();

  DisplayMetrics metrics = new DisplayMetrics();

  metrics.setToDefaults();

   //呼叫PackageParser的parsePackageLite解析該APK檔案

  PackageParser.PackageLite pkg =

         PackageParser.parsePackageLite(archiveFilePath,0);

   if (pkg== null) {//解析失敗

   ......//設定錯誤值

   returnret;

 }

  ret.packageName = pkg.packageName;

  ret.installLocation = pkg.installLocation;

  ret.verifiers = pkg.verifiers;

   //呼叫recommendAppInstallLocation，取得一個合理的安裝位置

  ret.recommendedInstallLocation =

          recommendAppInstallLocation(pkg.installLocation,archiveFilePath,

                                           flags, threshold);

   returnret;

}

private int recommendAppInstallLocation(intinstallLocation,

                               StringarchiveFilePath, int flags,long threshold) {

 int prefer;

 booleancheckBoth = false;

 check_inner: {

   if((flags & PackageManager.INSTALL_FORWARD_LOCK) != 0) {

        prefer = PREFER_INTERNAL;

        break check_inner; //根據FOWRAD_LOCK的情況，只能安裝在內部儲存

    } elseif ((flags & PackageManager.INSTALL_INTERNAL) != 0) {

        prefer = PREFER_INTERNAL;

        break check_inner;

   }

   ......//檢查各種情況

  } else if(installLocation == PackageInfo.INSTALL_LOCATION_AUTO) {

     prefer= PREFER_INTERNAL;//一般設定的位置為AUTO，預設是內部空間

    checkBoth = true; //設定checkBoth為true

     breakcheck_inner;

 }

  //查詢settings資料庫中的secure表，獲取使用者設定的安裝路徑

  intinstallPreference =

        Settings.System.getInt(getApplicationContext()

            .getContentResolver(),

             Settings.Secure.DEFAULT_INSTALL_LOCATION,

             PackageHelper.APP_INSTALL_AUTO);

   if(installPreference == PackageHelper.APP_INSTALL_INTERNAL) {

       prefer = PREFER_INTERNAL;

       break check_inner;

   } else if(installPreference == PackageHelper.APP_INSTALL_EXTERNAL) {

      prefer= PREFER_EXTERNAL;

      breakcheck_inner;

   }

   prefer =PREFER_INTERNAL;

  }

  //判斷外部儲存空間是否為模擬的，這部分內容我們以後再介紹

  finalboolean emulated = Environment.isExternalStorageEmulated();

  final FileapkFile = new File(archiveFilePath);

  booleanfitsOnInternal = false;

  if(checkBoth || prefer == PREFER_INTERNAL) {

      try {//檢查內部儲存空間是否足夠大

          fitsOnInternal = isUnderInternalThreshold(apkFile, threshold);

      } ......

   }

   booleanfitsOnSd = false;

   if(!emulated && (checkBoth || prefer == PREFER_EXTERNAL)) {

        try{ //檢查外部儲存空間是否足夠大

         fitsOnSd = isUnderExternalThreshold(apkFile);

       } ......

   }

  if (prefer== PREFER_INTERNAL) {

      if(fitsOnInternal) {//返回推薦安裝路徑為內部空間

        return PackageHelper.RECOMMEND_INSTALL_INTERNAL;

         }

    } elseif (!emulated && prefer == PREFER_EXTERNAL) {

      if(fitsOnSd) {//返回推薦安裝路徑為外部空間

         returnPackageHelper.RECOMMEND_INSTALL_EXTERNAL;

     }

 }

 if(checkBoth) {

     if(fitsOnInternal) {//如果內部儲存滿足條件，先返回內部空間

        return PackageHelper.RECOMMEND_INSTALL_INTERNAL;

       }else if (!emulated && fitsOnSd) {

         return PackageHelper.RECOMMEND_INSTALL_EXTERNAL;

      }

  }

     ...... //到此，前幾個條件都不滿足，此處將根據情況返回一個明確的錯誤值

     returnPackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE;

   }

}

int copyApk(IMediaContainerService imcs, booleantemp) throws RemoteException {

   if (temp){

  /*

    本例中temp引數為true，createCopyFile將在/data/app下建立一個臨時檔案。

    臨時檔名為vmdl-隨機數.tmp。為什麼會用這樣的檔名呢？

    因為PKMS通過Linux的inotify機制監控了/data/app,目錄，如果新複製生成的檔名字尾

    為apk，將觸發PKMS掃描。為了防止發生這種情況，這裡複製生成的檔案才有了

    如此奇怪的名字

  */

   createCopyFile();

  }

   FilecodeFile = new File(codeFileName);

   ......

  ParcelFileDescriptor out = null;

   try {

     out =ParcelFileDescriptor.open(codeFile,

                            ParcelFileDescriptor.MODE_READ_WRITE);

           }......

     int ret= PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;

     try {

       mContext.grantUriPermission(DEFAULT_CONTAINER_PACKAGE,

                   packageURI,Intent.FLAG_GRANT_READ_URI_PERMISSION);

        //呼叫DCS的copyResource，該函式將執行復制操作，最終結果是/data/local/tmp

       //下的APK檔案被複制到/data/app下，檔名也被換成vmdl-隨機數.tmp

         ret= imcs.copyResource(packageURI, out);

    }finally {

      ......//關閉out，撤銷URI授權

           }

    returnret;

 }

void handleReturnCode() {

       if(mArgs != null) {

         //呼叫processPendingInstall函式，mArgs指向之前建立的FileInstallArgs物件

        processPendingInstall(mArgs, mRet);

    }

}

private void processPendingInstall(finalInstallArgs args,

                                  final intcurrentStatus) {

   //向mHandler中拋一個Runnable物件

  mHandler.post(new Runnable() {

       publicvoid run() {

        mHandler.removeCallbacks(this);

         //建立一個PackageInstalledInfo物件，

       PackageInstalledInfo res = new PackageInstalledInfo();

       res.returnCode = currentStatus;

       res.uid = -1;

       res.pkg = null;

       res.removedInfo = new PackageRemovedInfo();

        if(res.returnCode == PackageManager.INSTALL_SUCCEEDED) {

           //①呼叫FileInstallArgs的doPreInstall

           args.doPreInstall(res.returnCode);

           synchronized (mInstallLock) {

               //②呼叫installPackageLI進行安裝

               installPackageLI(args, true, res);

            }

          //③呼叫FileInstallArgs的doPostInstall

         args.doPostInstall(res.returnCode);

        }

       final boolean update = res.removedInfo.removedPackage != null;

       boolean doRestore = (!update&& res.pkg != null &&

                    res.pkg.applicationInfo.backupAgentName!= null);

       int token;//計算一個ID號

        if(mNextInstallToken < 0) mNextInstallToken = 1;

            token = mNextInstallToken++;

            //建立一個PostInstallData物件

            PostInstallData data = new PostInstallData(args, res);

           //儲存到mRunningInstalls結構中，以token為key

           mRunningInstalls.put(token, data);

           if (res.returnCode ==PackageManager.INSTALL_SUCCEEDED && doRestore)

             {

                  ......//備份恢復的情況暫時不考慮

            }

           if(!doRestore) {

            //④拋一個POST_INSTALL訊息給mHandler進行處理

            Message msg = mHandler.obtainMessage(POST_INSTALL, token, 0);

            mHandler.sendMessage(msg);

           }

        }

        });

}

提示對於FileInstallArgs來說，其doPreInstall和doPostInstall都比較簡單，讀者可自行閱讀相關程式碼。另外，讀者也可自行研究PKMS的installPackageLI函式。

......//接前面的switch/case

case POST_INSTALL: {

  PostInstallData data = mRunningInstalls.get(msg.arg1);

 mRunningInstalls.delete(msg.arg1);

  booleandeleteOld = false;

  if (data!= null) {

      InstallArgs args = data.args;

      PackageInstalledInfo res = data.res;

       if(res.returnCode == PackageManager.INSTALL_SUCCEEDED) {

           res.removedInfo.sendBroadcast(false, true);

           Bundle extras = new Bundle(1);

           extras.putInt(Intent.EXTRA_UID, res.uid);

           final boolean update = res.removedInfo.removedPackage != null;

           if (update) {

                extras.putBoolean(Intent.EXTRA_REPLACING, true);

           }

           //傳送PACKAGE_ADDED廣播

           sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED,

                    res.pkg.applicationInfo.packageName,extras, null, null);

           if (update) {

           /*

           如果是APK升級，那麼傳送PACKAGE_REPLACE和MY_PACKAGE_REPLACED廣播。

          二者不同之處在於PACKAGE_REPLACE將攜帶一個extra資訊

         */

       }

      Runtime.getRuntime().gc();

       if(deleteOld) {

         synchronized (mInstallLock) {

           //呼叫FileInstallArgs的doPostDeleteLI進行資源清理

           res.removedInfo.args.doPostDeleteLI(true);

            }

        }

      if(args.observer != null) {

      try {

          // 向pm通知安裝的結果

        args.observer.packageInstalled(res.name, res.returnCode);

      } ......

} break;

  ......//此處已經獲得了合適的安裝位置

  finalInstallArgs args = createInstallArgs(this);

  mArgs =args;

if (ret == PackageManager.INSTALL_SUCCEEDED) {

    final int requiredUid =mRequiredVerifierPackage == null ? -1

                        :getPackageUid(mRequiredVerifierPackage);

  if (requiredUid != -1 &&isVerificationEnabled()) {

     //建立一個Intent，用於查詢滿足條件的廣播接收者

   finalIntent verification = new

                    Intent(Intent.ACTION_PACKAGE_NEEDS_VERIFICATION);

   verification.setDataAndType(packageURI, PACKAGE_MIME_TYPE);

   verification.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);

    //查詢滿足Intent條件的廣播接收者

    finalList<ResolveInfo> receivers = queryIntentReceivers(

               verification,null,PackageManager.GET_DISABLED_COMPONENTS);

    // verificationId為當前等待Verification的安裝包個數

    finalint verificationId = mPendingVerificationToken++;

   //設定Intent的引數，例如要校驗的包名

    verification.putExtra(PackageManager.EXTRA_VERIFICATION_ID,

                              VerificationId);

    verification.putExtra(

                            PackageManager.EXTRA_VERIFICATION_INSTALLER_PACKAGE,

                            installerPackageName);

  verification.putExtra(

                   PackageManager.EXTRA_VERIFICATION_INSTALL_FLAGS,flags);

   if(verificationURI != null) {

     verification.putExtra(PackageManager.EXTRA_VERIFICATION_URI,

                                verificationURI);

    }

  finalPackageVerificationState verificationState = new

                       PackageVerificationState(requiredUid,args);

  //將上面建立的PackageVerificationState儲存到mPendingVerification中

 mPendingVerification.append(verificationId, verificationState);

  //篩選符合條件的廣播接收者

  finalList<ComponentName> sufficientVerifiers =

                   matchVerifiers(pkgLite,receivers,verificationState);

  if (sufficientVerifiers != null) {

      finalint N = sufficientVerifiers.size();

      ......

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

       finalComponentName verifierComponent = sufficientVerifiers.get(i);

       final Intent sufficientIntent = newIntent(verification);

       sufficientIntent.setComponent(verifierComponent);

       //向校驗包傳送廣播

       mContext.sendBroadcast(sufficientIntent);

       }

    }

 }

   //除此之外，如果在執行adb install的時候指定了校驗包，則需要向其單獨傳送校驗廣播

   finalComponentName requiredVerifierComponent =

                        matchComponentForVerifier(mRequiredVerifierPackage,

                       receivers);

   if (ret == PackageManager.INSTALL_SUCCEEDED

        &&mRequiredVerifierPackage != null) {

      verification.setComponent(requiredVerifierComponent);

      mContext.sendOrderedBroadcast(verification,

      android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,

           new BroadcastReceiver() {

           //呼叫sendOrderdBroadcast，並傳遞一個BroadcastReceiver，該物件將在

          //廣播傳送的最後被呼叫。讀者可參考sendOrderdBroadcast的文件說明

           public void onReceive(Context context, Intent intent) {

            final Message msg =mHandler.obtainMessage(

                      CHECK_PENDING_VERIFICATION);

            msg.arg1 = verificationId;

            //設定一個超時執行時間，該值來自Settings資料庫的secure表，預設為60秒

            mHandler.sendMessageDelayed(msg, getVerificationTimeout());

           }

         },null, 0, null, null);

           mArgs = null;

        }

    }......//不用做Verification的流程

提示關於具體的匹配流程，請讀者務必閱讀SDK docs/guide/topics/intents/intents-filters.html中的說明。

     ......//此時APK檔案已經解析完成

     N =pkg.activities.size();//取出該APK中包含的Activities資訊

     r =null;

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

        PackageParser.Activity a = pkg.activities.get(i);

        a.info.processName = fixProcessName(pkg.applicationInfo.processName,

                                     a.info.processName,pkg.applicationInfo.uid);

         mActivities.addActivity(a,"activity");//①加到mActivities中儲存

 }

public final voidaddActivity(PackageParser.Activity a, String type) {

     finalboolean systemApp = isSystemApp(a.info.applicationInfo);

     //將Component和Activity儲存到mActivities中

    mActivities.put(a.getComponentName(), a);

     finalint NI = a.intents.size();

     for(int j=0; j<NI; j++) {

     //ActivityIntentInfo儲存的就是XML中宣告的IntentFilter資訊

    PackageParser.ActivityIntentInfo intent = a.intents.get(j);

     if(!systemApp && intent.getPriority() > 0 &&"activity".equals(type)) {

          //非系統APK的priority必須為0。後續分析中將介紹priority的作用

          intent.setPriority(0);

        }

         addFilter(intent);//接下來將分析這個函式

      }

 }

public void addFilter(F f) {

        ......

       mFilters.add(f);//mFilters儲存所有IntentFilter資訊

       //除此之外，為了加快匹配工作的速度，還需要分類儲存IntentFilter資訊

       //下邊register_xxx函式的最後一個引數用於列印資訊

        intnumS = register_intent_filter(f, f.schemesIterator(),

                         mSchemeToFilter,"      Scheme: ");

        intnumT = register_mime_types(f, "     Type: ");

        if(numS == 0 && numT == 0) {

           register_intent_filter(f, f.actionsIterator(),

                           mActionToFilter,"      Action: ");

        }

        if(numT != 0) {

           register_intent_filter(f, f.actionsIterator(),

                   mTypedActionToFilter, "     TypedAction: ");

        }

 }

<intent-filter android:label="test">

   <actionandroid:name="android.intent.action.VIEW" />

   dataandroid:mimeType="audio/*" android:scheme="http"

 </intent-filter>

public List<ResolveInfo>queryIntentActivities(Intent intent, int flags) {

   try {

           return mPM.queryIntentActivities(

               intent,//下面這句話很重要

               intent.resolveTypeIfNeeded(mContext.getContentResolver()),

               flags);

        }......

}

public List<ResolveInfo>queryIntentActivities(Intent intent,

                                  String resolvedType, int flags) {

       final ComponentName comp = intent.getComponent();

        if(comp != null) {

            //Explicit的Intents，直接根據component得到對應的ActivityInfo

           final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);

           final ActivityInfo ai = getActivityInfo(comp, flags);

           if (ai != null) {

               final ResolveInfo ri = new ResolveInfo();

               //ResovlerInfo的activityInfo指向查詢得到的ActivityInfo

               ri.activityInfo = ai;

               list.add(ri);

           }

           return list;

        }

       synchronized (mPackages) {

           final String pkgName = intent.getPackage();

           if (pkgName == null) {

                        //Implicit Intents，我們重點分析此中情況

               return mActivities.queryIntent(intent, resolvedType, flags);

           }

            //Intent指明瞭PackageName，比Explicit Intents情況差一點

           final PackageParser.Package pkg = mPackages.get(pkgName);

           if (pkg != null) {

               //其實是從該Package包含的Activities中進行匹配查詢

               return mActivities.queryIntentForPackage(intent, resolvedType,

                                           flags, pkg.activities);

           }

           return new ArrayList<ResolveInfo>();

        }

    }

public List<ResolveInfo> queryIntent(Intentintent, String resolvedType,

                                            intflags) {

    mFlags =flags;

   //呼叫基類的queryIntent函式

   returnsuper.queryIntent(intent, resolvedType,

               (flags&PackageManager.MATCH_DEFAULT_ONLY) != 0);

 }

public List<R> queryIntent(Intent intent,String resolvedType,

                             booleandefaultOnly) {

  Stringscheme = intent.getScheme();

 ArrayList<R> finalList = new ArrayList<R>();

 //最多有四輪匹配工作要做

 ArrayList<F> firstTypeCut = null;

 ArrayList<F> secondTypeCut = null;

 ArrayList<F> thirdTypeCut = null;

 ArrayList<F> schemeCut = null;

 //下面將設定各輪校驗者

 if(resolvedType != null) {

     intslashpos = resolvedType.indexOf('/');

      if(slashpos > 0) {

         final String baseType = resolvedType.substring(0, slashpos);

          if (!baseType.equals("*")) {

               if (resolvedType.length() != slashpos+2

                   || resolvedType.charAt(slashpos+1) != '*') {

                       firstTypeCut =mTypeToFilter.get(resolvedType);

                       secondTypeCut =mWildTypeToFilter.get(baseType);

                   }......//略去一部分內容

           }

        }

      if(scheme != null) {

           schemeCut = mSchemeToFilter.get(scheme);

        }

      if(resolvedType == null && scheme == null && intent.getAction()!= null)

      {

        //看來action的filter優先順序最低

       firstTypeCut = mActionToFilter.get(intent.getAction());

      }

   //FastImmutableArraySet是一種特殊的資料結構，用於儲存該Intent中攜帶的

   //Category相關的資訊。

   FastImmutableArraySet<String>categories = getFastIntentCategories(intent);

    if(firstTypeCut != null) {

     //匹配查詢，第一輪過關斬將

     buildResolveList(intent, categories, debug, defaultOnly,

             resolvedType, scheme, firstTypeCut,finalList);

    }

    if(secondTypeCut != null) {

        buildResolveList(intent, categories, debug, defaultOnly,

                   resolvedType, scheme, secondTypeCut, finalList);

     }

    if(thirdTypeCut != null) {

        buildResolveList(intent, categories, debug, defaultOnly,

                   resolvedType, scheme, thirdTypeCut, finalList);

     }

    if(schemeCut != null) {

        //生成符合schemeCut條件的finalList

        buildResolveList(intent, categories, debug, defaultOnly,

                   resolvedType, scheme, schemeCut, finalList);

    }

   //將匹配結果按Priority的大小排序

   sortResults(finalList);

    returnfinalList;

}

mInstaller = new Installer();//建立一個Installer物件

//對某個APK檔案進行dexopt優化

mInstaller.dexopt(paths[i], Process.SYSTEM_UID,true);

//掃描完系統Package後，呼叫moveFiles函式

mInstaller.moveFiles();

//當儲存空間不足時，呼叫該函式清理儲存空間

mInstaller.freeCache(freeStorageSize);

int main(const int argc, const char *argv[]) {

    charbuf[BUFFER_MAX];

    structsockaddr addr;

   socklen_t alen;

    intlsocket, s, count;

    //

  if (初始化全域性變數,如果失敗則退出) {

    initialize_globals();

    initialize_directories();

        ......

    }

    ......

    lsocket= android_get_control_socket(SOCKET_PATH);

   listen(lsocket, 5);

   fcntl(lsocket, F_SETFD, FD_CLOEXEC);

    for (;;){

        alen= sizeof(addr);

        s =accept(lsocket, &addr, &alen);

       fcntl(s, F_SETFD, FD_CLOEXEC);

        for(;;) {

           unsigned short count;

           readx(s, &count, sizeof(count));

           //執行installer發出的命令，具體解釋見下文

            execute(s, buf);

        }

       close(s);

    }

    return0;

}

struct cmdinfo cmds[] = {//第二個變數是引數個數，第三個引數是命令響應函式

    {"ping",                 0,do_ping },

    {"install",              3,do_install },

    {"dexopt",               3,do_dexopt },

    {"movedex",              2,do_move_dex },

    {"rmdex",                1,do_rm_dex },

    {"remove",               2,do_remove },

    {"rename",               2, do_rename },

    {"freecache",            1,do_free_cache },

    {"rmcache",              1,do_rm_cache },

    {"protect",              2,do_protect },

    {"getsize",              4,do_get_size },

    {"rmuserdata",           2,do_rm_user_data },

    {"movefiles",            0,do_movefiles },

    {"linklib",              2,do_linklib },

    {"unlinklib",            1,do_unlinklib },

    {"mkuserdata",           3,do_mk_user_data },

    {"rmuser",               1,do_rm_user },

};

static int do_dexopt(char **arg, charreply[REPLY_MAX])

{

     returndexopt(arg[0], atoi(arg[1]), atoi(arg[2]));

}

int dexopt(const char *apk_path, uid_t uid, intis_public)

{

    structutimbuf ut;

    structstat apk_stat, dex_stat;

    chardex_path[PKG_PATH_MAX];

    chardexopt_flags[PROPERTY_VALUE_MAX];

    char*end;

    int res,zip_fd=-1, odex_fd=-1;

    ......

    //取出系統級的dexopt_flags引數

   property_get("dalvik.vm.dexopt-flags", dexopt_flags,"");

   strcpy(dex_path, apk_path);

    end =strrchr(dex_path, '.');

    if (end!= NULL) {

       strcpy(end, ".odex");

        if(stat(dex_path, &dex_stat) == 0) {

           return 0;

        }

    }

    //得到一個字串，用於描述dex檔名，位於/data/dalvik-cache/下

    if(create_cache_path(dex_path, apk_path)) {

       return -1;

    }

   memset(&apk_stat, 0, sizeof(apk_stat));

   stat(apk_path, &apk_stat);

    zip_fd =open(apk_path, O_RDONLY, 0);

    ......

   unlink(dex_path);

    odex_fd= open(dex_path, O_RDWR | O_CREAT | O_EXCL, 0644);

    ......

    pid_tpid;

    pid =fork();

    if (pid== 0) {

        ......//uid設定

        //建立一個新程式，然後對exec dexopt程式進行dex優化

        run_dexopt(zip_fd,odex_fd, apk_path, dexopt_flags);

       exit(67);  

} else {

        //installd將等待dexopt完成優化工作

        res= wait_dexopt(pid, apk_path);

        ......

    }

    ......//資源清理

    return-1;

}

提示 dexopt程式由android原始碼/dalvik/dexopt/OptMain.cpp定義。感興趣的讀者可深入研究dex優化的工作原理。

static int do_movefiles(char **arg, charreply[REPLY_MAX])

{

    returnmovefiles();

}

int movefiles()

{

    DIR *d;

    int dfd,subfd;

    structdirent *de;

    structstat s;

    charbuf[PKG_PATH_MAX+1];

    intbufp, bufe, bufi, readlen;

    charsrcpkg[PKG_NAME_MAX];

    chardstpkg[PKG_NAME_MAX];

    charsrcpath[PKG_PATH_MAX];

    chardstpath[PKG_PATH_MAX];

    intdstuid=-1, dstgid=-1;

    inthasspace;

    //開啟/system/etc/updatecmds/目錄

    d =opendir(UPDATE_COMMANDS_DIR_PREFIX);

    if (d ==NULL) {

        gotodone;

    }

    dfd =dirfd(d);

       while((de = readdir(d))) {

        ......//解析該目錄下的檔案，然後執行對應操作

   }

   closedir(d);

done:

    return0;

}

static int do_free_cache(char **arg, charreply[REPLY_MAX])

{

    returnfree_cache((int64_t)atoll(arg[0]));

}

int free_cache(int64_t free_size)

{

    constchar *name;

    int dfd,subfd;

    DIR *d;

    structdirent *de;

    int64_tavail;

    avail =disk_free();//獲取當前系統的剩餘空間大小

    if(avail < 0) return -1;

    if(avail >= free_size) return 0;

    d =opendir(android_data_dir.path);//開啟/data/目錄

    dfd =dirfd(d);

    while((de = readdir(d))) {

        if (de->d_type != DT_DIR) continue;

        name= de->d_name;

       ......//略過.和..檔案

       subfd = openat(dfd, name, O_RDONLY | O_DIRECTORY);

        //刪除/data及各級子目錄中的cache資料夾

       delete_dir_contents_fd(subfd, "cache");

       close(subfd);

       ......//如果剩餘空間恢復正常，則返回

    }

   closedir(d);

    return-1;//清理空間後，仍然不滿足要求

}

提示 小米手機的訪客模式和UserManager比較相似。

//mUserAppDataDir指向/data/app。該目錄中包含的是非系統APK檔案

mUserManager = new UserManager(mInstaller,mUserAppDataDir);

public UserManager(Installer installer, FilebaseUserPath) {

   this(Environment.getDataDirectory(), baseUserPath);

   mInstaller = installer;

}

UserManager(File dataDir, File baseUserPath) {

   //mUsersDir指向/data/system/users目錄

   mUsersDir = new File(dataDir, USER_INFO_DIR);

   mUsersDir.mkdirs();//建立該目錄

   mBaseUserPath = baseUserPath;

   FileUtils.setPermissions(mUsersDir.toString(),

            FileUtils.S_IRWXU|FileUtils.S_IRWXG

           |FileUtils.S_IROTH|FileUtils.S_IXOTH,

               -1, -1);

   //mUserListFile指向/data/system/user/userlist.xml

   mUserListFile = new File(mUsersDir, USER_LIST_FILENAME);

   readUserList();//解析userlist.xml檔案

}

public class UserInfo implements Parcelable {

   //主使用者，全系統只能有一個這樣的使用者

    publicstatic final int FLAG_PRIMARY = 0x00000001;

    //管理員，可以建立、刪除其他使用者資訊

    publicstatic final int FLAG_ADMIN   =0x00000002;

    //訪客使用者

    publicstatic final int FLAG_GUEST   =0x00000004;

    publicint id; //id

    publicString name;//使用者名稱

    publicint flags; //屬性標誌

    ......//其他函式

}

mUserManager.installPackageForAllUsers(pkgName,pkg.applicationInfo.uid);

public void installPackageForAllUsers(StringpackageName, int uid) {

 for (intuserId : mUserIds) {

   if(userId == 0)

      continue;

  //向installd傳送命令，其中getUid將組合userId和uid為一個整型值

  //installd將在/data/對應user/目錄下建立相應的package子目錄

  mInstaller.createUserData(packageName, PackageManager.getUid(userId,uid),

                                  userId);

        }

 }