PKMS启动过程

Android 阅读量

PKMS启动过程

参考：https://blog.csdn.net/u012124438/article/details/54882771

PackageManagerService，是Android系统中核心服务之一，管理着所有跟package相关的工作。Android是基于mashup（混搭）的风格设计的，程序是由一个个的组件拼凑起来的，而PackageManagerService的任务就是解析package，然后把其中的组件信息一个个的拆解出来把相关信息放到内存里，当然还要处理package中的其他东西，比如库文件什么的。在程序需要的时候组件管理器（AMS）会向PKMS查询组件信息，然后创建相应的组件并进行管理。

PKMS涉及的内容比较多，常见的比如安装、卸载应用、应用解析，查询应用信息等。 PKMS服务也是通过binder进行通信，IPackageManager.aidl由工具转换后自动生成binder的服务端IPackageManager.Stub和客户端IPackageManager.Stub.Proxy，具体关系如下：

Binder服务端：PackageManagerService继承于IPackageManager.Stub；
Binder客户端：ApplicationPackageManager(简称APM)的成员变量mPM继承于IPackageManager.Stub.Proxy; 本身APM是继承于PackageManager对象。

首先先来看下PKMS的注释：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
 * Keep track of all those APKs everywhere.
 * <p>
 * Internally there are two important locks:
 * <ul>
 * <li>{@link #mPackages} is used to guard all in-memory parsed package details
 * and other related state. It is a fine-grained lock that should only be held
 * momentarily, as it's one of the most contended locks in the system.
 * <li>{@link #mInstallLock} is used to guard all {@code installd} access, whose
 * operations typically involve heavy lifting of application data on disk. Since
 * {@code installd} is single-threaded, and it's operations can often be slow,
 * this lock should never be acquired while already holding {@link #mPackages}.
 * Conversely, it's safe to acquire {@link #mPackages} momentarily while already
 * holding {@link #mInstallLock}.
 * </ul>
 * Many internal methods rely on the caller to hold the appropriate locks, and
 * this contract is expressed through method name suffixes:
 * <ul>
 * <li>fooLI(): the caller must hold {@link #mInstallLock}
 * <li>fooLIF(): the caller must hold {@link #mInstallLock} and the package
 * being modified must be frozen
 * <li>fooLPr(): the caller must hold {@link #mPackages} for reading
 * <li>fooLPw(): the caller must hold {@link #mPackages} for writing
 * </ul>
 * <p>
 * Because this class is very central to the platform's security; please run all
 * CTS and unit tests whenever making modifications:
 *
 * <pre>
 * $ runtest -c android.content.pm.PackageManagerTests frameworks-core
 * $ cts-tradefed run commandAndExit cts -m CtsAppSecurityHostTestCases
 * </pre>
 */

mPackages同步锁，是指操作mPackages时，用synchronized (mPackages) {}保护起来。mPackages同步锁用来保护内存中已经解析的包信息和其他相关状态。mPackages同步锁是细粒度的锁，只能短时间持有这个锁，因为争抢mPackages锁的请求很多，短时间持有mPackages锁，可以让其他请求等待的时间短些。

mInstallLock同步锁，是指安装App的时候，对安装的处理要用synchronized (mInstaller) {}保护起来。mInstallLock同步锁，用来保护所有对installd的访问。installd通常包含对应用数据的繁重操作。

由于installd是单线程的，并且installd的操作通常很慢，所以在已经持有mPackages同步锁的时候，千万不要再请求mInstallLock同步锁。反之，在已经持有mInstallLock同步锁的时候，可以去请求mPackages同步锁。

PKMS中的很多方法带有LI、LIF、LPw、LPr等后缀，LI、LIF、LPw、LPr中的L，指的是Lock，而后面跟的I和P指的是两个锁，I表示mInstallLock同步锁。P表示mPackages同步锁。LPw、LPr中的w表示writing，r表示reading。LIF中的F表示Freeze。

该部分也可参考https://blog.csdn.net/u013553529/article/details/61962439。

1. PKMS启动过程

PKMS和其它系统服务一样是在SystemServer中启动的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 /**
   * Starts the small tangle of critical services that are needed to get
   * the system off the ground.  These services have complex mutual dependencies
   * which is why we initialize them all in one place here.  Unless your service
   * is also entwined in these dependencies, it should be initialized in one of
   * the other functions.
   */
  private void startBootstrapServices() {//Bootstrap：引导，启动引导服务
//……
      // Wait for installd to finish starting up so that it has a chance to
      // create critical directories such as /data/user with the appropriate
      // permissions.  We need this to complete before we initialize other services.
      traceBeginAndSlog("StartInstaller");
      Installer installer = mSystemServiceManager.startService(Installer.class);
      traceEnd();
      //……
      // Only run "core" apps if we're encrypting the device.
      String cryptState = SystemProperties.get("vold.decrypt");
      if (ENCRYPTING_STATE.equals(cryptState)) {
          Slog.w(TAG, "Detected encryption in progress - only parsing core apps");
          mOnlyCore = true;
      } else if (ENCRYPTED_STATE.equals(cryptState)) {
          Slog.w(TAG, "Device encrypted - only parsing core apps");
          mOnlyCore = true;
      }

      // Start the package manager.
      if (!mRuntimeRestart) {
          MetricsLogger.histogram(null, "boot_package_manager_init_start",
                  (int) SystemClock.elapsedRealtime());
      }
    
    
      traceBeginAndSlog("StartPackageManagerService");
      mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
              mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
      mFirstBoot = mPackageManagerService.isFirstBoot();
      mPackageManager = mSystemContext.getPackageManager();
      traceEnd();
      //……
  }

startBootstrapServices中启动的是系统中最关键的一批服务，所以也是在SystemServer中最先启动的一批服务。

SystemServer通过调用PKSM的main方法创建并启动PKMS服务。

1
2
3
4
5
6
7
8
9
10
11
12
13
public static PackageManagerService main(Context context, Installer installer,
        boolean factoryTest, boolean onlyCore) {
    // Self-check for initial settings.
    PackageManagerServiceCompilerMapping.checkProperties();

    PackageManagerService m = new PackageManagerService(context, installer,
            factoryTest, onlyCore);
    m.enableSystemUserPackages();
    ServiceManager.addService("package", m);
    final PackageManagerNative pmn = m.new PackageManagerNative();
    ServiceManager.addService("package_native", pmn);
    return m;
}

首先是PKMS的初始化过程：PackageManagerService m = new PackageManagerService(context, installer, factoryTest, onlyCore);。

1.1 PKMS构造过程

Android系统提供了一种诊断工具来记录系统级的事件，该工具就是EventLog。PKMS的创建过程也通过EventLog进行了记录。根据EventLog来看，PKMS的创建可以分为5个阶段：

1
2
3
4
5
>BOOT_PROGRESS_PMS_START
>BOOT_PROGRESS_PMS_SYSTEM_SCAN_START
>BOOT_PROGRESS_PMS_DATA_SCAN_START
>BOOT_PROGRESS_PMS_SCAN_END
>BOOT_PROGRESS_PMS_READY

阶段1：BOOT_PROGRESS_PMS_START

该阶段代码如下，其中成员初始化的部分代码省略掉了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
    EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_START,
            SystemClock.uptimeMillis());
 // ……
   //构造Settings对象存储运行时的设置信息
    mSettings = new Settings(mPackages);
//添加系统的shareUID
    mSettings.addSharedUserLPw("android.uid.system", Process.SYSTEM_UID,
            ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
    mSettings.addSharedUserLPw("android.uid.phone", RADIO_UID,
            ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
    mSettings.addSharedUserLPw("android.uid.log", LOG_UID,
            ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
    mSettings.addSharedUserLPw("android.uid.nfc", NFC_UID,
            ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
    mSettings.addSharedUserLPw("android.uid.bluetooth", BLUETOOTH_UID,
            ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
    mSettings.addSharedUserLPw("android.uid.shell", SHELL_UID,
            ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
    //……
    SystemConfig systemConfig = SystemConfig.getInstance();
 //……

    synchronized (mInstallLock) {
    // writer
    synchronized (mPackages) {
		//……
        // 添加内置权限配置到mSettings
        // Propagate permission configuration in to package manager.
        ArrayMap<String, SystemConfig.PermissionEntry> permConfig
                = systemConfig.getPermissions();
        for (int i=0; i<permConfig.size(); i++) {
            SystemConfig.PermissionEntry perm = permConfig.valueAt(i);
            BasePermission bp = mSettings.mPermissions.get(perm.name);
            if (bp == null) {//android（framework-res.apk）这个应用拥有所有权限？
                bp = new BasePermission(perm.name, "android", BasePermission.TYPE_BUILTIN);
                mSettings.mPermissions.put(perm.name, bp);
            }
            if (perm.gids != null) {
                bp.setGids(perm.gids, perm.perUser);
            }
        }
        //获取SharedLibraries信息
        ArrayMap<String, String> libConfig = systemConfig.getSharedLibraries();
        final int builtInLibCount = libConfig.size();
        for (int i = 0; i < builtInLibCount; i++) {
            String name = libConfig.keyAt(i);
            String path = libConfig.valueAt(i);
            addSharedLibraryLPw(path, null, name, SharedLibraryInfo.VERSION_UNDEFINED,
                    SharedLibraryInfo.TYPE_BUILTIN, PLATFORM_PACKAGE_NAME, 0);
        }
        mFoundPolicyFile = SELinuxMMAC.readInstallPolicy();

        Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "read user settings");
        //尝试读取packages.xml内容，读取不到或者读取失败则判定为首次启动
        mFirstBoot = !mSettings.readLPw(sUserManager.getUsers(false));
        Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
        // Clean up orphaned packages for which the code path doesn't exist
        // and they are an update to a system app - caused by bug/32321269
        //第一次启动时还没有生成packages.xml所以packageSettingCount为0
        final int packageSettingCount = mSettings.mPackages.size();
        for (int i = packageSettingCount - 1; i >= 0; i--) {
            PackageSetting ps = mSettings.mPackages.valueAt(i);
            if (!isExternal(ps) && (ps.codePath == null || !ps.codePath.exists())
                    && mSettings.getDisabledSystemPkgLPr(ps.name) != null) {
                mSettings.mPackages.removeAt(i);
                mSettings.enableSystemPackageLPw(ps.name);
            }
        }
        //等到dex文件拷贝完成，实际copy是在/system/extras/cppreopts/cppreopts.rc进行的
        if (mFirstBoot) {
            requestCopyPreoptedFiles();
        }
   //自定义的Intent resolver         
        String customResolverActivity = Resources.getSystem().getString(
                R.string.config_customResolverActivity);
        if (TextUtils.isEmpty(customResolverActivity)) {
            customResolverActivity = null;
        } else {
            mCustomResolverComponentName = ComponentName.unflattenFromString(
                    customResolverActivity);
        }

第一阶段前半部分没加锁，后半部分是在加锁的代码块里的。总的来说第一阶段主要做了这几件事：初始化成员变量、添加系统SharedUID信息到mSettings、加载权限信息、获取SharedLibraries信息以及清除找不到的package信息。

关键的变量有两个：

1
2
mSettings = new Settings(mPackages);//对应packages.xml文件
SystemConfig systemConfig = SystemConfig.getInstance();

先来看下Setting的构造过程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Settings(Object lock) {
    this(Environment.getDataDirectory(), lock);
}

Settings(File dataDir, Object lock) {
    mLock = lock;

    mRuntimePermissionsPersistence = new RuntimePermissionPersistence(mLock);

    mSystemDir = new File(dataDir, "system");
    mSystemDir.mkdirs();
    FileUtils.setPermissions(mSystemDir.toString(),
            FileUtils.S_IRWXU|FileUtils.S_IRWXG
            |FileUtils.S_IROTH|FileUtils.S_IXOTH,
            -1, -1);
    mSettingsFilename = new File(mSystemDir, "packages.xml");
    mBackupSettingsFilename = new File(mSystemDir, "packages-backup.xml");
    mPackageListFilename = new File(mSystemDir, "packages.list");
    FileUtils.setPermissions(mPackageListFilename, 0640, SYSTEM_UID, PACKAGE_INFO_GID);

    final File kernelDir = new File("/config/sdcardfs");
    mKernelMappingFilename = kernelDir.exists() ? kernelDir : null;

    // Deprecated: Needed for migration
    mStoppedPackagesFilename = new File(mSystemDir, "packages-stopped.xml");
    mBackupStoppedPackagesFilename = new File(mSystemDir, "packages-stopped-backup.xml");
}

主要是指定Settings相关的文件路径。Settings中保存了package的相关信息，包括应用本身信息和AndroidManifest.xml中的信息。Settings中保存了各个包的PackageSetting信息，PackageSetting继承自PackageSettingBase，PackageSettingBase又继承自SettingBase，PackageSetting中保存了一个PackageParser.Package的引用（保存从apk中解析出的信息），而该Package对象由持有一个ApplicationInfo对象（对应于AndroidManifest.xml中的application标签）的引用。

再来看下SettingConfig的创建过程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 public static SystemConfig getInstance() {
     synchronized (SystemConfig.class) {
         if (sInstance == null) {
             sInstance = new SystemConfig();
         }
         return sInstance;
     }
 }
SystemConfig() {
     // Read configuration from system
     readPermissions(Environment.buildPath(
             Environment.getRootDirectory(), "etc", "sysconfig"), ALLOW_ALL);
     // Read configuration from the old permissions dir
     readPermissions(Environment.buildPath(
             Environment.getRootDirectory(), "etc", "permissions"), ALLOW_ALL);
     // Allow Vendor to customize system configs around libs, features, permissions and apps
     int vendorPermissionFlag = ALLOW_LIBS | ALLOW_FEATURES | ALLOW_PERMISSIONS |
             ALLOW_APP_CONFIGS;
     readPermissions(Environment.buildPath(
             Environment.getVendorDirectory(), "etc", "sysconfig"), vendorPermissionFlag);
     readPermissions(Environment.buildPath(
             Environment.getVendorDirectory(), "etc", "permissions"), vendorPermissionFlag);
     // Allow ODM to customize system configs around libs, features and apps
     int odmPermissionFlag = ALLOW_LIBS | ALLOW_FEATURES | ALLOW_APP_CONFIGS;
     readPermissions(Environment.buildPath(
             Environment.getOdmDirectory(), "etc", "sysconfig"), odmPermissionFlag);
     readPermissions(Environment.buildPath(
             Environment.getOdmDirectory(), "etc", "permissions"), odmPermissionFlag);
     // Only allow OEM to customize features
     readPermissions(Environment.buildPath(
             Environment.getOemDirectory(), "etc", "sysconfig"), ALLOW_FEATURES);
     readPermissions(Environment.buildPath(
             Environment.getOemDirectory(), "etc", "permissions"), ALLOW_FEATURES);
 }

readPermissions()解析指定目录下的所有xml文件，所以，SystemConfig创建过程是对以下这六个目录中的所有xml进行解析来完成的。

/system/etc/sysconfig
/system/etc/permissions
/vendor/etc/sysconfig
/vendor/etc/permissions
/oem/etc/sysconfig
/oem/etc/permissions

权限分两类，存储在两个不同的变量中，final SparseArray<ArraySet<String>> mSystemPermissions表示系统权限，是一个uid到权限的映射，final ArrayMap<String, PermissionEntry> mPermissions = new ArrayMap<>();gid到权限的映射。系统权限在文件中的attribute为assign-permission，比如：

1
2
3
4
5
6
platform.xml
144:    <assign-permission name="android.permission.MODIFY_AUDIO_SETTINGS" uid="media" />
151:    <assign-permission name="android.permission.MODIFY_AUDIO_SETTINGS" uid="audioserver" />
170:    <assign-permission name="android.permission.PACKAGE_USAGE_STATS" uid="incidentd" />
172:    <assign-permission name="android.permission.ACCESS_LOWPAN_STATE" uid="lowpan" />
177:    <assign-permission name="android.permission.STATSCOMPANION" uid="statsd" />

mPermissions在xml中对应的attribute为permissions：

1
2
3
4
5
6
7
<permission name="android.permission.INTERNET" >
    <group gid="inet" />
</permission>

<permission name="android.permission.READ_LOGS" >
    <group gid="log" />
</permission>

阶段2：BOOT_PROGRESS_PMS_SYSTEM_SCAN_START

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
      long startTime = SystemClock.uptimeMillis();
      EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SYSTEM_SCAN_START,
              startTime);

      final String bootClassPath = System.getenv("BOOTCLASSPATH");
      final String systemServerClassPath = System.getenv("SYSTEMSERVERCLASSPATH");
      //……
      //system/framework/
      File frameworkDir = new File(Environment.getRootDirectory(), "framework");

      final VersionInfo ver = mSettings.getInternalVersion();
      mIsUpgrade = !Build.FINGERPRINT.equals(ver.fingerprint);
      //……
      // Set flag to monitor and not change apk file paths when
      // scanning install directories.
      int scanFlags = SCAN_BOOTING | SCAN_INITIAL;

      if (mIsUpgrade || mFirstBoot) {
          scanFlags = scanFlags | SCAN_FIRST_BOOT_OR_UPGRADE;
      }

      // Collect vendor overlay packages. (Do this before scanning any apps.)
      // For security and version matching reason, only consider
      // overlay packages if they reside in the right directory.
      scanDirTracedLI(new File(VENDOR_OVERLAY_DIR), mDefParseFlags
              | PackageParser.PARSE_IS_SYSTEM
              | PackageParser.PARSE_IS_SYSTEM_DIR
              | PackageParser.PARSE_TRUSTED_OVERLAY, scanFlags | SCAN_TRUSTED_OVERLAY, 0);

      mParallelPackageParserCallback.findStaticOverlayPackages();

      // Find base frameworks (resource packages without code).
      scanDirTracedLI(frameworkDir, mDefParseFlags
              | PackageParser.PARSE_IS_SYSTEM
              | PackageParser.PARSE_IS_SYSTEM_DIR
              | PackageParser.PARSE_IS_PRIVILEGED,
              scanFlags | SCAN_NO_DEX, 0);

      // Collected privileged system packages.
      final File privilegedAppDir = new File(Environment.getRootDirectory(), "priv-app");
      scanDirTracedLI(privilegedAppDir, mDefParseFlags
              | PackageParser.PARSE_IS_SYSTEM
              | PackageParser.PARSE_IS_SYSTEM_DIR
              | PackageParser.PARSE_IS_PRIVILEGED, scanFlags, 0);

      // Collect ordinary system packages.
      final File systemAppDir = new File(Environment.getRootDirectory(), "app");
      scanDirTracedLI(systemAppDir, mDefParseFlags
              | PackageParser.PARSE_IS_SYSTEM
              | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags, 0);

      // Collect all vendor packages.
      File vendorAppDir = new File("/vendor/app");
      try {
          vendorAppDir = vendorAppDir.getCanonicalFile();
      } catch (IOException e) {
          // failed to look up canonical path, continue with original one
      }
      scanDirTracedLI(vendorAppDir, mDefParseFlags
              | PackageParser.PARSE_IS_SYSTEM
              | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags, 0);

      // Collect all OEM packages.
      final File oemAppDir = new File(Environment.getOemDirectory(), "app");
      scanDirTracedLI(oemAppDir, mDefParseFlags
              | PackageParser.PARSE_IS_SYSTEM
              | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags, 0);

      // Prune any system packages that no longer exist.
      final List<String> possiblyDeletedUpdatedSystemApps = new ArrayList<>();
      // Stub packages must either be replaced with full versions in the /data
      // partition or be disabled.
      final List<String> stubSystemApps = new ArrayList<>();
      if (!mOnlyCore) {
          // do this first before mucking with mPackages for the "expecting better" case
          final Iterator<PackageParser.Package> pkgIterator = mPackages.values().iterator();
          while (pkgIterator.hasNext()) {
              final PackageParser.Package pkg = pkgIterator.next();
              if (pkg.isStub) {
                  stubSystemApps.add(pkg.packageName);
              }
          }

          final Iterator<PackageSetting> psit = mSettings.mPackages.values().iterator();
          while (psit.hasNext()) {
              PackageSetting ps = psit.next();

              /*
               * If this is not a system app, it can't be a
               * disable system app.OTA的升级只涉及到系统app。
               */
              if ((ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) == 0) {
                  continue;
              }

              /*
               * If the package is scanned, it's not erased.
               */
              final PackageParser.Package scannedPkg = mPackages.get(ps.name);
              if (scannedPkg != null) {
                  /*
                   * If the system app is both scanned and in the
                   * disabled packages list, then it must have been
                   * added via OTA. Remove it from the currently
                   * scanned package so the previously user-installed
                   * application can be scanned.
                   */
                  if (mSettings.isDisabledSystemPackageLPr(ps.name)) {
                      removePackageLI(scannedPkg, true);
                      mExpectingBetter.put(ps.name, ps.codePath);
                  }
                  continue;
              }

              if (!mSettings.isDisabledSystemPackageLPr(ps.name)) {
                  psit.remove();
                  logCriticalInfo(Log.WARN, "System package " + ps.name
                          + " no longer exists; it's data will be wiped");
                  // Actual deletion of code and data will be handled by later
                  // reconciliation step
              } else {
                  // we still have a disabled system package, but, it still might have
                  // been removed. check the code path still exists and check there's
                  // still a package. the latter can happen if an OTA keeps the same
                  // code path, but, changes the package name.
                  final PackageSetting disabledPs =
                          mSettings.getDisabledSystemPkgLPr(ps.name);
                  if (disabledPs.codePath == null || !disabledPs.codePath.exists()
                          || disabledPs.pkg == null) {
                      possiblyDeletedUpdatedSystemApps.add(ps.name);
                  }
              }
          }
      }

      //look for any incomplete package installations
//删除未完成安装的package
      ArrayList<PackageSetting> deletePkgsList = mSettings.getListOfIncompleteInstallPackagesLPr();
      for (int i = 0; i < deletePkgsList.size(); i++) {
          // Actual deletion of code and data will be handled by later
          // reconciliation step
          final String packageName = deletePkgsList.get(i).name;
          logCriticalInfo(Log.WARN, "Cleaning up incompletely installed app: " + packageName);
          synchronized (mPackages) {
              mSettings.removePackageLPw(packageName);
          }
      }

      //delete tmp files
      deleteTempPackageFiles();

      final int cachedSystemApps = PackageParser.sCachedPackageReadCount.get();

      // Remove any shared userIDs that have no associated packages
      mSettings.pruneSharedUsersLPw();

环境变量: 那可通过adb shell env来查看系统所有的环境变量及相应值。也可通过命令adb shell echo $SYSTEMSERVERCLASSPATH。

SYSTEMSERVERCLASSPATH：主要包括/system/framework目录下services.jar，ethernet-service.jar，wifi-service.jar这3个文件。
BOOTCLASSPATH：该环境变量内容较多，不同ROM可能有所不同，常见内容包含/system/framework目录下的framework.jar，ext.jar，core-libart.jar，telephony-common.jar，ims-common.jar，core-junit.jar等文件。

scanDirLI(): 扫描指定目录下的apk文件，最终调用PackageParser.parseBaseApk来完成AndroidManifest.xml文件的解析，生成Application, activity,service,broadcast, provider等信息。
/vendor/overlay
/system/framework
/system/priv-app
/system/app
/vendor/priv-app
/vendor/app
/oem/app

该部分代码的细节暂不了解，以后有需要了再专门了解。

阶段3： BOOT_PROGRESS_PMS_DATA_SCAN_START

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
      if (!mOnlyCore) {
          EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_DATA_SCAN_START,
                  SystemClock.uptimeMillis());
          // /data/app/
          scanDirTracedLI(mAppInstallDir, 0, scanFlags | SCAN_REQUIRE_KNOWN, 0);
// /data/app-private/
          scanDirTracedLI(mDrmAppPrivateInstallDir, mDefParseFlags
                  | PackageParser.PARSE_FORWARD_LOCK,
                  scanFlags | SCAN_REQUIRE_KNOWN, 0);

          // Remove disable package settings for updated system apps that were
          // removed via an OTA. If the update is no longer present, remove the
          // app completely. Otherwise, revoke their system privileges.
          for (String deletedAppName : possiblyDeletedUpdatedSystemApps) {
              PackageParser.Package deletedPkg = mPackages.get(deletedAppName);
              mSettings.removeDisabledSystemPackageLPw(deletedAppName);

              final String msg;
              if (deletedPkg == null) {
                  // should have found an update, but, we didn't; remove everything
                  msg = "Updated system package " + deletedAppName
                          + " no longer exists; removing its data";
                  // Actual deletion of code and data will be handled by later
                  // reconciliation step
              } else {
                  // found an update; revoke system privileges
                  msg = "Updated system package + " + deletedAppName
                          + " no longer exists; revoking system privileges";

                  // Don't do anything if a stub is removed from the system image. If
                  // we were to remove the uncompressed version from the /data partition,
                  // this is where it'd be done.

                  final PackageSetting deletedPs = mSettings.mPackages.get(deletedAppName);
                  deletedPkg.applicationInfo.flags &= ~ApplicationInfo.FLAG_SYSTEM;
                  deletedPs.pkgFlags &= ~ApplicationInfo.FLAG_SYSTEM;
              }
              logCriticalInfo(Log.WARN, msg);
          }

          /*
           * Make sure all system apps that we expected to appear on
           * the userdata partition actually showed up. If they never
           * appeared, crawl back and revive the system version.
           */
          for (int i = 0; i < mExpectingBetter.size(); i++) {
              final String packageName = mExpectingBetter.keyAt(i);
              if (!mPackages.containsKey(packageName)) {
                  final File scanFile = mExpectingBetter.valueAt(i);

                  logCriticalInfo(Log.WARN, "Expected better " + packageName
                          + " but never showed up; reverting to system");

                  int reparseFlags = mDefParseFlags;
                  if (FileUtils.contains(privilegedAppDir, scanFile)) {
                      reparseFlags = PackageParser.PARSE_IS_SYSTEM
                              | PackageParser.PARSE_IS_SYSTEM_DIR
                              | PackageParser.PARSE_IS_PRIVILEGED;
                  } else if (FileUtils.contains(systemAppDir, scanFile)) {
                      reparseFlags = PackageParser.PARSE_IS_SYSTEM
                              | PackageParser.PARSE_IS_SYSTEM_DIR;
                  } else if (FileUtils.contains(vendorAppDir, scanFile)) {
                      reparseFlags = PackageParser.PARSE_IS_SYSTEM
                              | PackageParser.PARSE_IS_SYSTEM_DIR;
                  } else if (FileUtils.contains(oemAppDir, scanFile)) {
                      reparseFlags = PackageParser.PARSE_IS_SYSTEM
                              | PackageParser.PARSE_IS_SYSTEM_DIR;
                  } else {
                      Slog.e(TAG, "Ignoring unexpected fallback path " + scanFile);
                      continue;
                  }

                  mSettings.enableSystemPackageLPw(packageName);

                  try {
                      scanPackageTracedLI(scanFile, reparseFlags, scanFlags, 0, null);
                  } catch (PackageManagerException e) {
                      Slog.e(TAG, "Failed to parse original system package: "
                              + e.getMessage());
                  }
              }
          }

          // Uncompress and install any stubbed system applications.
          // This must be done last to ensure all stubs are replaced or disabled.
          decompressSystemApplications(stubSystemApps, scanFlags);

          final int cachedNonSystemApps = PackageParser.sCachedPackageReadCount.get()
                          - cachedSystemApps;

          final long dataScanTime = SystemClock.uptimeMillis() - systemScanTime - startTime;
          final int dataPackagesCount = mPackages.size() - systemPackagesCount;
          Slog.i(TAG, "Finished scanning non-system apps. Time: " + dataScanTime
                  + " ms, packageCount: " + dataPackagesCount
                  + " , timePerPackage: "
                  + (dataPackagesCount == 0 ? 0 : dataScanTime / dataPackagesCount)
                  + " , cached: " + cachedNonSystemApps);
          if (mIsUpgrade && dataPackagesCount > 0) {
              MetricsLogger.histogram(null, "ota_package_manager_data_app_avg_scan_time",
                      ((int) dataScanTime) / dataPackagesCount);
          }
      }
      mExpectingBetter.clear();

      // Resolve the storage manager.
      mStorageManagerPackage = getStorageManagerPackageName();

      // Resolve protected action filters. Only the setup wizard is allowed to
      // have a high priority filter for these actions.
      mSetupWizardPackage = getSetupWizardPackageName();
      if (mProtectedFilters.size() > 0) {
          if (DEBUG_FILTERS && mSetupWizardPackage == null) {
              Slog.i(TAG, "No setup wizard;"
                  + " All protected intents capped to priority 0");
          }
          for (ActivityIntentInfo filter : mProtectedFilters) {
              if (filter.activity.info.packageName.equals(mSetupWizardPackage)) {
                  if (DEBUG_FILTERS) {
                      Slog.i(TAG, "Found setup wizard;"
                          + " allow priority " + filter.getPriority() + ";"
                          + " package: " + filter.activity.info.packageName
                          + " activity: " + filter.activity.className
                          + " priority: " + filter.getPriority());
                  }
                  // skip setup wizard; allow it to keep the high priority filter
                  continue;
              }
              if (DEBUG_FILTERS) {
                  Slog.i(TAG, "Protected action; cap priority to 0;"
                          + " package: " + filter.activity.info.packageName
                          + " activity: " + filter.activity.className
                          + " origPrio: " + filter.getPriority());
              }
              filter.setPriority(0);
          }
      }
      mDeferProtectedFilters = false;
      mProtectedFilters.clear();

      // Now that we know all of the shared libraries, update all clients to have
      // the correct library paths.
      updateAllSharedLibrariesLPw(null);

      for (SharedUserSetting setting : mSettings.getAllSharedUsersLPw()) {
          // NOTE: We ignore potential failures here during a system scan (like
          // the rest of the commands above) because there's precious little we
          // can do about it. A settings error is reported, though.
          adjustCpuAbisForSharedUserLPw(setting.packages, null /*scannedPackage*/);
      }

      // Now that we know all the packages we are keeping,
      // read and update their last usage times.
      mPackageUsage.read(mPackages);
      mCompilerStats.read();

当mOnlyCore = false时，则scanDirLI()还会收集如下目录中的apk：
/data/app
/data/app-private：DRM保护的APK文件

阶段4：BOOT_PROGRESS_PMS_SCAN_END

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SCAN_END,
                    SystemClock.uptimeMillis());
            Slog.i(TAG, "Time to scan packages: "
                    + ((SystemClock.uptimeMillis()-startTime)/1000f)
                    + " seconds");

            // If the platform SDK has changed since the last time we booted,
            // we need to re-grant app permission to catch any new ones that
            // appear.  This is really a hack, and means that apps can in some
            // cases get permissions that the user didn't initially explicitly
            // allow...  it would be nice to have some better way to handle
            // this situation.
            int updateFlags = UPDATE_PERMISSIONS_ALL;
            if (ver.sdkVersion != mSdkVersion) {
                Slog.i(TAG, "Platform changed from " + ver.sdkVersion + " to "
                        + mSdkVersion + "; regranting permissions for internal storage");
                updateFlags |= UPDATE_PERMISSIONS_REPLACE_PKG | UPDATE_PERMISSIONS_REPLACE_ALL;
            }
            //当sdk版本不一致时，,更新相关信息，并给需要使用权限的apk分配相应的权限
            updatePermissionsLPw(null, null, StorageManager.UUID_PRIVATE_INTERNAL, updateFlags);
            ver.sdkVersion = mSdkVersion;

            // If this is the first boot or an update from pre-M, and it is a normal
            // boot, then we need to initialize the default preferred apps across
            // all defined users.
            //当这是ota后的首次启动，正常启动则需要清除目录的缓存代码
            if (!onlyCore && (mPromoteSystemApps || !mRestoredSettings)) {
                for (UserInfo user : sUserManager.getUsers(true)) {
                    mSettings.applyDefaultPreferredAppsLPw(this, user.id);
                    applyFactoryDefaultBrowserLPw(user.id);
                    primeDomainVerificationsLPw(user.id);
                }
            }

            // Prepare storage for system user really early during boot,
            // since core system apps like SettingsProvider and SystemUI
            // can't wait for user to start
            final int storageFlags;
            if (StorageManager.isFileEncryptedNativeOrEmulated()) {
                storageFlags = StorageManager.FLAG_STORAGE_DE;
            } else {
                storageFlags = StorageManager.FLAG_STORAGE_DE | StorageManager.FLAG_STORAGE_CE;
            }
            reconcileAppsDataLI(StorageManager.UUID_PRIVATE_INTERNAL, UserHandle.USER_SYSTEM,
                    storageFlags);

            // If this is first boot after an OTA, and a normal boot, then
            // we need to clear code cache directories.
            // Note that we do *not* clear the application profiles. These remain valid
            // across OTAs and are used to drive profile verification (post OTA) and
            // profile compilation (without waiting to collect a fresh set of profiles).
            if (mIsUpgrade && !onlyCore) {
                Slog.i(TAG, "Build fingerprint changed; clearing code caches");
                for (int i = 0; i < mSettings.mPackages.size(); i++) {
                    final PackageSetting ps = mSettings.mPackages.valueAt(i);
                    if (Objects.equals(StorageManager.UUID_PRIVATE_INTERNAL, ps.volumeUuid)) {
                        // No apps are running this early, so no need to freeze
                        clearAppDataLIF(ps.pkg, UserHandle.USER_ALL,
                                StorageManager.FLAG_STORAGE_DE | StorageManager.FLAG_STORAGE_CE
                                        | Installer.FLAG_CLEAR_CODE_CACHE_ONLY);
                    }
                }
                ver.fingerprint = Build.FINGERPRINT;
            }

            checkDefaultBrowser();

            // clear only after permissions and other defaults have been updated
            //当权限和其他默认项都完成更新，则清理相关信息
            mExistingSystemPackages.clear();
            mPromoteSystemApps = false;

            // All the changes are done during package scanning.
            ver.databaseVersion = Settings.CURRENT_DATABASE_VERSION;

            // can downgrade to reader
            //信息写回packages.xml文件
            mSettings.writeLPr();

            // Perform dexopt on all apps that mark themselves as coreApps. We do this pretty
            // early on (before the package manager declares itself as early) because other
            // components in the system server might ask for package contexts for these apps.
            //
            // Note that "onlyCore" in this context means the system is encrypted or encrypting
            // (i.e, that the data partition is unavailable).
            if ((isFirstBoot() || isUpgrade() || VMRuntime.didPruneDalvikCache()) && !onlyCore) {
                long start = System.nanoTime();
                List<PackageParser.Package> coreApps = new ArrayList<>();
                for (PackageParser.Package pkg : mPackages.values()) {
                    if (pkg.coreApp) {
                        coreApps.add(pkg);
                    }
                }

                int[] stats = performDexOpt(coreApps, false,
                        getCompilerFilterForReason(REASON_CORE_APP));

                final int elapsedTimeSeconds =
                        (int) TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - start);
                MetricsLogger.histogram(mContext, "opt_coreapps_time_s", elapsedTimeSeconds);

                if (DEBUG_DEXOPT) {
                    Slog.i(TAG, "Dex-opt core apps took : " + elapsedTimeSeconds + " seconds (" +
                            stats[0] + ", " + stats[1] + ", " + stats[2] + ")");
                }
            }

阶段5：BOOT_PROGRESS_PMS_READY

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_READY,
                    SystemClock.uptimeMillis());

            if (!mOnlyCore) {
                mRequiredVerifierPackage = getRequiredButNotReallyRequiredVerifierLPr();
                mRequiredInstallerPackage = getRequiredInstallerLPr();
                mIntentFilterVerifierComponent = getIntentFilterVerifierComponentNameLPr();
                mIntentFilterVerifier = new IntentVerifierProxy(mContext,
                        mIntentFilterVerifierComponent);
                mServicesSystemSharedLibraryPackageName = getRequiredSharedLibraryLPr(
                        PackageManager.SYSTEM_SHARED_LIBRARY_SERVICES);
                mSharedSystemSharedLibraryPackageName = getRequiredSharedLibraryLPr(
                        PackageManager.SYSTEM_SHARED_LIBRARY_SHARED);
            } else {
                mRequiredVerifierPackage = null;
                mRequiredInstallerPackage = null;
                mIntentFilterVerifierComponent = null;
                mIntentFilterVerifier = null;
                mServicesSystemSharedLibraryPackageName = null;
                mSharedSystemSharedLibraryPackageName = null;
            }

            mInstallerService = new PackageInstallerService(context, this);

            final ComponentName ephemeralResolverComponent = getEphemeralResolverLPr();
            final ComponentName ephemeralInstallerComponent = getEphemeralInstallerLPr();
            // both the installer and resolver must be present to enable ephemeral
            if (ephemeralInstallerComponent != null && ephemeralResolverComponent != null) {
                if (DEBUG_EPHEMERAL) {
                    Slog.i(TAG, "Ephemeral activated; resolver: " + ephemeralResolverComponent
                            + " installer:" + ephemeralInstallerComponent);
                }
                mEphemeralResolverComponent = ephemeralResolverComponent;
                mEphemeralInstallerComponent = ephemeralInstallerComponent;
                setUpEphemeralInstallerActivityLP(mEphemeralInstallerComponent);
                mEphemeralResolverConnection =
                        new EphemeralResolverConnection(mContext, mEphemeralResolverComponent);
            } else {
                if (DEBUG_EPHEMERAL) {
                    final String missingComponent =
                            (ephemeralResolverComponent == null)
                            ? (ephemeralInstallerComponent == null)
                                    ? "resolver and installer"
                                    : "resolver"
                            : "installer";
                    Slog.i(TAG, "Ephemeral deactivated; missing " + missingComponent);
                }
                mEphemeralResolverComponent = null;
                mEphemeralInstallerComponent = null;
                mEphemeralResolverConnection = null;
            }

            mEphemeralApplicationRegistry = new EphemeralApplicationRegistry(this);
        } // synchronized (mPackages)
        } // synchronized (mInstallLock)

        // Now after opening every single application zip, make sure they
        // are all flushed.  Not really needed, but keeps things nice and
        // tidy.
        Runtime.getRuntime().gc();

        // The initial scanning above does many calls into installd while
        // holding the mPackages lock, but we're mostly interested in yelling
        // once we have a booted system.
        mInstaller.setWarnIfHeld(mPackages);

        // Expose private service for system components to use.
        LocalServices.addService(PackageManagerInternal.class, new PackageManagerInternalImpl());

创建PackageInstallerService服务。

PKMS初始化过程，分为5个阶段：
PMS_START阶段：
创建Settings对象；
将6类shareUserId到mSettings；
初始化SystemConfig；
创建名为“PackageManager”的handler线程mHandlerThread;
创建UserManagerService多用户管理服务；
通过解析4大目录中的xmL文件构造共享mSharedLibraries；
PMS_SYSTEM_SCAN_START阶段：
扫描系统apk;
PMS_DATA_SCAN_START阶段：
扫描/data/app目录下的apk;
扫描/data/app-private目录下的apk;
PMS_SCAN_END阶段：
将上述信息写回/data/system/packages.xml;
PMS_READY阶段：
创建服务PackageInstallerService；

回到PKMS的main方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
public static PackageManagerService main(Context context, Installer installer,
         boolean factoryTest, boolean onlyCore) {
     // Self-check for initial settings.
     PackageManagerServiceCompilerMapping.checkProperties();

     PackageManagerService m = new PackageManagerService(context, installer,
             factoryTest, onlyCore);
     m.enableSystemUserPackages();
     ServiceManager.addService("package", m);
     final PackageManagerNative pmn = m.new PackageManagerNative();
     ServiceManager.addService("package_native", pmn);
     return m;
 }

PKSM初始化后会将服务添加到ServiceManager中。之后在SystemServer的startOtherServices()方法中会调用PKSM的systemReady()方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
@Override
public void systemReady() {
    enforceSystemOrRoot("Only the system can claim the system is ready");

    mSystemReady = true;
    final ContentResolver resolver = mContext.getContentResolver();
    ContentObserver co = new ContentObserver(mHandler) {
        @Override
        public void onChange(boolean selfChange) {
            mEphemeralAppsDisabled =
                    (Global.getInt(resolver, Global.ENABLE_EPHEMERAL_FEATURE, 1) == 0) ||
                            (Secure.getInt(resolver, Secure.INSTANT_APPS_ENABLED, 1) == 0);
        }
    };
    mContext.getContentResolver().registerContentObserver(android.provider.Settings.Global
                    .getUriFor(Global.ENABLE_EPHEMERAL_FEATURE),
            false, co, UserHandle.USER_SYSTEM);
    mContext.getContentResolver().registerContentObserver(android.provider.Settings.Global
                    .getUriFor(Secure.INSTANT_APPS_ENABLED), false, co, UserHandle.USER_SYSTEM);
    co.onChange(true);

    // Disable any carrier apps. We do this very early in boot to prevent the apps from being
    // disabled after already being started.
    CarrierAppUtils.disableCarrierAppsUntilPrivileged(mContext.getOpPackageName(), this,
            mContext.getContentResolver(), UserHandle.USER_SYSTEM);

    // Read the compatibilty setting when the system is ready.
    boolean compatibilityModeEnabled = android.provider.Settings.Global.getInt(
            mContext.getContentResolver(),
            android.provider.Settings.Global.COMPATIBILITY_MODE, 1) == 1;
    PackageParser.setCompatibilityModeEnabled(compatibilityModeEnabled);
    if (DEBUG_SETTINGS) {
        Log.d(TAG, "compatibility mode:" + compatibilityModeEnabled);
    }

    int[] grantPermissionsUserIds = EMPTY_INT_ARRAY;

    synchronized (mPackages) {
        // Verify that all of the preferred activity components actually
        // exist.  It is possible for applications to be updated and at
        // that point remove a previously declared activity component that
        // had been set as a preferred activity.  We try to clean this up
        // the next time we encounter that preferred activity, but it is
        // possible for the user flow to never be able to return to that
        // situation so here we do a sanity check to make sure we haven't
        // left any junk around.
        ArrayList<PreferredActivity> removed = new ArrayList<PreferredActivity>();
        for (int i=0; i<mSettings.mPreferredActivities.size(); i++) {
            PreferredIntentResolver pir = mSettings.mPreferredActivities.valueAt(i);
            removed.clear();
            for (PreferredActivity pa : pir.filterSet()) {
                if (mActivities.mActivities.get(pa.mPref.mComponent) == null) {
                    removed.add(pa);
                }
            }
            if (removed.size() > 0) {
                for (int r=0; r<removed.size(); r++) {
                    PreferredActivity pa = removed.get(r);
                    Slog.w(TAG, "Removing dangling preferred activity: "
                            + pa.mPref.mComponent);
                    pir.removeFilter(pa);
                }
                mSettings.writePackageRestrictionsLPr(
                        mSettings.mPreferredActivities.keyAt(i));
            }
        }

        for (int userId : UserManagerService.getInstance().getUserIds()) {
            if (!mSettings.areDefaultRuntimePermissionsGrantedLPr(userId)) {
                grantPermissionsUserIds = ArrayUtils.appendInt(
                        grantPermissionsUserIds, userId);
            }
        }
    }
    sUserManager.systemReady();

    // If we upgraded grant all default permissions before kicking off.
    for (int userId : grantPermissionsUserIds) {
        mDefaultPermissionPolicy.grantDefaultPermissions(userId);
    }

    // If we did not grant default permissions, we preload from this the
    // default permission exceptions lazily to ensure we don't hit the
    // disk on a new user creation.
    if (grantPermissionsUserIds == EMPTY_INT_ARRAY) {
        mDefaultPermissionPolicy.scheduleReadDefaultPermissionExceptions();
    }

    // Kick off any messages waiting for system ready
    if (mPostSystemReadyMessages != null) {
        for (Message msg : mPostSystemReadyMessages) {
            msg.sendToTarget();
        }
        mPostSystemReadyMessages = null;
    }

    // Watch for external volumes that come and go over time
    final StorageManager storage = mContext.getSystemService(StorageManager.class);
    storage.registerListener(mStorageListener);

    mInstallerService.systemReady();
    mPackageDexOptimizer.systemReady();

    StorageManagerInternal StorageManagerInternal = LocalServices.getService(
            StorageManagerInternal.class);
    StorageManagerInternal.addExternalStoragePolicy(
            new StorageManagerInternal.ExternalStorageMountPolicy() {
        @Override
        public int getMountMode(int uid, String packageName) {
            if (Process.isIsolated(uid)) {
                return Zygote.MOUNT_EXTERNAL_NONE;
            }
            if (checkUidPermission(WRITE_MEDIA_STORAGE, uid) == PERMISSION_GRANTED) {
                return Zygote.MOUNT_EXTERNAL_DEFAULT;
            }
            if (checkUidPermission(READ_EXTERNAL_STORAGE, uid) == PERMISSION_DENIED) {
                return Zygote.MOUNT_EXTERNAL_DEFAULT;
            }
            if (checkUidPermission(WRITE_EXTERNAL_STORAGE, uid) == PERMISSION_DENIED) {
                return Zygote.MOUNT_EXTERNAL_READ;
            }
            return Zygote.MOUNT_EXTERNAL_WRITE;
        }

        @Override
        public boolean hasExternalStorage(int uid, String packageName) {
            return true;
        }
    });

    // Now that we're mostly running, clean up stale users and apps
    sUserManager.reconcileUsers(StorageManager.UUID_PRIVATE_INTERNAL);
    reconcileApps(StorageManager.UUID_PRIVATE_INTERNAL);

    if (mPrivappPermissionsViolations != null) {
        Slog.wtf(TAG,"Signature|privileged permissions not in "
                + "privapp-permissions whitelist: " + mPrivappPermissionsViolations);
        mPrivappPermissionsViolations = null;
    }
}

至此，PKMS启动完毕。

已知的PKMS获取方式

PackageManager ->ApplicationPackageManager -> mPm

1
2
3
IBinder b = ServiceManager.getService("package");
//Slog.v("PackageManager", "default service binder = " + b);
PackageManager packageManager = IPackageManager.Stub.asInterface(b);
1
context.getPackageManager();

上面的所有代码基于Android O，有些细节没做了解，有些流程还没有理清，待以后进一步熟悉后再做补充完善，先对已了解内容做个记录。

Powered by Hexo and Hexo-theme-hiker

Copyright © 2018 - 2022 得一 All Rights Reserved.

访客数 : | 访问量 :