devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

PackageManagerService 整体以及Settings相关逻辑_no start tag found in package manager settings

作者：Gausst松鼠会 | 2024-03-06 13:19:54

赞

踩

no start tag found in package manager settings

PackageManagerService（简称PKMS），是Aandroid系统中核心服务之一，负责应用程序的安装、卸载、信息查询等工作。

PMS概述：

Android系统启动时，在SystemServer的main函数中会启动应用程序管理服务器PKMS。

[-->SystemServer.java]

  1. private void startBootstrapServices() {
  2.     mPackageManagerService = PackageManagerService.main(mSystemContext, installer, //初始化PKMS
  3.         mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
  4.     mFirstBoot = mPackageManagerService.isFirstBoot();  //是否是第一次启动
  5.     mPackageManager = mSystemContext.getPackageManager(); // 获取到PackageManager
  6. }

[PackageManagerService.java]

  1. public class PackageManagerService extends IPackageManager.Stub { //PKMS继承IPackageManager.Stub，实现其所有的接口
  2.     public static final PackageManagerService main(Context context, Installer installer,
  3.         boolean factoryTest, boolean onlyCore) {
  4.     PackageManagerService m = new PackageManagerService(context, installer, //创建PackageManagerService
  5.             factoryTest, onlyCore);
  6.     ServiceManager.addService("package", m); //将PKMS加入到ServiceManager 这里相当于添加的是IPackageManager.Stub 服务端
  7.     return m;
  8. }
  9. }

[SystemServer中获取PackageManager的过程 -->mSystemContext.getPackageManager()]

[ContextImpl.java]

  1. public PackageManager getPackageManager() {
  2.     if (mPackageManager != null) {
  3.         return mPackageManager;
  4.     }
  5.     IPackageManager pm = ActivityThread.getPackageManager(); //由ActivityThread获取IPackageManager
  6.     if (pm != null) {
  7.         // Doesn't matter if we make more than one instance.
  8.         return (mPackageManager = new ApplicationPackageManager(this, pm)); //ApplicationPackageManager继承于PackageManager
  9.     }
  10.     return null;
  11. }

[ActivityThread.java]

  1.  
  2. public static IPackageManager getPackageManager() {
  3.     if (sPackageManager != null) {
  4.         //Slog.v("PackageManager", "returning cur default = " + sPackageManager);
  5.         return sPackageManager;
  6.     }
  7.     IBinder b = ServiceManager.getService("package"); //获取到main函数中添加IPackageManager.Stub，获取到Binder服务端
  8.     //Slog.v("PackageManager", "default service binder = " + b);
  9.     sPackageManager = IPackageManager.Stub.asInterface(b); //返回IPackageManager.Stub.Proxy 代理对象
  10.     //Slog.v("PackageManager", "default service = " + sPackageManager);
  11.     return sPackageManager;
  12. }

[ApplicationPackageManager.java]

最后返回new ApplicationPackageManager(this, pm))

也就是返回new ApplicationPackageManager(this, IPackageManager.Stub.asInterface(b)))

PKMS类之间的继承关系图

 

简单概括以下PKMS的核心功能

1.解析AndroidManifest.xml清单文件，解析清单文件中的所有节点信息

2.扫描.apk文件，安装系统应用，安装本地应用

3.管理本地应用，主要有安装、卸载、应用信息查询等

客户端可以通过Context.getPackageManager()获得ApplicationPackageManager对象，ApplicationPackageManager对象的成员变量mPM指向的是IPackageManager.Stub.Proxy代理对象，通过Binder机制中的mRemote与服务端PackageManagerService通信，并调用PackageManagerService的方法。

 

1.PKMS启动流程图

 

1.1PKMS启动的七个步骤

第一步 到 第四步：

startBootstrapServices()首先启动Installer服务，也就是安装器，随后判断当前的设备是否处于加密

状态，如果是则只是解析核心应用，接着调用PackageManagerService的静态方法main来创建pms对

象

第一步： 启动Installer服务

第二步：获取设备是否加密(手机设置密码)，如果设备加密了，则只解析"core"应用

第三步： 调用PKMS main方法初始化PackageManagerService，其中调用PackageManagerService()

构造函数创建了PKMS对象

第四步： 如果设备没有加密，操作它。管理A/B OTA dexopting。

  1. private void startBootstrapServices() {
  2.         //..........省略
  3.         //第一步：启动Installer,以便有机会创建合适的权限相关的目录，比如/data/user。需要在初始化其它服务之前完成此任务
  4.         Installer installer = mSystemServiceManager.startService(Installer.class);
  5.         //..........省略
  6.         // Activity manager runs the show.
  7.         traceBeginAndSlog("StartActivityManager");
  8.         mActivityManagerService = mSystemServiceManager.startService(  //启动AMS
  9.                 ActivityManagerService.Lifecycle.class).getService();
  10.         mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
  11.         mActivityManagerService.setInstaller(installer);  //将installer设置给AMS
  12.         traceEnd();
  13.  
  14.         //...........省略
  15.  
  16.         // Only run "core" apps if we're encrypting the device.
  17.         //第二步：获取设备是否是加密状态（手机是否设置密码），如果设备是加密状态就只解析“core”APP，后面在PKMS中会利用mOnlyCore条件进行各种判断
  18.         String cryptState = SystemProperties.get("vold.decrypt");
  19.         if (ENCRYPTING_STATE.equals(cryptState)) {
  20.             Slog.w(TAG, "Detected encryption in progress - only parsing core apps");
  21.             mOnlyCore = true;
  22.         } else if (ENCRYPTED_STATE.equals(cryptState)) {
  23.             Slog.w(TAG, "Device encrypted - only parsing core apps");
  24.             mOnlyCore = true;
  25.         }
  26.         //...........省略
  27.         //第三步： 调用PKMS的main方法初始化PackageManagerService
  28.         mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
  29.                 mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
  30.         //是否是第一次启动
  31.         mFirstBoot = mPackageManagerService.isFirstBoot();
  32.         mPackageManager = mSystemContext.getPackageManager();
  33.         traceEnd();
  34.         if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
  35.             MetricsLogger.histogram(null, "boot_package_manager_init_ready",
  36.                     (int) SystemClock.elapsedRealtime());
  37.         }
  38.         //第四步：如果设备没有加密，就管理A/B OTA dexopting
  39.         // Manages A/B OTA dexopting. This is a bootstrap service as we need it to rename
  40.         // A/B artifacts after boot, before anything else might touch/need them.
  41.         // Note: this isn't needed during decryption (we don't have /data anyways).
  42.         if (!mOnlyCore) {
  43.             boolean disableOtaDexopt = SystemProperties.getBoolean("config.disable_otadexopt",
  44.                     false);
  45.             if (!disableOtaDexopt) {
  46.                 traceBeginAndSlog("StartOtaDexOptService");
  47.                 try {
  48.                     OtaDexoptService.main(mSystemContext, mPackageManagerService);
  49.                 } catch (Throwable e) {
  50.                     reportWtf("starting OtaDexOptService", e);
  51.                 } finally {
  52.                     traceEnd();
  53.                 }
  54.             }
  55.         }
  56.     }

第五步，第六步，第七步：

startOtherServices

第五步： 执行 updatePackagesIfNeeded ，完成dex优化；

第六步： 执行 performFstrimIfNeeded ，完成磁盘维护；

第七步： 调用systemReady，准备就绪。

  1. private void startOtherServices() {
  2. ...
  3. if (!mOnlyCore) {
  4. ...
  5. // 第五步：如果设备没有加密，执行performDexOptUpgrade，完成dex优化；
  6. mPackageManagerService.updatePackagesIfNeeded();
  7. }
  8. ...
  9. // 第六步：最终执行performFstrim，完成磁盘维护
  10. mPackageManagerService.performFstrimIfNeeded();
  11. ...
  12. // 第七步：PKMS准备就绪
  13. mPackageManagerService.systemReady();
  14. ...
  15. }

主要分析第三步：

  1. public static PackageManagerService main(Context context, Installer installer,
  2.             boolean factoryTest, boolean onlyCore) {
  3.         // Self-check for initial settings.
  4.         //检查package编译相关的系统属性pm.dexopt.first-boot,pm.dexopt.boot,pm.dexopt.install,pm.dexopt.bg-dexopt,pm.dexopt.ab-ota等
  5.         PackageManagerServiceCompilerMapping.checkProperties();
  6.         //调用PKMS的构造函数
  7.         PackageManagerService m = new PackageManagerService(context, installer,
  8.                 factoryTest, onlyCore);
  9.         //启用部分应用服务于多用户场景
  10.         m.enableSystemUserPackages();
  11.         //往ServiceManager中注册"package"和"package_native"
  12.         ServiceManager.addService("package", m);
  13.         final PackageManagerNative pmn = m.new PackageManagerNative();
  14.         ServiceManager.addService("package_native", pmn);
  15.         return m;
  16.     }

[PKMS构造方法]

PKMS中两个重要锁：

mInstallLock：用来保护所有安装apk的访问权限，此操作通常涉及繁重的磁盘数据读写操作，并且是单线程操作，故有时候会处理很慢，此锁不会在已经持有mPackages锁的情况下获得。反过来在已经持有mInstallLock锁的情况下，立即获取mPackages是安全的。

mPackages：用来解析内存中所有apk的package信息及相关状态。

PKMS构造函数的五个阶段

[阶段1：BOOT_PROGRESS_PMS_START]

（1）构造DisplayMetrics类：描述界面显示，尺寸，分辨率，密度。构造完后并获取默认的信息保存到变量mMetrics中

（2）构造Settings类：Setttings是Android的全局管理者，用于协助PKMS保存所有的安装包信息

（3）保存Installer对象

（4）获取系统配置信息：SystemConfig构造构造函数中会通过readPermissions()解析指定目录下的所有xml文件，然后把这些信息保存到systemConfig中，涉及目录有如下：

/system/etc/sysconfig

/system/etc/permissions

/oem/etc/sysconfig

/oem/etc/permissions

（5）创建名为PackageHandler的Handler线程，建立PackageHandler消息循环，用于处理外部安装请求等消息

（6）创建data下的各种目录，比如data/app，data/app-private等

（7）创建用户管理服务UserManagerService

（8）把SystemConfig关于xml中的标签所指的动态库保存到mSharedLibraries，Settings.readLPw扫描解析data/system/packages.xml和data/system/packages-backup.xml

和Settings.readLPw对应是Settings.writeLPr，writeLPr将

  1. public PackageManagerService(Context context, Installer installer,
  2.             boolean factoryTest, boolean onlyCore) {
  3.         LockGuard.installLock(mPackages, LockGuard.INDEX_PACKAGES);
  4.         Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "create package manager");
  5.         mContext = context;
  6.  
  7.         mFactoryTest = factoryTest;// 一般为false，即非工厂模式
  8.         mOnlyCore = onlyCore; //标记是否只加载核心服务
  9.         mMetrics = new DisplayMetrics(); //构造DispalyMetrics保存分辨率等相关信息
  10.         mInstaller = installer; //保存installer对象
  11.  
  12.         // Create sub-components that provide services / data. Order here is important.
  13.         synchronized (mInstallLock) {
  14.         synchronized (mPackages) {
  15.             // Expose private service for system components to use.
  16.             LocalServices.addService(PackageManagerInternal.class, new PackageManagerInternalImpl()); //本地服务
  17.             sUserManager = new UserManagerService(context, this,
  18.                     new UserDataPreparer(mInstaller, mInstallLock, mContext, mOnlyCore), mPackages); //多用户管理服务
  19.             mComponentResolver = new ComponentResolver(sUserManager,
  20.                     LocalServices.getService(PackageManagerInternal.class),
  21.                     mPackages);
  22.             mPermissionManager = PermissionManagerService.create(context, //权限管理服务，创建PermissionManager对象，进行权限管理
  23.                     mPackages /*externalLock*/);
  24.             mDefaultPermissionPolicy = mPermissionManager.getDefaultPermissionGrantPolicy();
  25.             //构造Settings类，保存安装包信息，清除路径不存在的孤立应用，主要涉及/data/system/目录的packages.xml,packages-backup.xml,packages.list
  26.             //packages-stopped.xml,packages-stopped-backup.xml等文件
  27.             mSettings = new Settings(Environment.getDataDirectory(), //创建Settings对象
  28.                     mPermissionManager.getPermissionSettings(), mPackages);
  29.         }
  30.         }
  31.         //添加system,phone,log,nfc,bluetooth,shell,se,networkstack 这8种shareUserId到mSettings
  32.         mSettings.addSharedUserLPw("android.uid.system", Process.SYSTEM_UID,
  33.                 ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
  34.         mSettings.addSharedUserLPw("android.uid.phone", RADIO_UID,
  35.                 ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
  36.         mSettings.addSharedUserLPw("android.uid.log", LOG_UID,
  37.                 ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
  38.         mSettings.addSharedUserLPw("android.uid.nfc", NFC_UID,
  39.                 ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
  40.         mSettings.addSharedUserLPw("android.uid.bluetooth", BLUETOOTH_UID,
  41.                 ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
  42.         mSettings.addSharedUserLPw("android.uid.shell", SHELL_UID,
  43.                 ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
  44.         mSettings.addSharedUserLPw("android.uid.se", SE_UID,
  45.                 ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
  46.         mSettings.addSharedUserLPw("android.uid.networkstack", NETWORKSTACK_UID,
  47.                 ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
  48.  
  49.         String separateProcesses = SystemProperties.get("debug.separate_processes");
  50.         if (separateProcesses != null && separateProcesses.length() > 0) {
  51.             if ("*".equals(separateProcesses)) {
  52.                 mDefParseFlags = PackageParser.PARSE_IGNORE_PROCESSES;
  53.                 mSeparateProcesses = null;
  54.                 Slog.w(TAG, "Running with debug.separate_processes: * (ALL)");
  55.             } else {
  56.                 mDefParseFlags = 0;
  57.                 mSeparateProcesses = separateProcesses.split(",");
  58.                 Slog.w(TAG, "Running with debug.separate_processes: "
  59.                         + separateProcesses);
  60.             }
  61.         } else {
  62.             mDefParseFlags = 0;
  63.             mSeparateProcesses = null;
  64.         }
  65.         // 构造PackageDexOptimizer及DexManager类，处理dex优化
  66.         mPackageDexOptimizer = new PackageDexOptimizer(installer, mInstallLock, context,
  67.                 "*dexopt*");
  68.         mDexManager = new DexManager(mContext, this, mPackageDexOptimizer, installer, mInstallLock);
  69.         //ART虚拟机管理服务
  70.         mArtManagerService = new ArtManagerService(mContext, this, installer, mInstallLock);
  71.         mMoveCallbacks = new MoveCallbacks(FgThread.get().getLooper());
  72.  
  73.         mViewCompiler = new ViewCompiler(mInstallLock, mInstaller);
  74.         //权限变化监听器
  75.         mOnPermissionChangeListeners = new OnPermissionChangeListeners(
  76.                 FgThread.get().getLooper());
  77.         //获取默认分辨率
  78.         getDefaultDisplayMetrics(context, mMetrics);
  79.  
  80.         Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "get system config");
  81.         //创建SystemConfig实例，获取系统配置信息，配置共享lib库
  82.         //在SystemConfig的构造函数中会调用readPermissions()读取/etc/permission和etc/sysconfig下面的xml文件
  83.         SystemConfig systemConfig = SystemConfig.getInstance();
  84.         mAvailableFeatures = systemConfig.getAvailableFeatures();
  85.         Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
  86.  
  87.         mProtectedPackages = new ProtectedPackages(mContext);
  88.  
  89.         mApexManager = new ApexManager(context);
  90.         synchronized (mInstallLock) {
  91.         // writer
  92.         synchronized (mPackages) {
  93.             //启动PackageManager线程，负责apk的安装、卸载
  94.             mHandlerThread = new ServiceThread(TAG,
  95.                     Process.THREAD_PRIORITY_BACKGROUND, true /*allowIo*/);
  96.             mHandlerThread.start();
  97.             //创建PackageManager的Handler线程，循环处理外部安装相关消息。 应用handler
  98.             mHandler = new PackageHandler(mHandlerThread.getLooper());
  99.             //进程记录handler
  100.             mProcessLoggingHandler = new ProcessLoggingHandler();
  101.             //watchdog监听serviceThread是否超时： 10分钟
  102.             Watchdog.getInstance().addThread(mHandler, WATCHDOG_TIMEOUT);
  103.             //Instant应用注册
  104.             mInstantAppRegistry = new InstantAppRegistry(this);
  105.             //共享lib库配置
  106.             ArrayMap<String, SystemConfig.SharedLibraryEntry> libConfig
  107.                     = systemConfig.getSharedLibraries();
  108.             final int builtInLibCount = libConfig.size();
  109.             for (int i = 0; i < builtInLibCount; i++) {
  110.                 String name = libConfig.keyAt(i);
  111.                 SystemConfig.SharedLibraryEntry entry = libConfig.valueAt(i);
  112.                 addBuiltInSharedLibraryLocked(entry.filename, name);
  113.             }
  114.  
  115.             // Now that we have added all the libraries, iterate again to add dependency
  116.             // information IFF their dependencies are added.
  117.             long undefinedVersion = SharedLibraryInfo.VERSION_UNDEFINED;
  118.             for (int i = 0; i < builtInLibCount; i++) {
  119.                 String name = libConfig.keyAt(i);
  120.                 SystemConfig.SharedLibraryEntry entry = libConfig.valueAt(i);
  121.                 final int dependencyCount = entry.dependencies.length;
  122.                 for (int j = 0; j < dependencyCount; j++) {
  123.                     final SharedLibraryInfo dependency =
  124.                         getSharedLibraryInfoLPr(entry.dependencies[j], undefinedVersion);
  125.                     if (dependency != null) {
  126.                         getSharedLibraryInfoLPr(name, undefinedVersion).addDependency(dependency);
  127.                     }
  128.                 }
  129.             }
  130.             //读取安装相关的SE linux策略
  131.             SELinuxMMAC.readInstallPolicy();
  132.  
  133.             Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "loadFallbacks");
  134.             //返回栈加载
  135.             FallbackCategoryProvider.loadFallbacks();
  136.             Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
  137.  
  138.             Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "read user settings");
  139.             //通过mSettings读取data/system/下的packages.xml等文件
  140.             mFirstBoot = !mSettings.readLPw(sUserManager.getUsers(false));
  141.             Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
  142.  
  143.             // Clean up orphaned packages for which the code path doesn't exist
  144.             // and they are an update to a system app - caused by bug/32321269
  145.             //清理代码路径不存在的孤立软件包
  146.             final int packageSettingCount = mSettings.mPackages.size();
  147.             for (int i = packageSettingCount - 1; i >= 0; i--) {
  148.                 PackageSetting ps = mSettings.mPackages.valueAt(i);
  149.                 if (!isExternal(ps) && (ps.codePath == null || !ps.codePath.exists())
  150.                         && mSettings.getDisabledSystemPkgLPr(ps.name) != null) {
  151.                     mSettings.mPackages.removeAt(i);
  152.                     mSettings.enableSystemPackageLPw(ps.name);
  153.                 }
  154.             }
  155.             //如果不是首次启动，并且不是core应用，则拷贝与编译DEX文件
  156.             if (!mOnlyCore && mFirstBoot) {
  157.                 requestCopyPreoptedFiles();
  158.             }
  159.            //...............省略 只是第一阶段分析            
  160.             }

[接上面的mSettings.readLPw]

readLPw会扫描下面的5个文件

”data/system/packages.xml" 所有安装app信息

"data/syatem/packages-backup" 所有安装app的备份信息

"data/system/packages.list" 所有安装的app包名和所在安装目录

"data/system/packages-stopped.xml" 所有强制停止app信息

"data/system/packages-stopped-backup.xml" 所有强制停止app备份信息

以上文件分为三组：

packages.xml：PKMS扫描完目标文件夹后会创建该文件，当系统进行程序安装、卸载和更新等操作时，均会更新该文件。该文件保存了系统中与package相关的一些信息

packages.list：扫描系统中存在的所有非系统自带APK信息，里面包含app的包名，进程id，userID，和app安装目录等

packages-stopped.xml：从系统自带的设置程序中，强制停止某个应用，系统会将应用的相关信息记录到此文件中，该文件保存系统中被用户强制停止的package信息

这些目录的创建都是在Settings的构造函数中完成，得到目录后调用readLPw进行扫描

[Settings构造函数]

  1. Settings(File dataDir, PermissionSettings permission, Object lock) {
  2.         mLock = lock;
  3.         mPermissions = permission;
  4.         mRuntimePermissionsPersistence = new RuntimePermissionPersistence(mLock);
  5.  
  6.         mSystemDir = new File(dataDir, "system");  //mSystemDir指向目录 /data/system
  7.         mSystemDir.mkdirs(); //创建data/system目录
  8.         FileUtils.setPermissions(mSystemDir.toString(),  //设置权限
  9.                 FileUtils.S_IRWXU|FileUtils.S_IRWXG
  10.                 |FileUtils.S_IROTH|FileUtils.S_IXOTH,
  11.                 -1, -1);
  12.         mSettingsFilename = new File(mSystemDir, "packages.xml"); //mSettingsFilename指向 /data/system/packages.xml
  13.         mBackupSettingsFilename = new File(mSystemDir, "packages-backup.xml"); //mBackupSettingsFilename指向 data/system/packages-backup.xml
  14.         mPackageListFilename = new File(mSystemDir, "packages.list"); //mPackageListFilename指向 data/system/packages.list
  15.         FileUtils.setPermissions(mPackageListFilename, 0640, SYSTEM_UID, PACKAGE_INFO_GID);
  16.  
  17.         final File kernelDir = new File("/config/sdcardfs");
  18.         mKernelMappingFilename = kernelDir.exists() ? kernelDir : null;
  19.  
  20.         // Deprecated: Needed for migration
  21.         mStoppedPackagesFilename = new File(mSystemDir, "packages-stopped.xml");//mStoppedPackagesFilename指向data/system/packages-stopped.xml
  22.         mBackupStoppedPackagesFilename = new File(mSystemDir, "packages-stopped-backup.xml");
  23.     }

[readLPw函数]

  1. boolean readLPw(@NonNull List<UserInfo> users) {
  2.         //...............................
  3.         try {
  4.             if (str == null) {
  5.                 if (!mSettingsFilename.exists()) {
  6.                     mReadMessages.append("No settings file found\n");
  7.                     PackageManagerService.reportSettingsProblem(Log.INFO,
  8.                             "No settings file; creating initial state");
  9.                     // It's enough to just touch version details to create them
  10.                     // with default values
  11.                     findOrCreateVersion(StorageManager.UUID_PRIVATE_INTERNAL).forceCurrent();
  12.                     findOrCreateVersion(StorageManager.UUID_PRIMARY_PHYSICAL).forceCurrent();
  13.                     return false;
  14.                 }
  15.                 str = new FileInputStream(mSettingsFilename); //创建文件"读入"流，来解析packages.xml文件
  16.             }
  17.             XmlPullParser parser = Xml.newPullParser();
  18.             parser.setInput(str, StandardCharsets.UTF_8.name());
  19.  
  20.             int type;
  21.             while ((type = parser.next()) != XmlPullParser.START_TAG
  22.                     && type != XmlPullParser.END_DOCUMENT) {
  23.                 ;
  24.             }
  25.  
  26.             if (type != XmlPullParser.START_TAG) {
  27.                 mReadMessages.append("No start tag found in settings file\n");
  28.                 PackageManagerService.reportSettingsProblem(Log.WARN,
  29.                         "No start tag found in package manager settings");
  30.                 Slog.wtf(PackageManagerService.TAG,
  31.                         "No start tag found in package manager settings");
  32.                 return false;
  33.             }
  34.  
  35.             int outerDepth = parser.getDepth();
  36.             while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
  37.                     && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
  38.                 if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
  39.                     continue;
  40.                 }
  41.                 //根据XML中的各个节点进行解析，读取permissions,shared-user等   
  42.                 String tagName = parser.getName();
  43.                 if (tagName.equals("package")) {
  44.                     readPackageLPw(parser);
  45.                 } else if (tagName.equals("permissions")) {
  46.                     mPermissions.readPermissions(parser);
  47.                 } else if (tagName.equals("permission-trees")) {
  48.                     mPermissions.readPermissionTrees(parser);
  49.                 } else if (tagName.equals("shared-user")) {
  50.                     readSharedUserLPw(parser);
  51.                 } else if (tagName.equals("preferred-packages")) {
  52.                     // no longer used.
  53.                 } else if (tagName.equals("preferred-activities")) {
  54.                     // Upgrading from old single-user implementation;
  55.                     // these are the preferred activities for user 0.
  56.                     readPreferredActivitiesLPw(parser, 0);
  57.                 } else if (tagName.equals(TAG_PERSISTENT_PREFERRED_ACTIVITIES)) {
  58.                     // TODO: check whether this is okay! as it is very
  59.                     // similar to how preferred-activities are treated
  60.                     readPersistentPreferredActivitiesLPw(parser, 0);
  61.                 } else if (tagName.equals(TAG_CROSS_PROFILE_INTENT_FILTERS)) {
  62.                     // TODO: check whether this is okay! as it is very
  63.                     // similar to how preferred-activities are treated
  64.                     readCrossProfileIntentFiltersLPw(parser, 0);
  65.                 } else if (tagName.equals(TAG_DEFAULT_BROWSER)) {
  66.                     readDefaultAppsLPw(parser, 0);
  67.                 } else if (tagName.equals("updated-package")) {
  68.                     readDisabledSysPackageLPw(parser);
  69.                 } else if (tagName.equals("cleaning-package")) {
  70.                 //.............................    
  71.  
  72.         return true;
  73.     }

[阶段2：BOOT_PROGRESS_PMS_SYSTEM_SCAN_START]

(1)从init.rc中获取环境变量 BOOTCLASSPATH和SYSTESERVERCLASSPATH

(2)对于旧版升级的情况，将安装时获取权限变更为运行时申请权限

(3)扫描system/vendor/product/odm/oem等目录的priv-app、app、overlay包

(4)清除安装时临时文件以及其它不必要信息

[PackageManagerService构造函数解析阶段2]

  1. public PackageManagerService(Context context, Installer installer,
  2.             boolean factoryTest, boolean onlyCore) {
  3.      long startTime = SystemClock.uptimeMillis(); //记录扫描开始时间
  4.             EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SYSTEM_SCAN_START,
  5.                     startTime);
  6.             final String bootClassPath = System.getenv("BOOTCLASSPATH"); //从init.rc中获取环境变量BOOTCLASSPATH和SYSTESERVERCLASSPATH
  7.             final String systemServerClassPath = System.getenv("SYSTEMSERVERCLASSPATH");
  8.             //............................
  9.             File frameworkDir = new File(Environment.getRootDirectory(), "framework");/获取system/framework目录
  10.  
  11.             final VersionInfo ver = mSettings.getInternalVersion();// 获取手机的版本 ，volumUuid
  12.             mIsUpgrade = !Build.FINGERPRINT.equals(ver.fingerprint);
  13.             if (mIsUpgrade) {
  14.                 logCriticalInfo(Log.INFO,
  15.                         "Upgrading from " + ver.fingerprint + " to " + Build.FINGERPRINT);
  16.             }
  17.  
  18.             // when upgrading from pre-M, promote system app permissions from install to runtime
  19.             //对于Aandroid M之前版本升级上来的情况，需将系统应用程序权限从安装升级到运行时
  20.             mPromoteSystemApps =
  21.                     mIsUpgrade && ver.sdkVersion <= Build.VERSION_CODES.LOLLIPOP_MR1;
  22.  
  23.             // When upgrading from pre-N, we need to handle package extraction like first boot,
  24.             // as there is no profiling data available.
  25.             mIsPreNUpgrade = mIsUpgrade && ver.sdkVersion < Build.VERSION_CODES.N;
  26.  
  27.             mIsPreNMR1Upgrade = mIsUpgrade && ver.sdkVersion < Build.VERSION_CODES.N_MR1;
  28.             mIsPreQUpgrade = mIsUpgrade && ver.sdkVersion < Build.VERSION_CODES.Q;
  29.  
  30.             int preUpgradeSdkVersion = ver.sdkVersion;
  31.  
  32.             // save off the names of pre-existing system packages prior to scanning; we don't
  33.             // want to automatically grant runtime permissions for new system apps
  34.             //扫描之前保存预先存在的system packages，不希望自动为新system app赋予运行时权限
  35.             if (mPromoteSystemApps) {
  36.                 Iterator<PackageSetting> pkgSettingIter = mSettings.mPackages.values().iterator();
  37.                 while (pkgSettingIter.hasNext()) {
  38.                     PackageSetting ps = pkgSettingIter.next();
  39.                     if (isSystemApp(ps)) {
  40.                         mExistingSystemPackages.add(ps.name);
  41.                     }
  42.                 }
  43.             }
  44.             //准备解析package的缓存   
  45.             mCacheDir = preparePackageParserCache();
  46.  
  47.             // Set flag to monitor and not change apk file paths when
  48.             // scanning install directories.
  49.             int scanFlags = SCAN_BOOTING | SCAN_INITIAL;
  50.  
  51.             if (mIsUpgrade || mFirstBoot) {
  52.                 scanFlags = scanFlags | SCAN_FIRST_BOOT_OR_UPGRADE;
  53.             }
  54.  
  55.             // Collect vendor/product/product_services overlay packages. (Do this before scanning
  56.             // any apps.)
  57.             // For security and version matching reason, only consider overlay packages if they
  58.             // reside in the right directory.
  59.             // 扫描以下各个路径的文件
  60.             scanDirTracedLI(new File(VENDOR_OVERLAY_DIR),
  61.                     mDefParseFlags
  62.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  63.                     scanFlags
  64.                     | SCAN_AS_SYSTEM
  65.                     | SCAN_AS_VENDOR,
  66.                     0);
  67.             scanDirTracedLI(new File(PRODUCT_OVERLAY_DIR),
  68.                     mDefParseFlags
  69.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  70.                     scanFlags
  71.                     | SCAN_AS_SYSTEM
  72.                     | SCAN_AS_PRODUCT,
  73.                     0);
  74.             scanDirTracedLI(new File(PRODUCT_SERVICES_OVERLAY_DIR),
  75.                     mDefParseFlags
  76.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  77.                     scanFlags
  78.                     | SCAN_AS_SYSTEM
  79.                     | SCAN_AS_PRODUCT_SERVICES,
  80.                     0);
  81.             scanDirTracedLI(new File(ODM_OVERLAY_DIR),
  82.                     mDefParseFlags
  83.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  84.                     scanFlags
  85.                     | SCAN_AS_SYSTEM
  86.                     | SCAN_AS_ODM,
  87.                     0);
  88.             scanDirTracedLI(new File(OEM_OVERLAY_DIR),
  89.                     mDefParseFlags
  90.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  91.                     scanFlags
  92.                     | SCAN_AS_SYSTEM
  93.                     | SCAN_AS_OEM,
  94.                     0);
  95.  
  96.             mParallelPackageParserCallback.findStaticOverlayPackages();
  97.  
  98.             // Find base frameworks (resource packages without code).
  99.             scanDirTracedLI(frameworkDir,
  100.                     mDefParseFlags
  101.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  102.                     scanFlags
  103.                     | SCAN_NO_DEX
  104.                     | SCAN_AS_SYSTEM
  105.                     | SCAN_AS_PRIVILEGED,
  106.                     0);
  107.             if (!mPackages.containsKey("android")) {
  108.                 throw new IllegalStateException(
  109.                         "Failed to load frameworks package; check log for warnings");
  110.             }
  111.  
  112.             // Collect privileged system packages.
  113.             final File privilegedAppDir = new File(Environment.getRootDirectory(), "priv-app");
  114.             scanDirTracedLI(privilegedAppDir,
  115.                     mDefParseFlags
  116.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  117.                     scanFlags
  118.                     | SCAN_AS_SYSTEM
  119.                     | SCAN_AS_PRIVILEGED,
  120.                     0);
  121.  
  122.             // Collect ordinary system packages.
  123.             final File systemAppDir = new File(Environment.getRootDirectory(), "app");
  124.             scanDirTracedLI(systemAppDir,
  125.                     mDefParseFlags
  126.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  127.                     scanFlags
  128.                     | SCAN_AS_SYSTEM,
  129.                     0);
  130.  
  131.             // Collect privileged vendor packages.
  132.             File privilegedVendorAppDir = new File(Environment.getVendorDirectory(), "priv-app");
  133.             try {
  134.                 privilegedVendorAppDir = privilegedVendorAppDir.getCanonicalFile();
  135.             } catch (IOException e) {
  136.                 // failed to look up canonical path, continue with original one
  137.             }
  138.             scanDirTracedLI(privilegedVendorAppDir,
  139.                     mDefParseFlags
  140.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  141.                     scanFlags
  142.                     | SCAN_AS_SYSTEM
  143.                     | SCAN_AS_VENDOR
  144.                     | SCAN_AS_PRIVILEGED,
  145.                     0);
  146.  
  147.             // Collect ordinary vendor packages.
  148.             File vendorAppDir = new File(Environment.getVendorDirectory(), "app");
  149.             try {
  150.                 vendorAppDir = vendorAppDir.getCanonicalFile();
  151.             } catch (IOException e) {
  152.                 // failed to look up canonical path, continue with original one
  153.             }
  154.             scanDirTracedLI(vendorAppDir,
  155.                     mDefParseFlags
  156.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  157.                     scanFlags
  158.                     | SCAN_AS_SYSTEM
  159.                     | SCAN_AS_VENDOR,
  160.                     0);
  161.  
  162.             // Collect privileged odm packages. /odm is another vendor partition
  163.             // other than /vendor.
  164.             File privilegedOdmAppDir = new File(Environment.getOdmDirectory(),
  165.                         "priv-app");
  166.             try {
  167.                 privilegedOdmAppDir = privilegedOdmAppDir.getCanonicalFile();
  168.             } catch (IOException e) {
  169.                 // failed to look up canonical path, continue with original one
  170.             }
  171.             scanDirTracedLI(privilegedOdmAppDir,
  172.                     mDefParseFlags
  173.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  174.                     scanFlags
  175.                     | SCAN_AS_SYSTEM
  176.                     | SCAN_AS_VENDOR
  177.                     | SCAN_AS_PRIVILEGED,
  178.                     0);
  179.  
  180.             // Collect ordinary odm packages. /odm is another vendor partition
  181.             // other than /vendor.
  182.             File odmAppDir = new File(Environment.getOdmDirectory(), "app");
  183.             try {
  184.                 odmAppDir = odmAppDir.getCanonicalFile();
  185.             } catch (IOException e) {
  186.                 // failed to look up canonical path, continue with original one
  187.             }
  188.             scanDirTracedLI(odmAppDir,
  189.                     mDefParseFlags
  190.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  191.                     scanFlags
  192.                     | SCAN_AS_SYSTEM
  193.                     | SCAN_AS_VENDOR,
  194.                     0);
  195.  
  196.             // Collect all OEM packages.
  197.             final File oemAppDir = new File(Environment.getOemDirectory(), "app");
  198.             scanDirTracedLI(oemAppDir,
  199.                     mDefParseFlags
  200.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  201.                     scanFlags
  202.                     | SCAN_AS_SYSTEM
  203.                     | SCAN_AS_OEM,
  204.                     0);
  205.  
  206.             // Collected privileged /product packages.
  207.             File privilegedProductAppDir = new File(Environment.getProductDirectory(), "priv-app");
  208.             try {
  209.                 privilegedProductAppDir = privilegedProductAppDir.getCanonicalFile();
  210.             } catch (IOException e) {
  211.                 // failed to look up canonical path, continue with original one
  212.             }
  213.             scanDirTracedLI(privilegedProductAppDir,
  214.                     mDefParseFlags
  215.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  216.                     scanFlags
  217.                     | SCAN_AS_SYSTEM
  218.                     | SCAN_AS_PRODUCT
  219.                     | SCAN_AS_PRIVILEGED,
  220.                     0);
  221.  
  222.             // Collect ordinary /product packages.
  223.             File productAppDir = new File(Environment.getProductDirectory(), "app");
  224.             try {
  225.                 productAppDir = productAppDir.getCanonicalFile();
  226.             } catch (IOException e) {
  227.                 // failed to look up canonical path, continue with original one
  228.             }
  229.             scanDirTracedLI(productAppDir,
  230.                     mDefParseFlags
  231.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  232.                     scanFlags
  233.                     | SCAN_AS_SYSTEM
  234.                     | SCAN_AS_PRODUCT,
  235.                     0);
  236.  
  237.             // Collected privileged /product_services packages.
  238.             File privilegedProductServicesAppDir =
  239.                     new File(Environment.getProductServicesDirectory(), "priv-app");
  240.             try {
  241.                 privilegedProductServicesAppDir =
  242.                         privilegedProductServicesAppDir.getCanonicalFile();
  243.             } catch (IOException e) {
  244.                 // failed to look up canonical path, continue with original one
  245.             }
  246.             scanDirTracedLI(privilegedProductServicesAppDir,
  247.                     mDefParseFlags
  248.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  249.                     scanFlags
  250.                     | SCAN_AS_SYSTEM
  251.                     | SCAN_AS_PRODUCT_SERVICES
  252.                     | SCAN_AS_PRIVILEGED,
  253.                     0);
  254.  
  255.             // Collect ordinary /product_services packages.
  256.             File productServicesAppDir = new File(Environment.getProductServicesDirectory(), "app");
  257.             try {
  258.                 productServicesAppDir = productServicesAppDir.getCanonicalFile();
  259.             } catch (IOException e) {
  260.                 // failed to look up canonical path, continue with original one
  261.             }
  262.             scanDirTracedLI(productServicesAppDir,
  263.                     mDefParseFlags
  264.                     | PackageParser.PARSE_IS_SYSTEM_DIR,
  265.                     scanFlags
  266.                     | SCAN_AS_SYSTEM
  267.                     | SCAN_AS_PRODUCT_SERVICES,
  268.                     0);
  269.  
  270.             // Prune any system packages that no longer exist.
  271.             final List<String> possiblyDeletedUpdatedSystemApps = new ArrayList<>();
  272.             // Stub packages must either be replaced with full versions in the /data
  273.             // partition or be disabled.
  274.             final List<String> stubSystemApps = new ArrayList<>();
  275.             //删除不存在的package
  276.             if (!mOnlyCore) {
  277.                 // do this first before mucking with mPackages for the "expecting better" case
  278.                 final Iterator<PackageParser.Package> pkgIterator = mPackages.values().iterator();
  279.                 while (pkgIterator.hasNext()) {
  280.                     final PackageParser.Package pkg = pkgIterator.next();
  281.                     if (pkg.isStub) {
  282.                         stubSystemApps.add(pkg.packageName);
  283.                     }
  284.                 }
  285.  
  286.                 final Iterator<PackageSetting> psit = mSettings.mPackages.values().iterator();
  287.                 while (psit.hasNext()) {
  288.                     PackageSetting ps = psit.next();
  289.  
  290.                     /*
  291.                      * If this is not a system app, it can't be a 不是系统应用，不被允许disable
  292.                      * disable system app.
  293.                      */
  294.                     if ((ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) == 0) {
  295.                         continue;
  296.                     }
  297.  
  298.                     /*
  299.                      * If the package is scanned, it's not erased. 如果应用被扫描，则不允许被擦除
  300.                      */
  301.                     final PackageParser.Package scannedPkg = mPackages.get(ps.name);
  302.                     if (scannedPkg != null) {
  303.                         /*
  304.                          * If the system app is both scanned and in the
  305.                          * disabled packages list, then it must have been
  306.                          * added via OTA. Remove it from the currently
  307.                          * scanned package so the previously user-installed
  308.                          * application can be scanned.
  309.                          */
  310.                         if (mSettings.isDisabledSystemPackageLPr(ps.name)) {
  311.                             logCriticalInfo(Log.WARN,
  312.                                     "Expecting better updated system app for " + ps.name
  313.                                     + "; removing system app.  Last known"
  314.                                     + " codePath=" + ps.codePathString
  315.                                     + ", versionCode=" + ps.versionCode
  316.                                     + "; scanned versionCode=" + scannedPkg.getLongVersionCode());
  317.                             removePackageLI(scannedPkg, true);
  318.                             mExpectingBetter.put(ps.name, ps.codePath);
  319.                         }
  320.  
  321.                         continue;
  322.                     }
  323.  
  324.                     if (!mSettings.isDisabledSystemPackageLPr(ps.name)) {
  325.                         psit.remove();
  326.                         logCriticalInfo(Log.WARN, "System package " + ps.name
  327.                                 + " no longer exists; it's data will be wiped");
  328.                         // Actual deletion of code and data will be handled by later
  329.                         // reconciliation step
  330.                     } else {
  331.                         // we still have a disabled system package, but, it still might have
  332.                         // been removed. check the code path still exists and check there's
  333.                         // still a package. the latter can happen if an OTA keeps the same
  334.                         // code path, but, changes the package name.
  335.                         final PackageSetting disabledPs =
  336.                                 mSettings.getDisabledSystemPkgLPr(ps.name);
  337.                         if (disabledPs.codePath == null || !disabledPs.codePath.exists()
  338.                                 || disabledPs.pkg == null) {
  339.                             possiblyDeletedUpdatedSystemApps.add(ps.name);
  340.                         } else {
  341.                             // We're expecting that the system app should remain disabled, but add
  342.                             // it to expecting better to recover in case the data version cannot
  343.                             // be scanned.
  344.                             mExpectingBetter.put(disabledPs.name, disabledPs.codePath);
  345.                         }
  346.                     }
  347.                 }
  348.             }
  349.  
  350.             //delete tmp files 删除安装产生的临时文件
  351.             deleteTempPackageFiles();
  352.  
  353.             final int cachedSystemApps = PackageParser.sCachedPackageReadCount.get();
  354.  
  355.             // Remove any shared userIDs that have no associated packages 删除没有关联shared userID的package
  356.             mSettings.pruneSharedUsersLPw();
  357. }

[阶段3：BOOT_PROGRESS_PMS_DATA_SCAN_START]

[PackageManagerService构造函数解析阶段3]

处理data目录的应用信息，及时更新，去除不必要的数据

  1. public PackageManagerService(Context context, Installer installer,
  2.             boolean factoryTest, boolean onlyCore) {
  3. if (!mOnlyCore) {
  4.                 EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_DATA_SCAN_START,
  5.                         SystemClock.uptimeMillis());
  6.                 scanDirTracedLI(sAppInstallDir, 0, scanFlags | SCAN_REQUIRE_KNOWN, 0);
  7.  
  8.                 // Remove disable package settings for updated system apps that were
  9.                 // removed via an OTA. If the update is no longer present, remove the
  10.                 // app completely. Otherwise, revoke their system privileges.
  11.                 for (int i = possiblyDeletedUpdatedSystemApps.size() - 1; i >= 0; --i) {
  12.                     final String packageName = possiblyDeletedUpdatedSystemApps.get(i);
  13.                     final PackageParser.Package pkg = mPackages.get(packageName);
  14.                     final String msg;
  15.  
  16.                     // remove from the disabled system list; do this first so any future
  17.                     // scans of this package are performed without this state
  18.                     mSettings.removeDisabledSystemPackageLPw(packageName);
  19.  
  20.                     if (pkg == null) {
  21.                         // should have found an update, but, we didn't; remove everything
  22.                         msg = "Updated system package " + packageName
  23.                                 + " no longer exists; removing its data";
  24.                         // Actual deletion of code and data will be handled by later
  25.                         // reconciliation step
  26.                     } else {
  27.                         // found an update; revoke system privileges
  28.                         msg = "Updated system package " + packageName
  29.                                 + " no longer exists; rescanning package on data";
  30.  
  31.                         // NOTE: We don't do anything special if a stub is removed from the
  32.                         // system image. But, if we were [like removing the uncompressed
  33.                         // version from the /data partition], this is where it'd be done.
  34.  
  35.                         // remove the package from the system and re-scan it without any
  36.                         // special privileges
  37.                         removePackageLI(pkg, true);
  38.                         try {
  39.                             final File codePath = new File(pkg.applicationInfo.getCodePath());
  40.                             scanPackageTracedLI(codePath, 0, scanFlags, 0, null);
  41.                         } catch (PackageManagerException e) {
  42.                             Slog.e(TAG, "Failed to parse updated, ex-system package: "
  43.                                     + e.getMessage());
  44.                         }
  45.                     }
  46.  
  47.                     // one final check. if we still have a package setting [ie. it was
  48.                     // previously scanned and known to the system], but, we don't have
  49.                     // a package [ie. there was an error scanning it from the /data
  50.                     // partition], completely remove the package data.
  51.                     final PackageSetting ps = mSettings.mPackages.get(packageName);
  52.                     if (ps != null && mPackages.get(packageName) == null) {
  53.                         removePackageDataLIF(ps, null, null, 0, false);
  54.  
  55.                     }
  56.                     logCriticalInfo(Log.WARN, msg);
  57.                 }
  58.  
  59.                 //确保期望显示在userdata分区上的所有应用程序都显示正确，如果从未出现过，就回滚以恢复系统版本
  60.                 for (int i = 0; i < mExpectingBetter.size(); i++) {
  61.                     final String packageName = mExpectingBetter.keyAt(i);
  62.                     if (!mPackages.containsKey(packageName)) {
  63.                         final File scanFile = mExpectingBetter.valueAt(i);
  64.  
  65.                         logCriticalInfo(Log.WARN, "Expected better " + packageName
  66.                                 + " but never showed up; reverting to system");
  67.  
  68.                         final @ParseFlags int reparseFlags;
  69.                         final @ScanFlags int rescanFlags;
  70.                         if (FileUtils.contains(privilegedAppDir, scanFile)) {
  71.                             reparseFlags =
  72.                                     mDefParseFlags |
  73.                                     PackageParser.PARSE_IS_SYSTEM_DIR;
  74.                             rescanFlags =
  75.                                     scanFlags
  76.                                     | SCAN_AS_SYSTEM
  77.                                     | SCAN_AS_PRIVILEGED;
  78.                         } else if (FileUtils.contains(systemAppDir, scanFile)) {
  79.                             reparseFlags =
  80.                                     mDefParseFlags |
  81.                                     PackageParser.PARSE_IS_SYSTEM_DIR;
  82.                             rescanFlags =
  83.                                     scanFlags
  84.                                     | SCAN_AS_SYSTEM;
  85.                         } else if (FileUtils.contains(privilegedVendorAppDir, scanFile)
  86.                                 || FileUtils.contains(privilegedOdmAppDir, scanFile)) {
  87.                             reparseFlags =
  88.                                     mDefParseFlags |
  89.                                     PackageParser.PARSE_IS_SYSTEM_DIR;
  90.                             rescanFlags =
  91.                                     scanFlags
  92.                                     | SCAN_AS_SYSTEM
  93.                                     | SCAN_AS_VENDOR
  94.                                     | SCAN_AS_PRIVILEGED;
  95.                         } else if (FileUtils.contains(vendorAppDir, scanFile)
  96.                                 || FileUtils.contains(odmAppDir, scanFile)) {
  97.                             reparseFlags =
  98.                                     mDefParseFlags |
  99.                                     PackageParser.PARSE_IS_SYSTEM_DIR;
  100.                             rescanFlags =
  101.                                     scanFlags
  102.                                     | SCAN_AS_SYSTEM
  103.                                     | SCAN_AS_VENDOR;
  104.                         } else if (FileUtils.contains(oemAppDir, scanFile)) {
  105.                             reparseFlags =
  106.                                     mDefParseFlags |
  107.                                     PackageParser.PARSE_IS_SYSTEM_DIR;
  108.                             rescanFlags =
  109.                                     scanFlags
  110.                                     | SCAN_AS_SYSTEM
  111.                                     | SCAN_AS_OEM;
  112.                         } else if (FileUtils.contains(privilegedProductAppDir, scanFile)) {
  113.                             reparseFlags =
  114.                                     mDefParseFlags |
  115.                                     PackageParser.PARSE_IS_SYSTEM_DIR;
  116.                             rescanFlags =
  117.                                     scanFlags
  118.                                     | SCAN_AS_SYSTEM
  119.                                     | SCAN_AS_PRODUCT
  120.                                     | SCAN_AS_PRIVILEGED;
  121.                         } else if (FileUtils.contains(productAppDir, scanFile)) {
  122.                             reparseFlags =
  123.                                     mDefParseFlags |
  124.                                     PackageParser.PARSE_IS_SYSTEM_DIR;
  125.                             rescanFlags =
  126.                                     scanFlags
  127.                                     | SCAN_AS_SYSTEM
  128.                                     | SCAN_AS_PRODUCT;
  129.                         } else if (FileUtils.contains(privilegedProductServicesAppDir, scanFile)) {
  130.                             reparseFlags =
  131.                                     mDefParseFlags |
  132.                                     PackageParser.PARSE_IS_SYSTEM_DIR;
  133.                             rescanFlags =
  134.                                     scanFlags
  135.                                     | SCAN_AS_SYSTEM
  136.                                     | SCAN_AS_PRODUCT_SERVICES
  137.                                     | SCAN_AS_PRIVILEGED;
  138.                         } else if (FileUtils.contains(productServicesAppDir, scanFile)) {
  139.                             reparseFlags =
  140.                                     mDefParseFlags |
  141.                                     PackageParser.PARSE_IS_SYSTEM_DIR;
  142.                             rescanFlags =
  143.                                     scanFlags
  144.                                     | SCAN_AS_SYSTEM
  145.                                     | SCAN_AS_PRODUCT_SERVICES;
  146.                         } else {
  147.                             Slog.e(TAG, "Ignoring unexpected fallback path " + scanFile);
  148.                             continue;
  149.                         }
  150.  
  151.                         mSettings.enableSystemPackageLPw(packageName);
  152.  
  153.                         try {
  154.                             //扫描APK
  155.                             scanPackageTracedLI(scanFile, reparseFlags, rescanFlags, 0, null);
  156.                         } catch (PackageManagerException e) {
  157.                             Slog.e(TAG, "Failed to parse original system package: "
  158.                                     + e.getMessage());
  159.                         }
  160.                     }
  161.                 }
  162.  
  163.                 // Uncompress and install any stubbed system applications.
  164.                 // This must be done last to ensure all stubs are replaced or disabled.
  165.                 installSystemStubPackages(stubSystemApps, scanFlags);//解压缩并安装任何存根系统应用程序，必须最后执行此操作以确保替换或禁用所有存根
  166.                 //......................
  167.                 }
  168.             }
  169.             mExpectingBetter.clear();
  170.  
  171.             // Resolve the storage manager. 获取到storage manager包名
  172.             mStorageManagerPackage = getStorageManagerPackageName();
  173.  
  174.             // Resolve protected action filters. Only the setup wizard is allowed to
  175.             // have a high priority filter for these actions.
  176.             mSetupWizardPackage = getSetupWizardPackageName();
  177.             mComponentResolver.fixProtectedFilterPriorities();
  178.  
  179.             mSystemTextClassifierPackage = getSystemTextClassifierPackageName();
  180.  
  181.             mWellbeingPackage = getWellbeingPackageName();
  182.             mDocumenterPackage = getDocumenterPackageName();
  183.             mConfiguratorPackage =
  184.                     mContext.getString(R.string.config_deviceConfiguratorPackageName);
  185.             mAppPredictionServicePackage = getAppPredictionServicePackageName();
  186.             mIncidentReportApproverPackage = getIncidentReportApproverPackageName();
  187.  
  188.             // Now that we know all of the shared libraries, update all clients to have
  189.             // the correct library paths. 更新客户端以确保持有正确的共享库路径
  190.             updateAllSharedLibrariesLocked(null, Collections.unmodifiableMap(mPackages));
  191.  
  192.             for (SharedUserSetting setting : mSettings.getAllSharedUsersLPw()) {
  193.                 // NOTE: We ignore potential failures here during a system scan (like
  194.                 // the rest of the commands above) because there's precious little we
  195.                 // can do about it. A settings error is reported, though.
  196.                 final List<String> changedAbiCodePath =
  197.                         adjustCpuAbisForSharedUserLPw(setting.packages, null /*scannedPackage*/);
  198.                 if (changedAbiCodePath != null && changedAbiCodePath.size() > 0) {
  199.                     for (int i = changedAbiCodePath.size() - 1; i >= 0; --i) {
  200.                         final String codePathString = changedAbiCodePath.get(i);
  201.                         try {
  202.                             mInstaller.rmdex(codePathString,
  203.                                     getDexCodeInstructionSet(getPreferredInstructionSet()));
  204.                         } catch (InstallerException ignored) {
  205.                         }
  206.                     }
  207.                 }
  208.                 // Adjust seInfo to ensure apps which share a sharedUserId are placed in the same
  209.                 // SELinux domain.
  210.                 setting.fixSeInfoLocked();
  211.             }
  212.  
  213.             // Now that we know all the packages we are keeping,
  214.             // read and update their last usage times. 读取并更新要保留的package的上次使用时间
  215.             mPackageUsage.read(mPackages);
  216.             mCompilerStats.read();
  217. }

[阶段4：BOOT_PROGRESS_PMS_SCAN_END]

[PackageManagerService构造函数解析阶段4]

（1）sdk版本变更，更新权限

（2）OTA升级后首次启动，清除不必要的缓存数据

（3）权限等默认项更新完后，清除相关数据

（4）更新packages.xml

  1. public PackageManagerService(Context context, Installer installer,
  2.             boolean factoryTest, boolean onlyCore) {
  3.     EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SCAN_END,
  4.                     SystemClock.uptimeMillis());
  5.             Slog.i(TAG, "Time to scan packages: "
  6.                     + ((SystemClock.uptimeMillis()-startTime)/1000f)
  7.                     + " seconds");
  8.  
  9.             // 如果子上次启动以来，平台sdk以改变，则需要重新授予应用程序权限以捕获出现任何新权限
  10.             final boolean sdkUpdated = (ver.sdkVersion != mSdkVersion);
  11.             if (sdkUpdated) {
  12.                 Slog.i(TAG, "Platform changed from " + ver.sdkVersion + " to "
  13.                         + mSdkVersion + "; regranting permissions for internal storage");
  14.             }
  15.             mPermissionManager.updateAllPermissions(
  16.                     StorageManager.UUID_PRIVATE_INTERNAL, sdkUpdated, mPackages.values(),
  17.                     mPermissionCallback);
  18.             ver.sdkVersion = mSdkVersion;
  19.  
  20.             // 如果是第一次启动或者来自Android M之前的版本升级，并且它是正常启动，那需要在所有一定以的用户中初始化默认的首选应用程序
  21.             if (!onlyCore && (mPromoteSystemApps || mFirstBoot)) {
  22.                 for (UserInfo user : sUserManager.getUsers(true)) {
  23.                     mSettings.applyDefaultPreferredAppsLPw(user.id);
  24.                     primeDomainVerificationsLPw(user.id);
  25.                 }
  26.             }
  27.             //在boot期间更早的为用户准备storage，因为像SettingsProvider和SystemUI这样的核心应用无法等到用户去启动
  28.             final int storageFlags;
  29.             if (StorageManager.isFileEncryptedNativeOrEmulated()) {
  30.                 storageFlags = StorageManager.FLAG_STORAGE_DE;
  31.             } else {
  32.                 storageFlags = StorageManager.FLAG_STORAGE_DE | StorageManager.FLAG_STORAGE_CE;
  33.             }
  34.             //............................
  35.  
  36.             // 如果是在OTA之后的首次启动，并且是正常启动，那需要清除代码缓存目录，但不清除应用程序配置文件
  37.             if (mIsUpgrade && !onlyCore) {
  38.                 Slog.i(TAG, "Build fingerprint changed; clearing code caches");
  39.                 for (int i = 0; i < mSettings.mPackages.size(); i++) {
  40.                     final PackageSetting ps = mSettings.mPackages.valueAt(i);
  41.                     if (Objects.equals(StorageManager.UUID_PRIVATE_INTERNAL, ps.volumeUuid)) {
  42.                         // No apps are running this early, so no need to freeze
  43.                         clearAppDataLIF(ps.pkg, UserHandle.USER_ALL,
  44.                                 FLAG_STORAGE_DE | FLAG_STORAGE_CE | FLAG_STORAGE_EXTERNAL
  45.                                         | Installer.FLAG_CLEAR_CODE_CACHE_ONLY);
  46.                     }
  47.                 }
  48.                 ver.fingerprint = Build.FINGERPRINT;
  49.             }
  50.  
  51.             // Grandfather existing (installed before Q) non-system apps to hide
  52.             // 安装Android-Q前的非系统应用程序在Launcher中隐藏他们的图标
  53.             if (!onlyCore && mIsPreQUpgrade) {
  54.                 Slog.i(TAG, "Whitelisting all existing apps to hide their icons");
  55.                 int size = mSettings.mPackages.size();
  56.                 for (int i = 0; i < size; i++) {
  57.                     final PackageSetting ps = mSettings.mPackages.valueAt(i);
  58.                     if ((ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) != 0) {
  59.                         continue;
  60.                     }
  61.                     ps.disableComponentLPw(PackageManager.APP_DETAILS_ACTIVITY_CLASS_NAME,
  62.                             UserHandle.USER_SYSTEM);
  63.                 }
  64.             }
  65.  
  66.             // 仅在权限或其它默认配置更新后清除
  67.             mExistingSystemPackages.clear();
  68.             mPromoteSystemApps = false;
  69.  
  70.             // 所有变更均在扫描过程中完成
  71.             ver.databaseVersion = Settings.CURRENT_DATABASE_VERSION;
  72.  
  73.             // 更新packages.xml
  74.             Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "write settings");
  75.             mSettings.writeLPr();          
  76. }

[阶段4：BOOT_PROGRESS_PMS_READY]

[PackageManagerService构造函数解析阶段5]

GC回收内存

Runtime.getRuntime().gc();

 

2.PKMS APK扫描

扫描APK的AndroidManifest.xml中的各个标签信息，例如"application"、"overlay"、"permission"、"uses-permission"等信息。再针对各个标签的子标签在进行扫描，例如application会扫描"activity"、"receiver"、"service"、"provider"等信息。

PKMS的构造函数中调用了scanDirTracedLI方法来扫描某个目录的apk文件。

android10.0中PKMS主要扫描以下路径的APK信息

/vendor/overlay 系统的APP类别

/product/overlay 系统的APP类别

/product_services/overlay 系统的APP类别

/odm/overlay 系统的APP类别

/oem/overlay 系统的APP类别

/system/framework 系统的APP类别

/system/priv-app 系统的APP类别

/system/app 系统的APP类别

/vendor/priv-app 系统的APP类别

/vendor/app 系统的APP类别

/odm/priv-app 系统的APP类别

/odm/app 系统的APP类别

/oem/app 系统的APP类别

/oem/priv-app 系统的APP类别

/product/priv-app 系统的APP类别

/product/app 系统的APP类别

/product_services/priv-app 系统的APP类别

/product_services/app 系统的APP类别

/product_services/priv-app 系统的APP类别

 

APK扫描整体流程图

3.APK安装的流程

（1）把APK的信息以IO流的形式写入到PackageInstaller.Session中

（2）调用PackageInstaller.Session的commit方法，将APK的信息交给PKMS处理

（3）进行APK的copy操作，进行安装

4.PKMS权限管理

读取/etc/sysconfig和/etc/permissions目录下的xml文件

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/199068
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号