Android系統-包管理機制(一)PMS服務啓動

時間  2021-08-13
標籤 java android shell 緩存 markdown app socket ide 工具 oop 欄目 Android 简体版
原文   原文鏈接

PackageManagerService(簡稱PMS,有時爲了區分PowerManagerService也稱爲PKMS)，是Android系統中核心服務之一，管理着全部跟package相關的工做，常見的好比安裝、卸載應用。java

SyetemServer處理

SystemServer啓動過程當中啓動服務android

frameworks/base/services/java/com/android/server/SystemServer.javashell

private void run() {
    try {
        ...
        //建立消息Looper
         Looper.prepareMainLooper();
        //加載了動態庫libandroid_servers.so
        System.loadLibrary("android_servers");
        performPendingShutdown();
        // 建立系統的Context
        createSystemContext();
        // 建立SystemServiceManager
        mSystemServiceManager = new SystemServiceManager(mSystemContext);
        mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
        LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
        SystemServerInitThreadPool.get();
    } finally {
        traceEnd(); 
    }
    try {
        traceBeginAndSlog("StartServices");
        //啓動引導服務
        startBootstrapServices();
        //啓動核心服務
        startCoreServices();
        //啓動其餘服務
        startOtherServices();
        SystemServerInitThreadPool.shutdown();
    } catch (Throwable ex) {
        Slog.e("System", "******************************************");
        Slog.e("System", "************ Failure starting system services", ex);
        throw ex;
    } finally {
        traceEnd();
    }
    ...
}
複製代碼

從上面能夠看出，系統服務分爲了三種類型，分別是引導服務、核心服務和其餘服務，本文要了解的PMS屬於引導服務。緩存

引導服務 做用
Installer 系統安裝apk時的一個服務類，啓動完成Installer服務以後才能啓動其餘的系統服務
ActivityManagerService 負責四大組件的啓動、切換、調度。
PowerManagerService 計算系統中和Power相關的計算，而後決策系統應該如何反應
LightsService 管理和顯示背光LED
DisplayManagerService 用來管理全部顯示設備
UserManagerService 多用戶模式管理
SensorService 爲系統提供各類感應器服務
PackageManagerService 用來對apk進行安裝、解析、刪除、卸載等等操做 
private void startBootstrapServices() {
        //啓動installer服務
        Installer installer = mSystemServiceManager.startService(Installer.class);
        // AMS
        mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();
        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
        mActivityManagerService.setInstaller(installer);
        
        //POWERMS
        mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
        Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "InitPowerManagement");
        mActivityManagerService.initPowerManagement();
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
        mSystemServiceManager.startService(LightsService.class);
        mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
        mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);

        // Only run "core" apps if we're encrypting the device.
        // 表示加密了設備，這時mOnlyCore的值爲true，表示只運行「核心」程序，建立一個極簡的啓動環境。
        String cryptState = SystemProperties.get("vold.decrypt");

        mIsAlarmBoot = SystemProperties.getBoolean("ro.alarm_boot", false);
        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;
        } else if (mIsAlarmBoot) {
            mOnlyCore = true;
        }

        if (RegionalizationEnvironment.isSupported()) {
            Slog.i(TAG, "Regionalization Service");
            RegionalizationService regionalizationService = new RegionalizationService();
            ServiceManager.addService("regionalization", regionalizationService);
        }

        // Start the package manager.
        //啓動PMS
        traceBeginAndSlog("StartPackageManagerService");
        //建立PMS
        mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
                mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
        // 表示PMS是否首次被啓動，這個參數會在WMS建立時使用
        mFirstBoot = mPackageManagerService.isFirstBoot();
        mPackageManager = mSystemContext.getPackageManager();
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);

        if (!mOnlyCore) {
            boolean disableOtaDexopt = SystemProperties.getBoolean("config.disable_otadexopt",
                    false);
            if (!disableOtaDexopt) {
                traceBeginAndSlog("StartOtaDexOptService");
                try {
                    OtaDexoptService.main(mSystemContext, mPackageManagerService);
                } catch (Throwable e) {
                    reportWtf("starting OtaDexOptService", e);
                } finally {
                    Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
                }
            }
        }

        traceBeginAndSlog("StartUserManagerService");
        mSystemServiceManager.startService(UserManagerService.LifeCycle.class);
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
        AttributeCache.init(mSystemContext);
        mActivityManagerService.setSystemProcess();
        startSensorService();
    }
複製代碼

PMS

構造方法

frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.javamarkdown

public static PackageManagerService main(Context context, Installer installer, boolean factoryTest, boolean onlyCore) {
        // Self-check for initial settings.
        PackageManagerServiceCompilerMapping.checkProperties();
			  //初始化PMS 
        PackageManagerService m = new PackageManagerService(context, installer,
                factoryTest, onlyCore);
        m.enableSystemUserPackages();
        //將package服務註冊到ServiceManager大管家
        ServiceManager.addService("package", m);
        return m;
    }
複製代碼

PMS的構造方法一共有700多行，在代碼中，將PMS的構造流程分爲了5個階段，每一個階段會使用EventLog.writeEvent打印系統日誌。app

  1. BOOT_PROGRESS_PMS_START（開始階段）
  2. BOOT_PROGRESS_PMS_SYSTEM_SCAN_START（掃描系統階段）
  3. BOOT_PROGRESS_PMS_DATA_SCAN_START（掃描Data分區階段）
  4. BOOT_PROGRESS_PMS_SCAN_END（掃描結束階段）
  5. BOOT_PROGRESS_PMS_READY（準備階段）

一、開始階段

BOOT_PROGRESS_PMS_STARTsocket

public PackageManagerService(Context context, Installer installer, boolean factoryTest, boolean onlyCore) {
        //打印開始日誌
        EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_START,
                SystemClock.uptimeMillis());

        if (mSdkVersion <= 0) {
            Slog.w(TAG, "**** ro.build.version.sdk not set!");
        }

        mContext = context;

        mPermissionReviewRequired = context.getResources().getBoolean(
                R.bool.config_permissionReviewRequired);

        mFactoryTest = factoryTest;
        mOnlyCore = onlyCore;
        //用於存儲屏幕的相關信息
        mMetrics = new DisplayMetrics();
        //建立Settings對象 (1)
        mSettings = new Settings(mPackages);
        // 添加system, phone, log, nfc, bluetooth, shell這六種shareUserId到mSettings；
        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);
     
     
     		......

        mInstaller = installer;
        //建立Dex優化工具類
        mPackageDexOptimizer = new PackageDexOptimizer(installer, mInstallLock, context,
                "*dexopt*");
        mMoveCallbacks = new MoveCallbacks(FgThread.get().getLooper());

        mOnPermissionChangeListeners = new OnPermissionChangeListeners(
                FgThread.get().getLooper());

        getDefaultDisplayMetrics(context, mMetrics);
        //獲得全局系統配置信息
        SystemConfig systemConfig = SystemConfig.getInstance();
     		//獲取全局的groupId 
        mGlobalGids = systemConfig.getGlobalGids();
     		//獲取系統權限
        mSystemPermissions = systemConfig.getSystemPermissions();
        mAvailableFeatures = systemConfig.getAvailableFeatures();

        mProtectedPackages = new ProtectedPackages(mContext);

        //安裝APK時須要的鎖，保護全部對installd的訪問。
        synchronized (mInstallLock) {
        //更新APK時須要的鎖，保護內存中已經解析的包信息等內容
        synchronized (mPackages) {
            //建立後臺線程ServiceThread
            mHandlerThread = new ServiceThread(TAG,
                    Process.THREAD_PRIORITY_BACKGROUND, true /*allowIo*/);
            mHandlerThread.start();
            //建立PackageHandler綁定到ServiceThread的消息隊列
            mHandler = new PackageHandler(mHandlerThread.getLooper());
            mProcessLoggingHandler = new ProcessLoggingHandler();
            //將PackageHandler添加到Watchdog的檢測集中
            Watchdog.getInstance().addThread(mHandler, WATCHDOG_TIMEOUT);

            mDefaultPermissionPolicy = new DefaultPermissionGrantPolicy(this);
  					
            //在Data分區建立一些目錄
            File dataDir = Environment.getDataDirectory();
            mAppInstallDir = new File(dataDir, "app");
            mAppLib32InstallDir = new File(dataDir, "app-lib");
            mEphemeralInstallDir = new File(dataDir, "app-ephemeral");
            mAsecInternalPath = new File(dataDir, "app-asec").getPath();
            mDrmAppPrivateInstallDir = new File(dataDir, "app-private");
            mRegionalizationAppInstallDir = new File(dataDir, "app-regional");

            //建立多用戶管理服務
            sUserManager = new UserManagerService(context, this, mPackages);

            mFoundPolicyFile = SELinuxMMAC.readInstallPolicy();
   					
          	//解析packages.xml等文件的信息，保存到Settings的對應字段中。packages.xml中記錄系統中全部安裝的應用信息，包括基本信息、簽名和權限。若是packages.xml有安裝的應用信息，readLPw方法會返回true，mFirstBoot的值爲false，說明PMS不是首次被啓動。
            mFirstBoot = !mSettings.readLPw(sUserManager.getUsers(false));

複製代碼

在開始階段，建立了不少PMS中的關鍵對象並賦值給PMS中的成員變量ide

mSettings

用於保存全部包的動態設置。工具

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(); //建立/data/system
    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);

    mStoppedPackagesFilename = new File(mSystemDir, "packages-stopped.xml");
    mBackupStoppedPackagesFilename = new File(mSystemDir, "packages-stopped-backup.xml");
}
複製代碼

此處mSystemDir是指目錄/data/system，在該目錄有如下5個文件：oop

文件 功能
packages.xml 記錄全部安裝app的信息
packages-backup.xml 備份文件
packages-stopped.xml 記錄系統被強制中止的文件
packages-stopped-backup.xml 備份文件
packages.list 記錄應用的數據信息

mInstaller

Installer繼承自SystemService，和PMS、AMS同樣是系統的服務(引導服務)，PMS不少的操做都是由Installer來完成的，好比APK的安裝和卸載。在Installer內部，經過socket與installd通訊，（貌似8.0以上改爲了IInstalld和installd進行Binder通訊），由位於nativie層的installd來完成具體的操做。

systemConfig

用於獲得全局系統配置信息。好比系統的權限就能夠經過SystemConfig來獲取。

mPackageDexOptimizer

Dex優化的工具類。

mHandler（PackageHandler類型）

PackageHandler繼承自Handler，PMS經過PackageHandler驅動APK的複製和安裝工做。 PackageHandler處理的消息隊列若是過於繁忙，有可能致使系統卡住， 所以將它添加到Watchdog的監測集中。 Watchdog主要有兩個用途，一個是定時檢測系統關鍵服務（AMS和WMS等）是否可能發生死鎖，還有一個是定時檢測線程的消息隊列是否長時間處於工做狀態（可能阻塞等待了很長時間）。若是出現上述問題，Watchdog會將日誌保存起來，必要時還會殺掉本身所在的進程，也就是SystemServer進程。

sUserManager（UserManagerService類型）

多用戶管理服務。

二、掃描系統階段

//打印掃描系統階段日誌
EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SYSTEM_SCAN_START,
                    startTime);

// Set flag to monitor and not change apk file paths when
// scanning install directories.
final int scanFlags = SCAN_NO_PATHS | SCAN_DEFER_DEX | SCAN_BOOTING | SCAN_INITIAL;

final String bootClassPath = System.getenv("BOOTCLASSPATH");
final String systemServerClassPath = System.getenv("SYSTEMSERVERCLASSPATH");

if (bootClassPath == null) {
  Slog.w(TAG, "No BOOTCLASSPATH found!");
}

if (systemServerClassPath == null) {
  Slog.w(TAG, "No SYSTEMSERVERCLASSPATH found!");
}

final List<String> allInstructionSets = InstructionSets.getAllInstructionSets();
final String[] dexCodeInstructionSets =
  getDexCodeInstructionSets(
  allInstructionSets.toArray(new String[allInstructionSets.size()]));

/** * Ensure all external libraries have had dexopt run on them. */
if (mSharedLibraries.size() > 0) {
  // NOTE: For now, we're compiling these system "shared libraries"
  // (and framework jars) into all available architectures. It's possible
  // to compile them only when we come across an app that uses them (there's
  // already logic for that in scanPackageLI) but that adds some complexity.
  for (String dexCodeInstructionSet : dexCodeInstructionSets) {
    for (SharedLibraryEntry libEntry : mSharedLibraries.values()) {
      final String lib = libEntry.path;
      if (lib == null) {
        continue;
      }

      try {
        // Shared libraries do not have profiles so we perform a full
        // AOT compilation (if needed).
        int dexoptNeeded = DexFile.getDexOptNeeded(
          lib, dexCodeInstructionSet,
          getCompilerFilterForReason(REASON_SHARED_APK),
          false /* newProfile */);
        if (dexoptNeeded != DexFile.NO_DEXOPT_NEEDED) {
          mInstaller.dexopt(lib, Process.SYSTEM_UID, dexCodeInstructionSet,
                            dexoptNeeded, DEXOPT_PUBLIC /*dexFlags*/,
                            getCompilerFilterForReason(REASON_SHARED_APK),
                            StorageManager.UUID_PRIVATE_INTERNAL,
                            SKIP_SHARED_LIBRARY_CHECK);
        }
      } catch (FileNotFoundException e) {
        Slog.w(TAG, "Library not found: " + lib);
      } catch (IOException | InstallerException e) {
        Slog.w(TAG, "Cannot dexopt " + lib + "; is it an APK or JAR? "
               + e.getMessage());
      }
    }
  }
}

//在/system中建立framework目錄
File frameworkDir = new File(Environment.getRootDirectory(), "framework");

final VersionInfo ver = mSettings.getInternalVersion();
mIsUpgrade = !Build.FINGERPRINT.equals(ver.fingerprint);

// when upgrading from pre-M, promote system app permissions from install to runtime
mPromoteSystemApps =
  mIsUpgrade && ver.sdkVersion <= Build.VERSION_CODES.LOLLIPOP_MR1;

// When upgrading from pre-N, we need to handle package extraction like first boot,
// as there is no profiling data available.
mIsPreNUpgrade = mIsUpgrade && ver.sdkVersion < Build.VERSION_CODES.N;

mIsPreNMR1Upgrade = mIsUpgrade && ver.sdkVersion < Build.VERSION_CODES.N_MR1;

// save off the names of pre-existing system packages prior to scanning; we don't
// want to automatically grant runtime permissions for new system apps
if (mPromoteSystemApps) {
  Iterator<PackageSetting> pkgSettingIter = mSettings.mPackages.values().iterator();
  while (pkgSettingIter.hasNext()) {
    PackageSetting ps = pkgSettingIter.next();
    if (isSystemApp(ps)) {
      mExistingSystemPackages.add(ps.name);
    }
  }
}

// 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.
String overlayThemeDir = SystemProperties.get(VENDOR_OVERLAY_THEME_PROPERTY);
 //掃描/vendor/overlay目錄下的文件
if (!overlayThemeDir.isEmpty()) {
  scanDirTracedLI(new File(VENDOR_OVERLAY_DIR, overlayThemeDir), mDefParseFlags
                  | PackageParser.PARSE_IS_SYSTEM
                  | PackageParser.PARSE_IS_SYSTEM_DIR
                  | PackageParser.PARSE_TRUSTED_OVERLAY, scanFlags | SCAN_TRUSTED_OVERLAY, 0);
}
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);

// Find base frameworks (resource packages without code).
//收集包名：/system/framework
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.
//收集私有的系統包名：/system/priv-app
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.
//收集通常的系統包名：/system/app
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.
//收集全部的供應商包名：/vendor/app
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.
//收集全部OEM包名：/oem/app
final File oemAppDir = new File(Environment.getOemDirectory(), "app");
scanDirTracedLI(oemAppDir, mDefParseFlags
                | PackageParser.PARSE_IS_SYSTEM
                | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags, 0);

// Collect all Regionalization packages form Carrier's res packages.
if (RegionalizationEnvironment.isSupported()) {
  Log.d(TAG, "Load Regionalization vendor apks");
  final List<File> RegionalizationDirs =
    RegionalizationEnvironment.getAllPackageDirectories();
  for (File f : RegionalizationDirs) {
    File RegionalizationSystemDir = new File(f, "system");
    // Collect packages in <Package>/system/priv-app
    scanDirLI(new File(RegionalizationSystemDir, "priv-app"),
              PackageParser.PARSE_IS_SYSTEM | PackageParser.PARSE_IS_SYSTEM_DIR
              | PackageParser.PARSE_IS_PRIVILEGED, scanFlags, 0);
    // Collect packages in <Package>/system/app
    scanDirLI(new File(RegionalizationSystemDir, "app"),
              PackageParser.PARSE_IS_SYSTEM | PackageParser.PARSE_IS_SYSTEM_DIR,
              scanFlags, 0);
    // Collect overlay in <Package>/system/vendor
    scanDirLI(new File(RegionalizationSystemDir, "vendor/overlay"),
              PackageParser.PARSE_IS_SYSTEM | PackageParser.PARSE_IS_SYSTEM_DIR,
              scanFlags | SCAN_TRUSTED_OVERLAY, 0);
  }
}

// Prune any system packages that no longer exist.
// 這個列表表明有可能有升級包的系統App
final List<String> possiblyDeletedUpdatedSystemApps = new ArrayList<String>();
if (!mOnlyCore) {
  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. */
    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)) {  //1
        logCriticalInfo(Log.WARN, "Expecting better updated system app for "
                        + ps.name + "; removing system app. Last known codePath="
                        + ps.codePathString + ", installStatus=" + ps.installStatus
                        + ", versionCode=" + ps.versionCode + "; scanned versionCode="
                        + scannedPkg.mVersionCode);
        //將這個系統App的PackageSetting從PMS的mPackages中移除
        removePackageLI(scannedPkg, true);
        //將升級包的路徑添加到mExpectingBetter列表中
        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 {
      final PackageSetting disabledPs = mSettings.getDisabledSystemPkgLPr(ps.name);
      //這個系統App升級包信息在mDisabledSysPackages中,可是沒有發現這個升級包存在
      if (disabledPs.codePath == null || !disabledPs.codePath.exists()) {//2
        possiblyDeletedUpdatedSystemApps.add(ps.name);
      }
    }
  }
}

//look for any incomplete package installations
//清理全部安裝不完整的包
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();

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

系統掃描階段的主要工做有如下3點：

  1. 建立/system的子目錄，好比/system/framework、/system/priv-app和/system/app等等
  2. 掃描系統文件，好比/vendor/overlay、/system/framework、/system/app等等目錄下的文件。
  3. 對掃描到的系統文件作後續處理。

主要來講第3點，一次OTA升級對於一個系統App會有三種狀況：

  • 這個系統APP無更新。
  • 這個系統APP有更新。
  • 新的OTA版本中，這個系統APP已經被刪除。

當系統App升級，PMS會將該系統App的升級包設置數據（PackageSetting）存儲到Settings的mDisabledSysPackages列表中（具體見PMS的replaceSystemPackageLIF方法），mDisabledSysPackages的類型爲ArrayMap<String, PackageSetting>。mDisabledSysPackages中的信息會被PMS保存到packages.xml中的<updated-package>標籤下（具體見Settings的writeDisabledSysPackageLPr方法）。

註釋1處說明這個系統App有升級包，那麼就將該系統App的PackageSetting從mDisabledSysPackages列表中移除，並將系統App的升級包的路徑添加到mExpectingBetter列表中，mExpectingBetter的類型爲ArrayMap<String, File>等待後續處理。

註釋2處若是這個系統App的升級包信息存儲在mDisabledSysPackages列表中，可是沒有發現這個升級包存在，則將它加入到possiblyDeletedUpdatedSystemApps列表中，意爲「系統App的升級包可能被刪除」，之因此是「可能」，是由於系統尚未掃描Data分區，只能暫放到possiblyDeletedUpdatedSystemApps列表中，等到掃描完Data分區後再作處理。

三、掃描Data分區階段

//若是設備沒有加密，那麼就開始掃描Data分區 
if (!mOnlyCore) {
    //打印掃描Data分區階段日誌
    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);
    //掃描/data/app-ephemeral目錄下的文件
    scanDirLI(mEphemeralInstallDir, mDefParseFlags
              | PackageParser.PARSE_IS_EPHEMERAL,
              scanFlags | SCAN_REQUIRE_KNOWN, 0);

    /** * Remove disable package settings for any updated system * apps that were removed via an OTA. If they're not a * previously-updated app, remove them completely. * Otherwise, just revoke their system-level permissions. * 處理possiblyDeletedUpdatedSystemApps列表 * */
    for (String deletedAppName : possiblyDeletedUpdatedSystemApps) {
      PackageParser.Package deletedPkg = mPackages.get(deletedAppName);
      mSettings.removeDisabledSystemPackageLPw(deletedAppName);

      String msg;
      if (deletedPkg == null) {
        //1 若是這個系統App的包信息不在PMS的變量mPackages中，說明是殘留的App信息，後續會刪除它的數據
        msg = "Updated system package " + deletedAppName
          + " no longer exists; it's data will be wiped";
        // Actual deletion of code and data will be handled by later
        // reconciliation step
      } else {
        //2 若是這個系統App在mPackages中，說明是存在於Data分區，不屬於系統App，那麼移除其系統權限。
        msg = "Updated system app + " + deletedAppName
          + " no longer present; removing system privileges for "
          + deletedAppName;

        deletedPkg.applicationInfo.flags &= ~ApplicationInfo.FLAG_SYSTEM;

        PackageSetting deletedPs = mSettings.mPackages.get(deletedAppName);
        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. */
     //遍歷mExpectingBetter列表
    for (int i = 0; i < mExpectingBetter.size(); i++) {
      final String packageName = mExpectingBetter.keyAt(i);
      if (!mPackages.containsKey(packageName)) {
        //獲得系統App的升級包路徑
        final File scanFile = mExpectingBetter.valueAt(i);

        logCriticalInfo(Log.WARN, "Expected better " + packageName
                        + " but never showed up; reverting to system");
 
        
        //3 根據系統App所在的目錄設置掃描的解析參數
        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;
        }

        //4 將packageName對應的包設置數據（PackageSetting）添加到mSettings的mPackages中
        mSettings.enableSystemPackageLPw(packageName);

        try {
          //5 掃描系統App的升級包
          scanPackageTracedLI(scanFile, reparseFlags, scanFlags, 0, null);
        } catch (PackageManagerException e) {
          Slog.e(TAG, "Failed to parse original system package: "
                 + e.getMessage());
        }
      }
    }
  }
 //清除mExpectingBetter列表
  mExpectingBetter.clear();
複製代碼

掃描Data分區階段主要作了如下幾件事：

  1. 掃描/data/app和/data/app-private目錄下的文件。
  2. 遍歷possiblyDeletedUpdatedSystemApps列表，註釋1處若是這個系統App的包信息不在PMS的變量mPackages中，說明是殘留的App信息，後續會刪除它的數據。註釋2處若是這個系統App的包信息在mPackages中，說明是存在於Data分區，不屬於系統App，那麼移除其系統權限。
  3. 遍歷mExpectingBetter列表，註釋3處根據系統App所在的目錄設置掃描的解析參數，註釋4處的方法內部會將packageName對應的包設置數據（PackageSetting）添加到mSettings的mPackages中。註釋5處掃描系統App的升級包，最後清除mExpectingBetter列表。

四、掃描結束階段

//打印掃描結束階段日誌
EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SCAN_END,
                    SystemClock.uptimeMillis());

            // 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.
            //當sdk版本不一致時，須要更新權限
            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;
            }
            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.
   					//若是是第一次啓動或者是Android M升級後的第一次啓動，須要初始化全部用戶定義的默認首選App
            if (!onlyCore && (mPromoteSystemApps || mFirstBoot)) {
                for (UserInfo user : sUserManager.getUsers(true)) {
                    mSettings.applyDefaultPreferredAppsLPw(this, user.id);
                    applyFactoryDefaultBrowserLPw(user.id);
                    primeDomainVerificationsLPw(user.id);
                }
            }

            //在引導過程當中儘早爲系統用戶準備存儲，
            //由於核心系統應用程序，如設置Provider和SystemUI沒法等待用戶啓動
            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).
 						// OTA後的第一次啓動，會清除代碼緩存目錄
            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();

            //當權限和其餘默認項都完成更新，則清理相關信息
            mExistingSystemPackages.clear();
            mPromoteSystemApps = false;

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

            // 把Settings的內容保存到packages.xml中
            mSettings.writeLPr();

複製代碼

掃描結束結束階段主要作了如下幾件事：

  1. 若是當前平臺SDK版本和上次啓動時的SDK版本不一樣，從新更新APK的受權。
  2. 若是是第一次啓動或者是Android M升級後的第一次啓動，須要初始化全部用戶定義的默認首選App。
  3. OTA升級後的第一次啓動，會清除代碼緩存目錄。
  4. 把Settings的內容保存到packages.xml中，這樣此後PMS再次建立時會讀到此前保存的Settings的內容。

五、準備階段

//打印準備階段日誌
EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_READY,
                    SystemClock.uptimeMillis());

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

//建立PackageInstallerService，用於管理安裝會話的服務，它會爲每次安裝過程分配一個SessionId
mInstallerService = new PackageInstallerService(context, this);

//進行一次垃圾收集
untime.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);

// 將PackageManagerInternalImpl（PackageManager的本地服務）添加到LocalServices中，LocalServices用於存儲運行在當前的進程中的本地服務
LocalServices.addService(PackageManagerInternal.class, new PackageManagerInternalImpl());
複製代碼

總結

PMS屬於引導服務，由SyetemServer啓動

PMS啓動又分爲5個階段

  1. BOOT_PROGRESS_PMS_START（開始階段）
  2. BOOT_PROGRESS_PMS_SYSTEM_SCAN_START（掃描系統階段）
  3. BOOT_PROGRESS_PMS_DATA_SCAN_START（掃描Data分區階段）
  4. BOOT_PROGRESS_PMS_SCAN_END（掃描結束階段）
  5. BOOT_PROGRESS_PMS_READY（準備階段）

連接

Android系統-包管理機制(一)PMS服務啓動

Android系統-包管理機制(二)PackageInstaller安裝APK

Android系統-包管理機制(三)PMS處理APK安裝

Android系統-installd守護進程

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程