APK的安裝過程分析

時間  2021-01-19
欄目 Android 简体版
原文   原文鏈接

Package管理服務PackageManagerService在安裝一個應用程序的過程中，會對這個應用程序的配置文件AndroidManifest.xml進行解析，以便可以獲得它的安裝信息。

Android系統中每一個應用程序都有一個Linux用戶ID，一個應用程序除了擁有一個linux用戶ID之外，還可以擁有若干個Linux用戶組ID，以便可以在系統中獲得更多的資源訪問權限，如讀取聯繫人信息、使用攝像頭等權限。

PMS在安裝一個應用程序時，如果發現它沒有與其他應用程序共享同一個Linux用戶ID，那麼就會爲它分配一個唯一的Linux用戶ID，以便它可以在系統中獲得合適的運行權限。如果發現它申請了一個特定的資源訪問權限，那麼就會爲它分配一個相應的Linux用戶組ID。

分析應用程序的安裝過程，主要是關注它的組件信息的解析過程，以及Linux用戶ID和Linux用戶組ID的分配過程。

System進程在啓動時，會調用PMS類的靜態成員函數main方法將系統的PMS啓動起來。由於PMS在啓動過程中會對系統中的應用程序進行安裝，因此，接下來就從PMS類的main方法開始分析應用程序的安裝過程：

[java]  view plain  copy
  1. public static PackageManagerService main(Context context, Installer installer,  
  2.         boolean factoryTest, boolean onlyCore) {  
  3.     // 實例化PMS  
  4.     PackageManagerService m = new PackageManagerService(context, installer,  
  5.             factoryTest, onlyCore);  
  6.     // 把PMS添加到ServiceManager中  
  7.     ServiceManager.addService("package", m);  
  8.     return m;  
  9. }  


PMS的構造方法完成的主要功能是，掃描android系統中幾個目標文件夾中的apk文件，從而建立合適的數據結構以管理諸如Package信息、四大組件信息、權限信息等各種信息。PMS的工作流程相對簡單，複雜的是其中用於保存各種信息的數據結構和它們之間的關係，以及影響最終結果的策略控制。

由於代碼量較大，採用分段的方法進行分析。

1.掃描目標文件夾之前的準備工作

先看下時序圖：

[java]  view plain  copy
  1. final int mSdkVersion = Build.VERSION.SDK_INT;  
  2. final Context mContext;  
  3. final boolean mFactoryTest;  
  4. final boolean mOnlyCore;  
  5. final boolean mLazyDexOpt;  
  6. final DisplayMetrics mMetrics;  
  7. final Settings mSettings;  
  8. // Keys are String (package name), values are Package.  This also serves  
  9. // as the lock for the global state.  Methods that must be called with  
  10. // this lock held have the prefix "LP".  
  11. @GuardedBy("mPackages")  
  12. final ArrayMap<String, PackageParser.Package> mPackages =  
  13.         new ArrayMap<String, PackageParser.Package>();  
  14. private static final int RADIO_UID = Process.PHONE_UID;  
  15. private static final int LOG_UID = Process.LOG_UID;  
  16. private static final int NFC_UID = Process.NFC_UID;  
  17. private static final int BLUETOOTH_UID = Process.BLUETOOTH_UID;  
  18. private static final int SHELL_UID = Process.SHELL_UID;  
  19.   
  20. public PackageManagerService(Context context, Installer installer,  
  21.         boolean factoryTest, boolean onlyCore) {  
  22.   
  23.     // 編譯的SDK版本，若沒有定義則APK就無法知道自己運行在Android的哪個版本上  
  24.     if (mSdkVersion <= 0) {  
  25.         Slog.w(TAG, "**** ro.build.version.sdk not set!");  
  26.     }  
  27.   
  28.     mContext = context;  
  29.     // 是否運行在工廠模式下  
  30.     mFactoryTest = factoryTest;  
  31.     // 用於判斷是否只掃描系統目錄  
  32.     mOnlyCore = onlyCore;  
  33.     // 如果此係統是eng版本，則掃描Package後，不對其做dex優化  
  34.     mLazyDexOpt = "eng".equals(SystemProperties.get("ro.build.type"));  
  35.     // 用於存儲與顯示屏相關的一些屬性，如屏幕的寬高、分辨率等信息  
  36.     mMetrics = new DisplayMetrics();  
  37.     // Settings是用來管理應用程序的安裝信息的  
  38.     mSettings = new Settings(mPackages);  
  39.     // 添加共享用戶  
  40.     mSettings.addSharedUserLPw("android.uid.system", Process.SYSTEM_UID,  
  41.             ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);  
  42.     mSettings.addSharedUserLPw("android.uid.phone", RADIO_UID,  
  43.             ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);  
  44.     mSettings.addSharedUserLPw("android.uid.log", LOG_UID,  
  45.             ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);  
  46.     mSettings.addSharedUserLPw("android.uid.nfc", NFC_UID,  
  47.             ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);  
  48.     mSettings.addSharedUserLPw("android.uid.bluetooth", BLUETOOTH_UID,  
  49.             ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);  
  50.     mSettings.addSharedUserLPw("android.uid.shell", SHELL_UID,  
  51.             ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);  
  52.     . . .  
  53. }  


剛進入構造函數就會遇到第一個較爲複雜的數據結構Settings以及它的addSharedUserLPw方法。先看Settings類的構造方法，主要是創建相關的文件夾並設置文件夾的讀寫權限：

[java]  view plain  copy
  1. Settings(Object lock) {  
  2.     // Environment.getDataDirectory()獲取到的是/data目錄  
  3.     this(Environment.getDataDirectory(), lock);  
  4. }  
  5.   
  6. private final Object mLock;  
  7. private final RuntimePermissionPersistence mRuntimePermissionsPersistence;  
  8. private final File mSystemDir;  
  9. private final File mSettingsFilename;  
  10. private final File mBackupSettingsFilename;  
  11. private final File mPackageListFilename;  
  12. private final File mStoppedPackagesFilename;  
  13. private final File mBackupStoppedPackagesFilename;  
  14.   
  15. Settings(File dataDir, Object lock) {  
  16.     mLock = lock;  
  17.   
  18.     mRuntimePermissionsPersistence = new RuntimePermissionPersistence(mLock);  
  19.   
  20.     mSystemDir = new File(dataDir, "system");  
  21.     // 創建/data/system文件夾  
  22.     mSystemDir.mkdirs();  
  23.     // 設置/data/system文件夾的讀寫權限  
  24.     FileUtils.setPermissions(mSystemDir.toString(),  
  25.             FileUtils.S_IRWXU|FileUtils.S_IRWXG  
  26.             |FileUtils.S_IROTH|FileUtils.S_IXOTH,  
  27.             -1, -1);  
  28.     mSettingsFilename = new File(mSystemDir, "packages.xml");  
  29.     mBackupSettingsFilename = new File(mSystemDir, "packages-backup.xml");  
  30.     mPackageListFilename = new File(mSystemDir, "packages.list");  
  31.     FileUtils.setPermissions(mPackageListFilename, 0640, SYSTEM_UID, PACKAGE_INFO_GID);  
  32.   
  33.     // Deprecated: Needed for migration  
  34.     mStoppedPackagesFilename = new File(mSystemDir, "packages-stopped.xml");  
  35.     mBackupStoppedPackagesFilename = new File(mSystemDir, "packages-stopped-backup.xml");  
  36. }  


Settings的構造方法會在data目錄下創建system目錄，用來保存多個系統文件。主要有：

packages.xml：記錄系統中所有安裝的應用信息，包括基本信息、簽名和權限。

packages-backup.xml：packages.xml文件的備份。寫文件之前會先備份，寫成功後再刪除掉備份文件，如果寫的時候出現問題，則重啓後再讀取這兩個文件時，如果發現備份文件存在，就會使用備份文件的內容，因爲原文件可能已經損壞了。

packages.list：保存普通應用的數據目錄和uid等信息。

packages-stopped.xml：記錄系統中被強制停止運行的應用信息。系統在強制停止某個應用時，會將應用的信息記錄在該文件中。

packages-stopped-backup.xml：packages-stopped.xml文件的備份文件。

[java]  view plain  copy
  1. final ArrayMap<String, SharedUserSetting> mSharedUsers = new ArrayMap<String, SharedUserSetting>();  
  2.   
  3. // 添加共享用戶  
  4. SharedUserSetting addSharedUserLPw(String name, int uid, int pkgFlags, int pkgPrivateFlags) {  
  5.     // 根據key從map中獲取值  
  6.     SharedUserSetting s = mSharedUsers.get(name);  
  7.     // 如果值不爲null並且保存的uid和傳遞過來的一致，就直接返回結果。uid不一致則返回null  
  8.     if (s != null) {  
  9.         if (s.userId == uid) {  
  10.             return s;  
  11.         }  
  12.         PackageManagerService.reportSettingsProblem(Log.ERROR,  
  13.                 "Adding duplicate shared user, keeping first: " + name);  
  14.         return null;  
  15.     }  
  16.     // 若s爲null，則根據傳遞過來的參數新創建對象  
  17.     s = new SharedUserSetting(name, pkgFlags, pkgPrivateFlags);  
  18.     s.userId = uid;  
  19.     // 在系統中保存值爲uid的Linux用戶ID，成功返回true  
  20.     if (addUserIdLPw(uid, s, name)) {  
  21.         // 保存到map中  
  22.         mSharedUsers.put(name, s);  
  23.         return s;  
  24.     }  
  25.     return null;  
  26. }  
  27.   
  28. private final ArrayList<Object> mUserIds = new ArrayList<Object>();  
  29. private final SparseArray<Object> mOtherUserIds = new SparseArray<Object>();  
  30.   
  31. private boolean addUserIdLPw(int uid, Object obj, Object name) {  
  32.     // LAST_APPLICATION_UID = 19999  
  33.     if (uid > Process.LAST_APPLICATION_UID) {  
  34.         return false;  
  35.     }  
  36.   
  37.     // FIRST_APPLICATION_UID = 10000  
  38.     if (uid >= Process.FIRST_APPLICATION_UID) {  
  39.         // 獲取數組的長度  
  40.         int N = mUserIds.size();  
  41.         // 計算目標索引值  
  42.         final int index = uid - Process.FIRST_APPLICATION_UID;  
  43.         // 如果目標索引值大於數組長度，則在數組索引值之前的位置都添加null的元素  
  44.         while (index >= N) {  
  45.             mUserIds.add(null);  
  46.             N++;  
  47.         }  
  48.         // 如果數組的目標索引值位置有不爲null的值，說明已經添加過  
  49.         if (mUserIds.get(index) != null) {  
  50.             PackageManagerService.reportSettingsProblem(Log.ERROR,  
  51.                     "Adding duplicate user id: " + uid  
  52.                     + " name=" + name);  
  53.             return false;  
  54.         }  
  55.         // 把值放在數組的目標索引位置  
  56.         mUserIds.set(index, obj);  
  57.     } else {  
  58.         // 如果uid < 10000,則把對應的值保存在mOtherUserIds變量中  
  59.         if (mOtherUserIds.get(uid) != null) {  
  60.             PackageManagerService.reportSettingsProblem(Log.ERROR,  
  61.                     "Adding duplicate shared id: " + uid  
  62.                             + " name=" + name);  
  63.             return false;  
  64.         }  
  65.         mOtherUserIds.put(uid, obj);  
  66.     }  
  67.     return true;  
  68. }  


至此，對Settings的分析就告一段落了。下面繼續分析PMS的構造方法：

[java]  view plain  copy
  1. private static final long WATCHDOG_TIMEOUT = 1000*60*10;   
  2.   
  3. public PackageManagerService(Context context, Installer installer,  
  4.         boolean factoryTest, boolean onlyCore) {  
  5.   
  6.     . . .  
  7.   
  8.     // 應用安裝器  
  9.     mInstaller = installer;  
  10.     // 實例化類優化器  
  11.     mPackageDexOptimizer = new PackageDexOptimizer(this);  
  12.     mMoveCallbacks = new MoveCallbacks(FgThread.get().getLooper());  
  13.   
  14.     mOnPermissionChangeListeners = new OnPermissionChangeListeners(  
  15.             FgThread.get().getLooper());  
  16.   
  17.     // 獲取當前顯示屏信息  
  18.     getDefaultDisplayMetrics(context, mMetrics);  
  19.   
  20.     // 獲取系統的初始化變量  
  21.     SystemConfig systemConfig = SystemConfig.getInstance();  
  22.     mGlobalGids = systemConfig.getGlobalGids();  
  23.     mSystemPermissions = systemConfig.getSystemPermissions();  
  24.     mAvailableFeatures = systemConfig.getAvailableFeatures();  
  25.   
  26.     // 創建一個HandlerThread子類的實例，主要處理應用的安裝和卸載  
  27.     mHandlerThread = new ServiceThread(TAG,  
  28.             Process.THREAD_PRIORITY_BACKGROUND, true /*allowIo*/);  
  29.     mHandlerThread.start();  
  30.     // 以mHandlerThread線程的looper創建的Handler實例，該Handler運行在mHandlerThread線程  
  31.     mHandler = new PackageHandler(mHandlerThread.getLooper());  
  32.     // 把mHandler加入到watchdog中  
  33.     Watchdog.getInstance().addThread(mHandler, WATCHDOG_TIMEOUT);  
  34.   
  35.     // /data目錄  
  36.     File dataDir = Environment.getDataDirectory();  
  37.     // /data/data目錄  
  38.     mAppDataDir = new File(dataDir, "data");  
  39.     // /data/app目錄，保存的是用戶自己安裝的app  
  40.     mAppInstallDir = new File(dataDir, "app");  
  41.     mAppLib32InstallDir = new File(dataDir, "app-lib");  
  42.     mAsecInternalPath = new File(dataDir, "app-asec").getPath();  
  43.     mUserAppDataDir = new File(dataDir, "user");  
  44.     // /data/app-parivate目錄，保存的是受DRM保護的私有app  
  45.     mDrmAppPrivateInstallDir = new File(dataDir, "app-private");  
  46.     mRegionalizationAppInstallDir = new File(dataDir, "app-regional");  
  47.   
  48.     // 實例化用戶管理服務，多用戶時使用  
  49.     sUserManager = new UserManagerService(context, this,  
  50.             mInstallLock, mPackages);  
  51.   
  52.     // 通過systemConfig獲取系統中定義的權限，這些權限保存在/system/etc/permissions目錄下的文件中  
  53.     ArrayMap<String, SystemConfig.PermissionEntry> permConfig  
  54.             = systemConfig.getPermissions();  
  55.     for (int i=0; i<permConfig.size(); i++) {  
  56.         SystemConfig.PermissionEntry perm = permConfig.valueAt(i);  
  57.         // 根據權限名獲取基本權限信息  
  58.         BasePermission bp = mSettings.mPermissions.get(perm.name);  
  59.         if (bp == null) {  
  60.             bp = new BasePermission(perm.name, "android", BasePermission.TYPE_BUILTIN);  
  61.             // 如果基本權限信息爲null，則根據權限名創建它並保存到mSettings.mPermissions中  
  62.             mSettings.mPermissions.put(perm.name, bp);  
  63.         }  
  64.         if (perm.gids != null) {  
  65.             bp.setGids(perm.gids, perm.perUser);  
  66.         }  
  67.     }  
  68.   
  69.     // 通過systemConfig獲取系統的共享庫列表，並保存在mSharedLibraries中  
  70.     ArrayMap<String, String> libConfig = systemConfig.getSharedLibraries();  
  71.     for (int i=0; i<libConfig.size(); i++) {  
  72.         mSharedLibraries.put(libConfig.keyAt(i),  
  73.                 new SharedLibraryEntry(libConfig.valueAt(i), null));  
  74.     }  
  75.   
  76.     // 解析SELinux的策略文件  
  77.     mFoundPolicyFile = SELinuxMMAC.readInstallPolicy();  
  78.   
  79.     // 恢復上一次的應用程序安裝信息，掃描package.xml文件  
  80.     mRestoredSettings = mSettings.readLPw(this, sUserManager.getUsers(false),  
  81.             mSdkVersion, mOnlyCore);  
  82.   
  83.     // 這裏獲取的customResolverActivity爲空字符串  
  84.     String customResolverActivity = Resources.getSystem().getString(  
  85.             R.string.config_customResolverActivity);  
  86.     if (TextUtils.isEmpty(customResolverActivity)) {  
  87.         customResolverActivity = null;  
  88.     } else {  
  89.         mCustomResolverComponentName = ComponentName.unflattenFromString(  
  90.                 customResolverActivity);  
  91.     }  
  92.     . . .  
  93.   
  94. }  


下面分析下SystemConfig類的方法：

[java]  view plain  copy
  1. static SystemConfig sInstance;  
  2.   
  3. public static SystemConfig getInstance() {  
  4.     synchronized (SystemConfig.class) {  
  5.         if (sInstance == null) {  
  6.             sInstance = new SystemConfig();  
  7.         }  
  8.         return sInstance;  
  9.     }  
  10. }  
  11.   
  12. SystemConfig() {  
  13.     // Read configuration from system  
  14.     // Environment.getRootDirectory()獲取到的是/system目錄  
  15.     readPermissions(Environment.buildPath(  
  16.             Environment.getRootDirectory(), "etc", "sysconfig"), false);  
  17.     // Read configuration from the old permissions dir  
  18.     readPermissions(Environment.buildPath(  
  19.             Environment.getRootDirectory(), "etc", "permissions"), false);  
  20.     // Only read features from OEM config  
  21.     readPermissions(Environment.buildPath(  
  22.             Environment.getOemDirectory(), "etc", "sysconfig"), true);  
  23.     readPermissions(Environment.buildPath(  
  24.             Environment.getOemDirectory(), "etc", "permissions"), true);  
  25. }  
  26.   
  27. void readPermissions(File libraryDir, boolean onlyFeatures) {  
  28.     // Read permissions from given directory.  
  29.     if (!libraryDir.exists() || !libraryDir.isDirectory()) {  
  30.         if (!onlyFeatures) {  
  31.             Slog.w(TAG, "No directory " + libraryDir + ", skipping");  
  32.         }  
  33.         return;  
  34.     }  
  35.     if (!libraryDir.canRead()) {  
  36.         Slog.w(TAG, "Directory " + libraryDir + " cannot be read");  
  37.         return;  
  38.     }  
  39.   
  40.     // 遍歷目標文件夾下所有的.xml文件  
  41.     File platformFile = null;  
  42.     for (File f : libraryDir.listFiles()) {  
  43.         // 最後解析platform.xml文件  
  44.         if (f.getPath().endsWith("etc/permissions/platform.xml")) {  
  45.             platformFile = f;  
  46.             continue;  
  47.         }  
  48.   
  49.         if (!f.getPath().endsWith(".xml")) {  
  50.             Slog.i(TAG, "Non-xml file " + f + " in " + libraryDir + " directory, ignoring");  
  51.             continue;  
  52.         }  
  53.         if (!f.canRead()) {  
  54.             Slog.w(TAG, "Permissions library file " + f + " cannot be read");  
  55.             continue;  
  56.         }  
  57.   
  58.         // 解析xml文件，保存到相應的變量中  
  59.         readPermissionsFromXml(f, onlyFeatures);  
  60.     }  
  61.   
  62.     // 最後解析platform.xml文件，該文件的優先級最高  
  63.     if (platformFile != null) {  
  64.         readPermissionsFromXml(platformFile, onlyFeatures);  
  65.     }  
  66. }  
  67.   
  68.   
  69. public int[] getGlobalGids() {  
  70.     // 該變量保存xml中group標籤定義的gid  
  71.     return mGlobalGids;  
  72. }  
  73.   
  74. public SparseArray<ArraySet<String>> getSystemPermissions() {  
  75.     // uid爲索引，存儲一個字符串集合，用於描述指定UID所擁有的權限。解析assign-permission標籤而來  
  76.     return mSystemPermissions;  
  77. }  
  78.   
  79. public ArrayMap<String, String> getSharedLibraries() {  
  80.     // 解析library標籤而來，key爲庫的名字，value爲庫文件的位置  
  81.     return mSharedLibraries;  
  82. }  
  83.   
  84. public ArrayMap<String, FeatureInfo> getAvailableFeatures() {  
  85.     // 解析feature標籤而來。key爲feature的字符串描述，value爲FeatureInfo對象  
  86.     return mAvailableFeatures;  
  87. }  
  88.   
  89. public ArrayMap<String, PermissionEntry> getPermissions() {  
  90.     // 解析permission標籤而來，key爲權限名，value爲PermissionEntry對象。  
  91.     return mPermissions;  
  92. }  


Android系統每次啓動時，都會重新安裝一遍系統中的應用程序，但是有些應用程序信息每次安裝都是需要保持一致的，如應用程序的Linux用戶ID等。否則應用程序每次在系統重啓後表現可能不一致。因此PMS每次在安裝完成應用程序之後，都需要將它們的信息保存下來，以便下次安裝時可以恢復回來。恢復上一次的應用程序安裝信息是通過Settings類的readLPw方法實現的。下面就分析下該方法掃描packages.xml文件或其備份文件的過程：

[java]  view plain  copy
  1. // 讀取應用程序的安裝信息  
  2. boolean readLPw(PackageManagerService service, List<UserInfo> users, int sdkVersion,  
  3.         boolean onlyCore) {  
  4.     FileInputStream str = null;  
  5.     // 先檢查/data/system/packages-backup.xml文件是否存在，  
  6.     // 如果存在就將它的內容作爲上一次的應用程序安裝信息  
  7.     if (mBackupSettingsFilename.exists()) {  
  8.         try {  
  9.             str = new FileInputStream(mBackupSettingsFilename);  
  10.             mReadMessages.append("Reading from backup settings file\n");  
  11.             PackageManagerService.reportSettingsProblem(Log.INFO,  
  12.                     "Need to read from backup settings file");  
  13.             if (mSettingsFilename.exists()) {  
  14.                 // 備份文件和原文件都存在時，原文件可能已經損壞了，故這裏要刪除掉原文件  
  15.                 Slog.w(PackageManagerService.TAG, "Cleaning up settings file "  
  16.                         + mSettingsFilename);  
  17.                 mSettingsFilename.delete();  
  18.             }  
  19.         } catch (java.io.IOException e) {  
  20.             // We'll try for the normal settings file.  
  21.         }  
  22.     }  
  23.   
  24.     mPendingPackages.clear();  
  25.     mPastSignatures.clear();  
  26.     mKeySetRefs.clear();  
  27.   
  28.     try {  
  29.         // 如果str爲null，說明沒有讀取備份文件，下面要讀取原文件  
  30.         if (str == null) {  
  31.             if (!mSettingsFilename.exists()) {  
  32.                 mReadMessages.append("No settings file found\n");  
  33.                 PackageManagerService.reportSettingsProblem(Log.INFO,  
  34.                         "No settings file; creating initial state");  
  35.                 // 如果原文件不存在，根據默認值創建版本信息。  
  36.                 findOrCreateVersion(StorageManager.UUID_PRIVATE_INTERNAL);  
  37.                 findOrCreateVersion(StorageManager.UUID_PRIMARY_PHYSICAL);  
  38.                 return false;  
  39.             }  
  40.             str = new FileInputStream(mSettingsFilename);  
  41.         }  
  42.         // 創建解析器  
  43.         XmlPullParser parser = Xml.newPullParser();  
  44.         parser.setInput(str, StandardCharsets.UTF_8.name());  
  45.   
  46.         int type;  
  47.         while ((type = parser.next()) != XmlPullParser.START_TAG  
  48.                 && type != XmlPullParser.END_DOCUMENT) {  
  49.             ;  
  50.         }  
  51.   
  52.         if (type != XmlPullParser.START_TAG) {  
  53.             mReadMessages.append("No start tag found in settings file\n");  
  54.             PackageManagerService.reportSettingsProblem(Log.WARN,  
  55.                     "No start tag found in package manager settings");  
  56.             Slog.wtf(PackageManagerService.TAG,  
  57.                     "No start tag found in package manager settings");  
  58.             return false;  
  59.         }  
  60.   
  61.         int outerDepth = parser.getDepth();  
  62.         // 開始解析xml文件  
  63.         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT  
  64.                 && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {  
  65.             if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {  
  66.                 continue;  
  67.             }  
  68.   
  69.             String tagName = parser.getName();  
  70.             if (tagName.equals("package")) {  
  71.                 // 解析標籤爲package的元素，一個應用一個package標籤.  
  72.                 // 獲取上一次安裝這個應用程序時所分配給它的Linux用戶ID  
  73.                 readPackageLPw(parser);  
  74.             } else if (tagName.equals("permissions")) {  
  75.                 // 解析系統定義了哪些權限，由哪個包定義  
  76.                 readPermissionsLPw(mPermissions, parser);  
  77.             } else if (tagName.equals("permission-trees")) {  
  78.                 readPermissionsLPw(mPermissionTrees, parser);  
  79.             } else if (tagName.equals("shared-user")) {  
  80.                 // shared-user標籤是以sharedUserId的名字爲name屬性，然後爲它分配一個userId賦值給userId屬性。  
  81.                 // 其他應用用到該sharedUserId的，userId都是shared-user標籤中的userId屬性值  
  82.                 // 解析上一次應用程序安裝信息中的共享Linux用戶信息  
  83.                 readSharedUserLPw(parser);  
  84.             }  
  85.             . . .  
  86.             else {  
  87.                 Slog.w(PackageManagerService.TAG, "Unknown element under <packages>: "  
  88.                         + parser.getName());  
  89.                 XmlUtils.skipCurrentTag(parser);  
  90.             }  
  91.         }  
  92.   
  93.         str.close();  
  94.   
  95.     } catch (XmlPullParserException e) {  
  96.         mReadMessages.append("Error reading: " + e.toString());  
  97.         PackageManagerService.reportSettingsProblem(Log.ERROR, "Error reading settings: " + e);  
  98.         Slog.wtf(PackageManagerService.TAG, "Error reading package manager settings", e);  
  99.   
  100.     } catch (java.io.IOException e) {  
  101.         mReadMessages.append("Error reading: " + e.toString());  
  102.         PackageManagerService.reportSettingsProblem(Log.ERROR, "Error reading settings: " + e);  
  103.         Slog.wtf(PackageManagerService.TAG, "Error reading package manager settings", e);  
  104.     }  
  105.   
  106.     . . .  
  107.       
  108.     // 先看readPackageLPw方法再往下面看  
  109.     final int N = mPendingPackages.size();  
  110.   
  111.     // 循環遍歷mPendingPackages中的PendingPackage對象，以便爲它們所描述的應用程序保存上一次安裝時所使用的Linux用戶ID  
  112.     for (int i = 0; i < N; i++) {  
  113.         final PendingPackage pp = mPendingPackages.get(i);  
  114.         // 根據uid獲取對應的對象，如果在mUserIds或mOtherUserIds中存在一個與userId對應的Object對象，  
  115.         // 且該對象是SharedUserSetting的類型，則說明pp所描述的應用程序上一次所使用的Linux用戶ID是有效的  
  116.         Object idObj = getUserIdLPr(pp.sharedId);  
  117.         if (idObj != null && idObj instanceof SharedUserSetting) {  
  118.             // 爲該應用程序分配一個Linux用戶ID  
  119.             PackageSetting p = getPackageLPw(pp.name, null, pp.realName,  
  120.                     (SharedUserSetting) idObj, pp.codePath, pp.resourcePath,  
  121.                     pp.legacyNativeLibraryPathString, pp.primaryCpuAbiString,  
  122.                     pp.secondaryCpuAbiString, pp.versionCode, pp.pkgFlags, pp.pkgPrivateFlags,  
  123.                     null, true /* add */, false /* allowInstall */);  
  124.             if (p == null) {  
  125.                 PackageManagerService.reportSettingsProblem(Log.WARN,  
  126.                         "Unable to create application package for " + pp.name);  
  127.                 continue;  
  128.             }  
  129.             p.copyFrom(pp);  
  130.         } else if (idObj != null) {  
  131.             String msg = "Bad package setting: package " + pp.name + " has shared uid "  
  132.                     + pp.sharedId + " that is not a shared uid\n";  
  133.             mReadMessages.append(msg);  
  134.             PackageManagerService.reportSettingsProblem(Log.ERROR, msg);  
  135.         } else {  
  136.             String msg = "Bad package setting: package " + pp.name + " has shared uid "  
  137.                     + pp.sharedId + " that is not defined\n";  
  138.             mReadMessages.append(msg);  
  139.             PackageManagerService.reportSettingsProblem(Log.ERROR, msg);  
  140.         }  
  141.     }  
  142.     mPendingPackages.clear();  
  143.     . . .  
  144.   
  145.     mReadMessages.append("Read completed successfully: " + mPackages.size() + " packages, "  
  146.             + mSharedUsers.size() + " shared uids\n");  
  147.   
  148.     return true;  
  149. }  
  150.   
  151. private static final String ATTR_NAME = "name";  
  152. // 解析標籤爲package的元素，可以獲取到上一次安裝這個應用程序時所分配給它的Linux用戶ID  
  153. private void readPackageLPw(XmlPullParser parser) throws XmlPullParserException, IOException {  
  154.     String name = null;  
  155.     String idStr = null;  
  156.     String sharedIdStr = null;  
  157.     . . .  
  158.     try {  
  159.         // 應用程序的包名  
  160.         name = parser.getAttributeValue(null, ATTR_NAME);  
  161.         // 應用程序所使用的獨立Linux用戶ID  
  162.         idStr = parser.getAttributeValue(null, "userId");  
  163.         // 應用程序所使用的共享Linux用戶ID  
  164.         sharedIdStr = parser.getAttributeValue(null, "sharedUserId");  
  165.         . . .  
  166.   
  167.         int userId = idStr != null ? Integer.parseInt(idStr) : 0;  
  168.         . . .  
  169.         if (name == null) {  
  170.             // 安裝的應用程序包名不能爲null，否則上報錯誤信息  
  171.             PackageManagerService.reportSettingsProblem(Log.WARN,  
  172.                     "Error in package manager settings: <package> has no name at "  
  173.                             + parser.getPositionDescription());  
  174.         }  
  175.         . . .  
  176.         else if (userId > 0) {  
  177.             // 檢查該應用是否被分配了一個獨立的uid，如果是就在系統中保存值爲userId的Linux用戶ID  
  178.             packageSetting = addPackageLPw(name.intern(), realName, new File(codePathStr),  
  179.                     new File(resourcePathStr), legacyNativeLibraryPathStr, primaryCpuAbiString,  
  180.                     secondaryCpuAbiString, cpuAbiOverrideString, userId, versionCode, pkgFlags,  
  181.                     pkgPrivateFlags);  
  182.             . . .  
  183.         } else if (sharedIdStr != null) {  
  184.             // 如果sharedIdStr不爲null，說明安裝該應用時PMS給它分配了一個共享的uid。此時不能馬上保存該uid，  
  185.             // 因爲這個uid不屬於它自己所有，等解析完shared-user節點之後，再爲它保存上一次所使用的Linux用戶ID  
  186.             userId = sharedIdStr != null ? Integer.parseInt(sharedIdStr) : 0;  
  187.             if (userId > 0) {  
  188.                 // 創建PendingPackage對象並保存在mPendingPackages中，用來描述一個Linux用戶ID還未確定的應用程序  
  189.                 packageSetting = new PendingPackage(name.intern(), realName, new File(  
  190.                         codePathStr), new File(resourcePathStr), legacyNativeLibraryPathStr,  
  191.                         primaryCpuAbiString, secondaryCpuAbiString, cpuAbiOverrideString,  
  192.                         userId, versionCode, pkgFlags, pkgPrivateFlags);  
  193.                 . . .  
  194.                 mPendingPackages.add((PendingPackage) packageSetting);  
  195.                 . . .  
  196.             }  
  197.             . . .  
  198.         } else {  
  199.             PackageManagerService.reportSettingsProblem(Log.WARN,  
  200.                     "Error in package manager settings: package " + name + " has bad userId "  
  201.                             + idStr + " at " + parser.getPositionDescription());  
  202.         }  
  203.     } catch (NumberFormatException e) {  
  204.         PackageManagerService.reportSettingsProblem(Log.WARN,  
  205.                 "Error in package manager settings: package " + name + " has bad userId "  
  206.                         + idStr + " at " + parser.getPositionDescription());  
  207.     }  
  208. }  
  209.   
  210. // 在系統中保存值爲userId的Linux用戶ID  
  211. // 在PMS中，每一個應用程序的安裝信息都是使用一個PackageSetting對象來描述的。這些對象保存在mPackages中。  
  212. PackageSetting addPackageLPw(String name, String realName, File codePath, File resourcePath,  
  213.         String legacyNativeLibraryPathString, String primaryCpuAbiString, String secondaryCpuAbiString,  
  214.         String cpuAbiOverrideString, int uid, int vc, int pkgFlags, int pkgPrivateFlags) {  
  215.     // 根據包名獲取應用程序的安裝信息  
  216.     PackageSetting p = mPackages.get(name);  
  217.     if (p != null) {  
  218.         // 如果應用程序的安裝信息不爲null，並且uid和目標uid相同則說明PMS已經爲該應用程序分配過uid了  
  219.         if (p.appId == uid) {  
  220.             return p;  
  221.         }  
  222.         PackageManagerService.reportSettingsProblem(Log.ERROR,  
  223.                 "Adding duplicate package, keeping first: " + name);  
  224.         return null;  
  225.     }  
  226.     // 如果mPackages中不存在與該包名對應的PackageSetting對象，則爲該應用程序分配一個參數uid所描述的Linux用戶ID  
  227.     p = new PackageSetting(name, realName, codePath, resourcePath,  
  228.             legacyNativeLibraryPathString, primaryCpuAbiString, secondaryCpuAbiString,  
  229.             cpuAbiOverrideString, vc, pkgFlags, pkgPrivateFlags);  
  230.     p.appId = uid;  
  231.     // 在系統中保存保存值爲uid的Linux用戶ID  
  232.     if (addUserIdLPw(uid, p, name)) {  
  233.         mPackages.put(name, p);  
  234.         return p;  
  235.     }  
  236.     return null;  
  237. }  
  238.   
  239. // 解析上一次的應用程序安裝信息中的共享Linux用戶信息  
  240. private void readSharedUserLPw(XmlPullParser parser) throws XmlPullParserException,IOException {  
  241.     String name = null;  
  242.     String idStr = null;  
  243.     int pkgFlags = 0;  
  244.     int pkgPrivateFlags = 0;  
  245.     SharedUserSetting su = null;  
  246.     try {  
  247.         // 獲取sharedUserId的名字  
  248.         name = parser.getAttributeValue(null, ATTR_NAME);  
  249.         // 所有共享該sharedUserId名字的應用程序uid  
  250.         idStr = parser.getAttributeValue(null, "userId");  
  251.         int userId = idStr != null ? Integer.parseInt(idStr) : 0;  
  252.         // system屬性用來描述這個共享uid是分配給一個系統類型的應用程序使用的還是分配給一個用戶類型的應用程序使用的。  
  253.         if ("true".equals(parser.getAttributeValue(null, "system"))) {  
  254.             pkgFlags |= ApplicationInfo.FLAG_SYSTEM;  
  255.         }  
  256.         if (name == null) {  
  257.             PackageManagerService.reportSettingsProblem(Log.WARN,  
  258.                     "Error in package manager settings: <shared-user> has no name at "  
  259.                             + parser.getPositionDescription());  
  260.         } else if (userId == 0) {  
  261.             PackageManagerService.reportSettingsProblem(Log.WARN,  
  262.                     "Error in package manager settings: shared-user " + name  
  263.                             + " has bad userId " + idStr + " at "  
  264.                             + parser.getPositionDescription());  
  265.         } else {  
  266.             // 調用addSharedUserLPw方法在系統中爲名稱爲name的共享Linux用戶保存一個值爲userId的Linux用戶  
  267.             if ((su = addSharedUserLPw(name.intern(), userId, pkgFlags, pkgPrivateFlags))  
  268.                     == null) {  
  269.                 PackageManagerService  
  270.                         .reportSettingsProblem(Log.ERROR, "Occurred while parsing settings at "  
  271.                                 + parser.getPositionDescription());  
  272.             }  
  273.         }  
  274.     } catch (NumberFormatException e) {  
  275.         PackageManagerService.reportSettingsProblem(Log.WARN,  
  276.                 "Error in package manager settings: package " + name + " has bad userId "  
  277.                         + idStr + " at " + parser.getPositionDescription());  
  278.     }  
  279.   
  280.     . . .  
  281. }  
  282.   
  283. // 在系統中爲名稱爲name的共享Linux用戶保存一個值爲userId的Linux用戶  
  284. // 在PMS中，每一個共享Linux用戶都是使用一個SharedUserSetting對象來描述的。這些對象保存在mSharedUsers中。  
  285. SharedUserSetting addSharedUserLPw(String name, int uid, int pkgFlags, int pkgPrivateFlags) {  
  286.     // 根據包名獲取共享應用程序的安裝信息，如果存在並且userId等於參數uid的值，則說明PMS已經爲該應用程序分配過uid了  
  287.     SharedUserSetting s = mSharedUsers.get(name);  
  288.     if (s != null) {  
  289.         if (s.userId == uid) {  
  290.             return s;  
  291.         }  
  292.         PackageManagerService.reportSettingsProblem(Log.ERROR,  
  293.                 "Adding duplicate shared user, keeping first: " + name);  
  294.         return null;  
  295.     }  
  296.     // 如果mSharedUsers中不存在與該包名對應的SharedUserSetting對象，則爲該應用程序分配一個參數uid所描述的Linux用戶ID  
  297.     s = new SharedUserSetting(name, pkgFlags, pkgPrivateFlags);  
  298.     s.userId = uid;  
  299.     // 在系統中保存保存值爲uid的Linux用戶ID  
  300.     if (addUserIdLPw(uid, s, name)) {  
  301.         mSharedUsers.put(name, s);  
  302.         return s;  
  303.     }  
  304.     return null;  
  305. }  
  306.   
  307. // 爲應用程序分配一個Linux用戶ID  
  308. private PackageSetting getPackageLPw(String name, PackageSetting origPackage,  
  309.         String realName, SharedUserSetting sharedUser, File codePath, File resourcePath,  
  310.         String legacyNativeLibraryPathString, String primaryCpuAbiString,  
  311.         String secondaryCpuAbiString, int vc, int pkgFlags, int pkgPrivateFlags,  
  312.         UserHandle installUser, boolean add, boolean allowInstall) {  
  313.     // 根據name從mPackages中獲取PackageSetting對象  
  314.     PackageSetting p = mPackages.get(name);  
  315.     UserManagerService userManager = UserManagerService.getInstance();  
  316.     if (p != null) {  
  317.         . . .  
  318.   
  319.         // 判斷已經存在的p對象的sharedUser是否和傳遞來的一致，若不一致說明對象p已不能描述應用的安裝信息，需要重新分配  
  320.         if (p.sharedUser != sharedUser) {  
  321.             PackageManagerService.reportSettingsProblem(Log.WARN,  
  322.                     "Package " + name + " shared user changed from "  
  323.                     + (p.sharedUser != null ? p.sharedUser.name : "<nothing>")  
  324.                     + " to "  
  325.                     + (sharedUser != null ? sharedUser.name : "<nothing>")  
  326.                     + "; replacing with new");  
  327.             p = null;  
  328.         } else {  
  329.             // 判斷當前分配的應用是否是系統應用/私有特權應用  
  330.             p.pkgFlags |= pkgFlags & ApplicationInfo.FLAG_SYSTEM;  
  331.             p.pkgPrivateFlags |= pkgPrivateFlags & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED;  
  332.         }  
  333.     }  
  334.     // p爲null說明要重新分配Linux用戶ID  
  335.     if (p == null) {  
  336.         if (origPackage != null) {  
  337.             // origPackage不爲null說明該應用程序在系統中有一箇舊版本  
  338.             // 根據舊版本的應用程序創建一個新的PackageSetting對象  
  339.             p = new PackageSetting(origPackage.name, name, codePath, resourcePath,  
  340.                     legacyNativeLibraryPathString, primaryCpuAbiString, secondaryCpuAbiString,  
  341.                     null /* cpuAbiOverrideString */, vc, pkgFlags, pkgPrivateFlags);  
  342.             . . .  
  343.             // 把舊安裝包的userId分配給該應用程序  
  344.             p.appId = origPackage.appId;  
  345.             . . .  
  346.         } else {  
  347.             // origPackage爲null，說明該應用是一個新安裝的應用程序  
  348.             // 根據傳遞過來的參數新建一個PackageSetting對象  
  349.             p = new PackageSetting(name, realName, codePath, resourcePath,  
  350.                     legacyNativeLibraryPathString, primaryCpuAbiString, secondaryCpuAbiString,  
  351.                     null /* cpuAbiOverrideString */, vc, pkgFlags, pkgPrivateFlags);  
  352.             p.setTimeStamp(codePath.lastModified());  
  353.             p.sharedUser = sharedUser;  
  354.             // 如果該應用不是系統應用，則新安裝後是停止運行狀態  
  355.             if ((pkgFlags&ApplicationInfo.FLAG_SYSTEM) == 0) {  
  356.                 List<UserInfo> users = getAllUsers();  
  357.                 final int installUserId = installUser != null ? installUser.getIdentifier() : 0;  
  358.                 if (users != null && allowInstall) {  
  359.                     for (UserInfo user : users) {  
  360.                         final boolean installed = installUser == null  
  361.                                 || (installUserId == UserHandle.USER_ALL  
  362.                                     && !isAdbInstallDisallowed(userManager, user.id))  
  363.                                 || installUserId == user.id;  
  364.                         // 設置該應用是停止運行狀態  
  365.                         p.setUserState(user.id, COMPONENT_ENABLED_STATE_DEFAULT,  
  366.                                 installed,  
  367.                                 true, // stopped,  
  368.                                 true, // notLaunched  
  369.                                 false, // hidden  
  370.                                 null, null, null,  
  371.                                 false, // blockUninstall  
  372.                                 INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED, 0);  
  373.                         writePackageRestrictionsLPr(user.id);  
  374.                     }  
  375.                 }  
  376.             }  
  377.             if (sharedUser != null) {  
  378.                 // 如果sharedUser不爲null，說明該新安裝應用程序設置了sharedUserId屬性，  
  379.                 // 則把sharedUserId的userId分配給該應用  
  380.                 p.appId = sharedUser.userId;  
  381.             } else {  
  382.                 // 如果該新安裝應用程序沒有設置sharedUserId屬性，則需要爲該應用程序分配新的Linux用戶ID  
  383.                   
  384.                 // 根據name值從已經禁用的系統應用程序列表中獲取PackageSetting對象  
  385.                 PackageSetting dis = mDisabledSysPackages.get(name);  
  386.                 if (dis != null) {  
  387.                     // 如果dis不爲null，說明該應用程序是一個已經禁用的系統應用，此時  
  388.                     // 只需用把它原來的userId分配給它即可  
  389.                     . . .  
  390.                     // 把原來的userId分配給該應用程序  
  391.                     p.appId = dis.appId;  
  392.                     . . .  
  393.                     // 在系統中保存保存值爲uid的Linux用戶ID  
  394.                     addUserIdLPw(p.appId, p, name);  
  395.                 } else {  
  396.                     // 如果dis爲null，說明需要爲該新安裝應用程序新分配一個Linux用戶ID  
  397.                     p.appId = newUserIdLPw(p);  
  398.                 }  
  399.             }  
  400.         }  
  401.         if (p.appId < 0) {  
  402.             PackageManagerService.reportSettingsProblem(Log.WARN,  
  403.                     "Package " + name + " could not be assigned a valid uid");  
  404.             return null;  
  405.         }  
  406.         if (add) {  
  407.             // 調用addPackageSettingLPw方法把p保存到mPackages中，  
  408.             // 表示它所描述的應用程序已經成功地安裝在系統中了  
  409.             addPackageSettingLPw(p, name, sharedUser);  
  410.         }  
  411.     } else {  
  412.         // p不爲null說明不需要重新分配Linux用戶ID  
  413.         if (installUser != null && allowInstall) {  
  414.             // The caller has explicitly specified the user they want this  
  415.             // package installed for, and the package already exists.  
  416.             // Make sure it conforms to the new request.  
  417.             List<UserInfo> users = getAllUsers();  
  418.             if (users != null) {  
  419.                 for (UserInfo user : users) {  
  420.                     if ((installUser.getIdentifier() == UserHandle.USER_ALL  
  421.                                 && !isAdbInstallDisallowed(userManager, user.id))  
  422.                             || installUser.getIdentifier() == user.id) {  
  423.                         boolean installed = p.getInstalled(user.id);  
  424.                         if (!installed) {  
  425.                             p.setInstalled(true, user.id);  
  426.                             writePackageRestrictionsLPr(user.id);  
  427.                         }  
  428.                     }  
  429.                 }  
  430.             }  
  431.         }  
  432.     }  
  433.     return p;  
  434. }  
  435.   
  436. // 爲該新安裝應用程序新分配一個Linux用戶ID  
  437. private int newUserIdLPw(Object obj) {  
  438.     // 獲取之前已經分配出去的Linux用戶ID的數量  
  439.     final int N = mUserIds.size();  
  440.     for (int i = mFirstAvailableUid; i < N; i++) {  
  441.         // 如果第i個對象值爲null，說明值爲Process.FIRST_APPLICATION_UID + i  
  442.         // 的Linux用戶ID還未分配出去，這裏就將該值分配給新安裝的應用程序使用  
  443.         if (mUserIds.get(i) == null) {  
  444.             mUserIds.set(i, obj);  
  445.             return Process.FIRST_APPLICATION_UID + i;  
  446.         }  
  447.     }  
  448.   
  449.     // 如果已經沒有值可分配時，則返回-1  
  450.     if (N > (Process.LAST_APPLICATION_UID-Process.FIRST_APPLICATION_UID)) {  
  451.         return -1;  
  452.     }  
  453.   
  454.     mUserIds.add(obj);  
  455.     // 如果不能在mUserIds中找到空閒的Linux用戶ID，且沒有超過分配限制，則把  
  456.     // Process.FIRST_APPLICATION_UID + N分配給新安裝應用程序使用  
  457.     return Process.FIRST_APPLICATION_UID + N;  
  458. }  


到這裏，掃描目標文件夾之前的準備工作就介紹完了。主要是掃描並解析xml文件將上一次的應用程序安裝信息恢復完成。

2.掃描目標文件夾

先看下時序圖：

下面主要是掃描系統中的apk文件了。繼續分析PMS的構造方法：

[java]  view plain  copy
  1. private static final String VENDOR_OVERLAY_DIR = "/vendor/overlay";  
  2.   
  3. public PackageManagerService(Context context, Installer installer,  
  4.         boolean factoryTest, boolean onlyCore) {  
  5.   
  6.     . . .  
  7.     // 記錄開始掃描的時間  
  8.     long startTime = SystemClock.uptimeMillis();  
  9.   
  10.     // 初始化掃描參數  
  11.     final int scanFlags = SCAN_NO_PATHS | SCAN_DEFER_DEX | SCAN_BOOTING | SCAN_INITIAL;  
  12.   
  13.     // /system/framework目錄保存的應用程序是資源型的。資源型的應用程序是用來打包資源文件的，不包含有執行代碼  
  14.     File frameworkDir = new File(Environment.getRootDirectory(), "framework");  
  15.     . . .  
  16.     // Collect vendor overlay packages.  
  17.     // (Do this before scanning any apps.)  
  18.     // 收集供應商提供的覆蓋應用程序  
  19.     File vendorOverlayDir = new File(VENDOR_OVERLAY_DIR);  
  20.     scanDirLI(vendorOverlayDir, PackageParser.PARSE_IS_SYSTEM  
  21.             | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags | SCAN_TRUSTED_OVERLAY, 0);  
  22.   
  23.     // Find base frameworks (resource packages without code).  
  24.     scanDirLI(frameworkDir, PackageParser.PARSE_IS_SYSTEM  
  25.             | PackageParser.PARSE_IS_SYSTEM_DIR  
  26.             | PackageParser.PARSE_IS_PRIVILEGED,  
  27.             scanFlags | SCAN_NO_DEX, 0);  
  28.   
  29.     // Collected privileged system packages./system/priv-app系統自帶應用程序  
  30.     final File privilegedAppDir = new File(Environment.getRootDirectory(), "priv-app");  
  31.     scanDirLI(privilegedAppDir, PackageParser.PARSE_IS_SYSTEM  
  32.             | PackageParser.PARSE_IS_SYSTEM_DIR  
  33.             | PackageParser.PARSE_IS_PRIVILEGED, scanFlags, 0);  
  34.   
  35.     // Collect ordinary system packages./system/app目錄保存的是系統自帶的應用程序  
  36.     final File systemAppDir = new File(Environment.getRootDirectory(), "app");  
  37.     scanDirLI(systemAppDir, PackageParser.PARSE_IS_SYSTEM  
  38.             | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags, 0);  
  39.   
  40.     // Collect all vendor packages.供應商提供的應用程序  
  41.     File vendorAppDir = new File("/vendor/app");  
  42.     try {  
  43.         vendorAppDir = vendorAppDir.getCanonicalFile();  
  44.     } catch (IOException e) {  
  45.         // failed to look up canonical path, continue with original one  
  46.     }  
  47.     scanDirLI(vendorAppDir, PackageParser.PARSE_IS_SYSTEM  
  48.             | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags, 0);  
  49.     if (DEBUG_UPGRADE) Log.v(TAG, "Running installd update commands");  
  50.     mInstaller.moveFiles();  
  51.   
  52.     // 刪除各種無效安裝包  
  53.       
  54.     if (!mOnlyCore) {  
  55.         EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_DATA_SCAN_START,  
  56.                 SystemClock.uptimeMillis());  
  57.         scanDirLI(mAppInstallDir, 0, scanFlags | SCAN_REQUIRE_KNOWN, 0);  
  58.   
  59.         scanDirLI(mDrmAppPrivateInstallDir, PackageParser.PARSE_FORWARD_LOCK,  
  60.                 scanFlags | SCAN_REQUIRE_KNOWN, 0);  
  61.         . . .  
  62.   
  63.     }  
  64.   
  65.     // Now that we know all the packages we are keeping,  
  66.     // read and update their last usage times.  
  67.     mPackageUsage.readLP();// 更新各安裝包的上次使用時間  
  68.   
  69.     EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SCAN_END,  
  70.             SystemClock.uptimeMillis());  
  71.     // 輸出掃描用的時間  
  72.     Slog.i(TAG, "Time to scan packages: "  
  73.             + ((SystemClock.uptimeMillis()-startTime)/1000f)  
  74.             + " seconds");  
  75.     . . .  
  76. }  


上面這段代碼主要是掃描系統中各相關目錄下的apk文件。

[java]  view plain  copy
  1. // 掃描給定目錄下的apk文件  
  2. private void scanDirLI(File dir, int parseFlags, int scanFlags, long currentTime) {  
  3.     final File[] files = dir.listFiles();  
  4.     if (ArrayUtils.isEmpty(files)) {  
  5.         Log.d(TAG, "No files in app dir " + dir);  
  6.         return;  
  7.     }  
  8.   
  9.     Log.d(TAG, "start scanDirLI:"+dir);  
  10.     // 使用多線程提高掃描速度  
  11.     int iMultitaskNum = SystemProperties.getInt("persist.pm.multitask", 6);  
  12.     Log.d(TAG, "max thread:" + iMultitaskNum);  
  13.     final MultiTaskDealer dealer = (iMultitaskNum > 1) ? MultiTaskDealer.startDealer(  
  14.             MultiTaskDealer.PACKAGEMANAGER_SCANER, iMultitaskNum) : null;  
  15.   
  16.     for (File file : files) {  
  17.         final boolean isPackage = (isApkFile(file) || file.isDirectory())  
  18.                 && !PackageInstallerService.isStageName(file.getName());  
  19.         if (!isPackage) {  
  20.             continue;  
  21.         }  
  22.   
  23.         final File ref_file = file;  
  24.         final int ref_parseFlags = parseFlags;  
  25.         final int ref_scanFlags = scanFlags;  
  26.         final long ref_currentTime = currentTime;  
  27.         Runnable scanTask = new Runnable() {  
  28.             public void run() {  
  29.                 try {  
  30.                     // 解析apk文件  
  31.                     scanPackageLI(ref_file, ref_parseFlags | PackageParser.PARSE_MUST_BE_APK,  
  32.                             ref_scanFlags, ref_currentTime, null);  
  33.                 } catch (PackageManagerException e) {  
  34.                     Slog.w(TAG, "Failed to parse " + ref_file + ": " + e.getMessage());  
  35.   
  36.                     // 解析失敗則刪除無效的apk文件  
  37.                     if ((ref_parseFlags & PackageParser.PARSE_IS_SYSTEM) == 0 &&  
  38.                             e.error == PackageManager.INSTALL_FAILED_INVALID_APK) {  
  39.                         logCriticalInfo(Log.WARN, "Deleting invalid package at " + ref_file);  
  40.                         if (ref_file.isDirectory()) {  
  41.                             mInstaller.rmPackageDir(ref_file.getAbsolutePath());  
  42.                         } else {  
  43.                             ref_file.delete();  
  44.                         }  
  45.                     }  
  46.                 }  
  47.             }  
  48.         };  
  49.   
  50.         if (dealer != null)  
  51.             dealer.addTask(scanTask);  
  52.         else  
  53.             scanTask.run();  
  54.     }  
  55.   
  56.     if (dealer != null)  
  57.         dealer.waitAll();  
  58.     Log.d(TAG, "end scanDirLI:"+dir);  
  59. }  
  60.   
  61. // 解析apk文件  
  62. private PackageParser.Package scanPackageLI(File scanFile, int parseFlags, int scanFlags,  
  63.         long currentTime, UserHandle user) throws PackageManagerException {  
  64.     if (DEBUG_INSTALL) Slog.d(TAG, "Parsing: " + scanFile);  
  65.     parseFlags |= mDefParseFlags;  
  66.     PackageParser pp = new PackageParser();  
  67.     . . .  
  68.   
  69.     final PackageParser.Package pkg;  
  70.     try {  
  71.         // 解析apk文件後返回一個PackageParser.Package對象  
  72.         pkg = pp.parsePackage(scanFile, parseFlags);  
  73.     } catch (PackageParserException e) {  
  74.         throw PackageManagerException.from(e);  
  75.     }  
  76.     . . .  
  77.   
  78.     // Set application objects path explicitly.  
  79.     pkg.applicationInfo.volumeUuid = pkg.volumeUuid;  
  80.     pkg.applicationInfo.setCodePath(pkg.codePath);  
  81.     pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);  
  82.     pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);  
  83.     pkg.applicationInfo.setResourcePath(resourcePath);  
  84.     pkg.applicationInfo.setBaseResourcePath(baseResourcePath);  
  85.     pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);  
  86.   
  87.     // 對剛解析apk文件返回的pkg對象所描述的apk文件進行安裝，以便獲取它的組件信息，以及爲它分配Linux用戶ID等。  
  88.     PackageParser.Package scannedPkg = scanPackageLI(pkg, parseFlags, scanFlags  
  89.             | SCAN_UPDATE_SIGNATURE, currentTime, user);  
  90.   
  91.     return scannedPkg;  
  92. }  


接下來先看PackageParser類的parsePackage方法：

[java]  view plain  copy
  1. // 解析apk文件  
  2. public Package parsePackage(File packageFile, int flags) throws PackageParserException {  
  3.     if (packageFile.isDirectory()) {  
  4.         // 解析文件夾下的所有apk文件  
  5.         return parseClusterPackage(packageFile, flags);  
  6.     } else {  
  7.         // 解析獨立apk文件  
  8.         return parseMonolithicPackage(packageFile, flags);  
  9.     }  
  10. }  
  11.   
  12. // 解析獨立apk文件  
  13. public Package parseMonolithicPackage(File apkFile, int flags) throws PackageParserException {  
  14.     if (mOnlyCoreApps) {  
  15.         // 根據傳遞來的參數生成一個PackageLite對象，並對它進行是否爲核心應用判斷，若不是則拋異常  
  16.         final PackageLite lite = parseMonolithicPackageLite(apkFile, flags);  
  17.         if (!lite.coreApp) {  
  18.             throw new PackageParserException(INSTALL_PARSE_FAILED_MANIFEST_MALFORMED,  
  19.                     "Not a coreApp: " + apkFile);  
  20.         }  
  21.     }  
  22.   
  23.     final AssetManager assets = new AssetManager();  
  24.     try {  
  25.         // 解析apk文件  
  26.         final Package pkg = parseBaseApk(apkFile, assets, flags);  
  27.         pkg.codePath = apkFile.getAbsolutePath();  
  28.         return pkg;  
  29.     } finally {  
  30.         IoUtils.closeQuietly(assets);  
  31.     }  
  32. }  
  33.   
  34. private static final String ANDROID_MANIFEST_FILENAME = "AndroidManifest.xml";  
  35. // 解析apk文件  
  36. private Package parseBaseApk(File apkFile, AssetManager assets, int flags)  
  37.         throws PackageParserException {  
  38.     . . .  
  39.   
  40.     Resources res = null;  
  41.     XmlResourceParser parser = null;  
  42.     try {  
  43.          res = new Resources(assets, mMetrics, null);  
  44.   
  45.         assets.setConfiguration(0, 0, null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
  46.                 Build.VERSION.RESOURCES_SDK_INT);  
  47.         parser = assets.openXmlResourceParser(cookie, ANDROID_MANIFEST_FILENAME);  
  48.   
  49.         final String[] outError = new String[1];  
  50.         // 解析AndroidManifest.xml文件  
  51.         final Package pkg = parseBaseApk(res, parser, flags, outError);  
  52.         if (pkg == null) {  
  53.             throw new PackageParserException(mParseError,  
  54.                     apkPath + " (at " + parser.getPositionDescription() + "): " + outError[0]);  
  55.         }  
  56.         . . .  
  57.         return pkg;  
  58.   
  59.     } catch (PackageParserException e) {  
  60.         throw e;  
  61.     } catch (Exception e) {  
  62.         throw new PackageParserException(INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION,  
  63.                 "Failed to read manifest from " + apkPath, e);  
  64.     } finally {  
  65.         IoUtils.closeQuietly(parser);  
  66.     }  
  67. }  
  68.   
  69. // 解析AndroidManifest.xml文件  
  70. private Package parseBaseApk(Resources res, XmlResourceParser parser, int flags,  
  71.         String[] outError) throws XmlPullParserException, IOException {  
  72.     . . .  
  73.     try {  
  74.         // 解析apk的包名  
  75.         Pair<String, String> packageSplit = parsePackageSplitNames(parser, attrs, flags);  
  76.         pkgName = packageSplit.first;  
  77.         splitName = packageSplit.second;  
  78.     } catch (PackageParserException e) {  
  79.         mParseError = PackageManager.INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME;  
  80.         return null;  
  81.     }  
  82.   
  83.     final Package pkg = new Package(pkgName);  
  84.     boolean foundApp = false;  
  85.   
  86.     // 解析apk的版本號、versionName、等  
  87.     . . .  
  88.     // 解析manifest標籤中的android:sharedUserId屬性  
  89.     String str = sa.getNonConfigurationString(  
  90.             com.android.internal.R.styleable.AndroidManifest_sharedUserId, 0);  
  91.     if (str != null && str.length() > 0) {  
  92.         . . .  
  93.          // 把該屬性值賦值給mSharedUserId  
  94.         pkg.mSharedUserId = str.intern();  
  95.         . . .  
  96.     }  
  97.     . . .  
  98.     sa.recycle();  
  99.     . . .  
  100.   
  101.     // 循環解析manifest的各個子標籤  
  102.     while ((type = parser.next()) != XmlPullParser.END_DOCUMENT  
  103.             && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {  
  104.         if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {  
  105.             continue;  
  106.         }  
  107.   
  108.         String tagName = parser.getName();  
  109.         if (tagName.equals("application")) {  
  110.             . . .  
  111.             // 解析application標籤，該標籤用來描述與應用程序組件相關的信息  
  112.             if (!parseBaseApplication(pkg, res, parser, attrs, flags, outError)) {  
  113.                 return null;  
  114.             }  
  115.         } else if (tagName.equals("uses-permission")) {  
  116.             // 解析uses-permission標籤，一個標籤對應一個資源訪問權限  
  117.             if (!parseUsesPermission(pkg, res, parser, attrs)) {  
  118.                 return null;  
  119.             }  
  120.         }  
  121.         . . .  
  122.         else {  
  123.             Slog.w(TAG, "Unknown element under <manifest>: " + parser.getName()  
  124.                     + " at " + mArchiveSourcePath + " "  
  125.                     + parser.getPositionDescription());  
  126.             XmlUtils.skipCurrentTag(parser);  
  127.             continue;  
  128.         }  
  129.     }  
  130.     . . .  
  131.     return pkg;  
  132. }  
  133.   
  134. // 解析application標籤  
  135. private boolean parseBaseApplication(Package owner, Resources res,  
  136.         XmlPullParser parser, AttributeSet attrs, int flags, String[] outError)  
  137.     throws XmlPullParserException, IOException {  
  138.     // 解析application標籤的基本信息，圖標、應用名等  
  139.     . . .  
  140.   
  141.   
  142.     final int innerDepth = parser.getDepth();  
  143.     int type;  
  144.     // 解析application的子標籤  
  145.     while ((type = parser.next()) != XmlPullParser.END_DOCUMENT  
  146.             && (type != XmlPullParser.END_TAG || parser.getDepth() > innerDepth)) {  
  147.         if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {  
  148.             continue;  
  149.         }  
  150.   
  151.         String tagName = parser.getName();  
  152.         // 解析四大組件的標籤，把相應配置信息都存放在owner的相應列表中  
  153.         if (tagName.equals("activity")) {  
  154.             Activity a = parseActivity(owner, res, parser, attrs, flags, outError, false,  
  155.                     owner.baseHardwareAccelerated);  
  156.             . . .  
  157.             owner.activities.add(a);  
  158.         } else if (tagName.equals("receiver")) {  
  159.             Activity a = parseActivity(owner, res, parser, attrs, flags, outError, true, false);  
  160.             . . .  
  161.             owner.receivers.add(a);  
  162.         } else if (tagName.equals("service")) {  
  163.             Service s = parseService(owner, res, parser, attrs, flags, outError);  
  164.             . . .  
  165.             owner.services.add(s);  
  166.         } else if (tagName.equals("provider")) {  
  167.             Provider p = parseProvider(owner, res, parser, attrs, flags, outError);  
  168.             . . .  
  169.             owner.providers.add(p);  
  170.         }  
  171.         . . .  
  172.         else {  
  173.             . . .  
  174.         }  
  175.     }  
  176.     . . .  
  177.     return true;  
  178. }  


到這裏，PMS就解析完一個應用程序了，下面調用PMS類的scanPackageLI方法以便可以獲得前面所解析的應用程序的組件配置信息，以及爲這個應用程序分配Linux用戶ID：

[java]  view plain  copy
  1. // 獲得前面所解析的應用程序的組件配置信息，以及爲這個應用程序分配Linux用戶ID  
  2. private PackageParser.Package scanPackageLI(PackageParser.Package pkg, int parseFlags,  
  3.         int scanFlags, long currentTime, UserHandle user) throws PackageManagerException {  
  4.     boolean success = false;  
  5.     try {  
  6.         final PackageParser.Package res = scanPackageDirtyLI(pkg, parseFlags, scanFlags,  
  7.                 currentTime, user);  
  8.         success = true;  
  9.         return res;  
  10.     } finally {  
  11.         if (!success && (scanFlags & SCAN_DELETE_DATA_ON_FAILURES) != 0) {  
  12.             removeDataDirsLI(pkg.volumeUuid, pkg.packageName);  
  13.         }  
  14.     }  
  15. }  
  16.   
  17. // 獲得前面所解析的應用程序的組件配置信息，以及爲這個應用程序分配Linux用戶ID  
  18. private PackageParser.Package scanPackageDirtyLI(PackageParser.Package pkg, int parseFlags,  
  19.         int scanFlags, long currentTime, UserHandle user) throws PackageManagerException {  
  20.     final File scanFile = new File(pkg.codePath);  
  21.     . . .  
  22.   
  23.     SharedUserSetting suid = null;  
  24.     PackageSetting pkgSetting = null;  
  25.   
  26.     // 爲參數pkg所描述的應用程序分配Linux用戶ID  
  27.     // writer  
  28.     synchronized (mPackages) {  
  29.         if (pkg.mSharedUserId != null) {  
  30.             // 如果該應用有sharedUserId屬性，則從mSettings中獲取要爲它分配的共享uid  
  31.             suid = mSettings.getSharedUserLPw(pkg.mSharedUserId, 0, 0, true);  
  32.             // 判斷該共享uid是否合法  
  33.             . . .  
  34.         }  
  35.         . . .  
  36.   
  37.         // 爲應用程序分配一個Linux用戶ID  
  38.         pkgSetting = mSettings.getPackageLPw(pkg, origPackage, realName, suid, destCodeFile,  
  39.                 destResourceFile, pkg.applicationInfo.nativeLibraryRootDir,  
  40.                 pkg.applicationInfo.primaryCpuAbi,  
  41.                 pkg.applicationInfo.secondaryCpuAbi,  
  42.                 pkg.applicationInfo.flags, pkg.applicationInfo.privateFlags,  
  43.                 user, false);  
  44.         . . .  
  45.     }  
  46.     . . .  
  47.   
  48.     // writer  
  49.     synchronized (mPackages) {  
  50.         . . .  
  51.         // 把pkg所指向的一個Package對象保存在mSettings中  
  52.         mPackages.put(pkg.applicationInfo.packageName, pkg);  
  53.         . . .  
  54.   
  55.         // 把參數pkg所描述的應用程序的Content Provider組件配置信息保存在mProviders中  
  56.         int N = pkg.providers.size();  
  57.         StringBuilder r = null;  
  58.         int i;  
  59.         for (i=0; i<N; i++) {  
  60.             PackageParser.Provider p = pkg.providers.get(i);  
  61.             p.info.processName = fixProcessName(pkg.applicationInfo.processName,  
  62.                     p.info.processName, pkg.applicationInfo.uid);  
  63.             mProviders.addProvider(p);  
  64.             . . .  
  65.         }  
  66.   
  67.         // 把參數pkg所描述的應用程序的Service組件配置信息保存在mServices中  
  68.         N = pkg.services.size();  
  69.         r = null;  
  70.         for (i=0; i<N; i++) {  
  71.             PackageParser.Service s = pkg.services.get(i);  
  72.             s.info.processName = fixProcessName(pkg.applicationInfo.processName,  
  73.                     s.info.processName, pkg.applicationInfo.uid);  
  74.             mServices.addService(s);  
  75.             . . .  
  76.         }  
  77.   
  78.         // 把參數pkg所描述的應用程序的廣播接收者組件配置信息保存在mReceivers中  
  79.         N = pkg.receivers.size();  
  80.         r = null;  
  81.         for (i=0; i<N; i++) {  
  82.             PackageParser.Activity a = pkg.receivers.get(i);  
  83.             a.info.processName = fixProcessName(pkg.applicationInfo.processName,  
  84.                     a.info.processName, pkg.applicationInfo.uid);  
  85.             mReceivers.addActivity(a, "receiver");  
  86.             . . .  
  87.         }  
  88.   
  89.         // 把參數pkg所描述的應用程序的Activity組件配置信息保存在mActivities中  
  90.         N = pkg.activities.size();  
  91.         r = null;  
  92.         for (i=0; i<N; i++) {  
  93.             PackageParser.Activity a = pkg.activities.get(i);  
  94.             a.info.processName = fixProcessName(pkg.applicationInfo.processName,  
  95.                     a.info.processName, pkg.applicationInfo.uid);  
  96.             mActivities.addActivity(a, "activity");  
  97.             . . .  
  98.         }  
  99.   
  100.         . . .  
  101.     }  
  102.   
  103.     return pkg;  
  104. }  


通過調用getPackageLPw方法爲該應用程序分配uid後，一個應用程序就成功地安裝到系統中了。到這裏PMS構造方法的掃描目標文件夾的工作就完成了。

3.掃描之後的工作

先看下時序圖：

當系統安裝完所有應用程序後，PMS的構造方法就會調用updatePermissionsLPw方法爲前面所安裝的應用程序分配Linux用戶組ID，即授予它們所申請的資源訪問權限，以及調用Settings類的writeLPr方法將這些應用程序的安裝信息保持到本地文件中：

[java]  view plain  copy
  1. public PackageManagerService(Context context, Installer installer,  
  2.         boolean factoryTest, boolean onlyCore) {  
  3.   
  4.     . . .  
  5.     // 爲申請了特定的資源訪問權限的應用程序分配相應的Linux用戶組ID  
  6.     updatePermissionsLPw(null, null, StorageManager.UUID_PRIVATE_INTERNAL, updateFlags);  
  7.     . . .  
  8.       
  9.     // 將前面獲取到的應用程序安裝信息保存在本地的一個配置文件中，以便下一次再安裝這些應用程序時  
  10.     // 可以將需要保持一致的應用程序信息恢復回來  
  11.     mSettings.writeLPr();  
  12.     . . .  
  13.     // Now after opening every single application zip, make sure they  
  14.     // are all flushed.  Not really needed, but keeps things nice and  
  15.     // tidy.  
  16.     Runtime.getRuntime().gc();  
  17.   
  18.     // Expose private service for system components to use.  
  19.     LocalServices.addService(PackageManagerInternal.class, new PackageManagerInternalImpl());  
  20.   
  21.   
  22.     // are all flushed.  Not really needed, but keeps things nice and  
  23.     // tidy.  
  24.     Runtime.getRuntime().gc();  
  25.   
  26.     // Expose private service for system components to use.  
  27.     LocalServices.addService(PackageManagerInternal.class, new PackageManagerInternalImpl());  
  28.   
  29. }  
  30.   
  31. // 爲前面所安裝的應用程序分配Linux用戶組ID  
  32. private void updatePermissionsLPw(String changingPkg,  
  33.         PackageParser.Package pkgInfo, String replaceVolumeUuid, int flags) {  
  34.     . . .  
  35.   
  36.     // Now update the permissions for all packages, in particular  bold">new PackageManagerInternalImpl());  
  37.   
  38. }  
  39.   
  40. // 爲前面所安裝的應用程序分配Linux用戶組ID  
  41. private void updatePermissionsLPw(String changingPkg,  
  42.         PackageParser.Package pkgInfo, String replaceVolumeUuid, int flags) {  
  43.     . . .  
  44.   
  45.     // Now update the permissions for all packages, in particular  
  46.     // replace the granted permissions of the system packages.  
  47.     if ((flags&UPDATE_PERMISSIONS_ALL) != 0) {  
  48.         for (PackageParser.Package pkg : mPackages.values()) {  
  49.             if}  
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程