Android 9.0 PM机制系列（五）PMS启动流程

最新推荐文章于 2024-07-26 15:44:51 发布

忙忙碌碌一头羊

最新推荐文章于 2024-07-26 15:44:51 发布

阅读量1.3k

点赞数

分类专栏： Android开发 PackageManager 文章标签： android

本文链接：https://blog.csdn.net/dfvbrtdhy/article/details/118296144

版权

本文详细解析了Android 9.0中PMS（PackageManagerService）的启动流程，包括SystemServer处理部分和PMS构造方法的五个阶段：开始阶段、扫描系统阶段、扫描Data分区阶段、扫描结束阶段和准备阶段。PMS在SystemServer中创建，负责系统服务的管理和APK的安装卸载。在构造过程中，涉及设置初始化、系统及Data分区扫描、权限管理等多个关键步骤。

摘要由CSDN通过智能技术生成

前言

PMS的创建过程分为两个部分进行讲解，分别是SyetemServer处理部分和PMS构造方法。其中SyetemServer处理部分和AMS和WMS的创建过程基本类似。

1. SyetemServer处理部分

PMS是在SyetemServer进程中被创建的，SyetemServer进程用来创建系统服务。
从SyetemServer的入口方法main方法开始讲起，如下所示。
frameworks/base/services/java/com/android/server/SystemServer.java

public static void main(String[] args) {
   
   new SystemServer().run();
}

main方法中只调用了SystemServer的run方法，如下所示。
frameworks/base/services/java/com/android/server/SystemServer.java

private void run() {
   
    try {
   
        ...
        // Prepare the main looper thread (this thread).
        android.os.Process.setThreadPriority(
            android.os.Process.THREAD_PRIORITY_FOREGROUND);
        android.os.Process.setCanSelfBackground(false);
        Looper.prepareMainLooper();
        Looper.getMainLooper().setSlowLogThresholdMs(
                SLOW_DISPATCH_THRESHOLD_MS, SLOW_DELIVERY_THRESHOLD_MS);

        // Initialize native services.
        System.loadLibrary("android_servers");

        // Check whether we failed to shut down last time we tried.
        // This call may not return.
        performPendingShutdown();

        // Initialize the system context.
        createSystemContext();

        // Create the system service manager.
        mSystemServiceManager = new SystemServiceManager(mSystemContext);
        mSystemServiceManager.setStartInfo(mRuntimeRestart,
                mRuntimeStartElapsedTime, mRuntimeStartUptime);
        LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
        // Prepare the thread pool for init tasks that can be parallelized
        SystemServerInitThreadPool.get();
    } finally {
   
        traceEnd();  // InitBeforeStartServices
    }

    // Start services.
    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();
    }
    ...
    // Loop forever.
    Looper.loop();
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

上面的代码注释都比较清晰明了，主要干了几件事

创建消息loop，加载android_servers.so。
初始化系统上下文，创建SystemServiceManager。它会对系统的服务进行创建、启动和生命周期管理。
启动三类核心服务，这些服务的父类均为SystemService。
- BootstrapServices：AMS，PackageMS和PowerMS等引导服务
- CoreServices：DropBoxManagerService、BatteryService、UsageStatsService和WebViewUpdateService等核心服务
- OtherServices：CameraService、AlarmManagerService、VrManagerService等其他服务

本文要讲的PMS属于引导服务，因此这里列出引导服务以及它们的作用，见下表。
在这里插入图片描述
查看启动引导服务的startBootstrapServices方法。
frameworks/base/services/java/com/android/server/SystemServer.java

private static final String ENCRYPTING_STATE = "trigger_restart_min_framework";
private static final String ENCRYPTED_STATE = "1"; 

private void startBootstrapServices() {
   
		...
		//启动Installer服务
		Installer installer = mSystemServiceManager.startService(Installer.class);
        /* Only run "core" apps if we're encrypting the device.获取手机是否加密
        * 读取init.rc的vold.decrypt属性，如果它的值为”trigger_restart_min_framework”，说明我们加密了设备，
        * 这时mOnlyCore的值为true，表示只运行“核心”程序，这是为了创建一个极简的启动环境。
        */
        String cryptState = SystemProperties.get("vold.decrypt");
        if (ENCRYPTING_STATE.equals(cryptState)) {
   
            Slog.w(TAG, "Detected encryption in progress - only parsing core apps");
            mOnlyCore = true;
        } else if (ENCRYPTED_STATE.equals(cryptState)) {
   
            Slog.w(TAG, "Device encrypted - only parsing core apps");
            mOnlyCore = true;
        }

        // Start the package manager.
        if (!mRuntimeRestart) {
   
            MetricsLogger.histogram(null, "boot_package_manager_init_start",
                    (int) SystemClock.elapsedRealtime());
        }
        //调用PKMS的main方法，实列化
        mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
                mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
        mFirstBoot = mPackageManagerService.isFirstBoot();
        mPackageManager = mSystemContext.getPackageManager();
        
        if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
   
            MetricsLogger.histogram(null, "boot_package_manager_init_ready",
                    (int) SystemClock.elapsedRealtime());
        }
        // Manages A/B OTA dexopting. This is a bootstrap service as we need it to rename
        // A/B artifacts after boot, before anything else might touch/need them.
        // Note: this isn't needed during decryption (we don't have /data anyways).
        if (!mOnlyCore) {
   
            boolean disableOtaDexopt = SystemProperties.getBoolean("config.disable_otadexopt",
                    false);
            if (!disableOtaDexopt) {
   
                traceBeginAndSlog("StartOtaDexOptService");
                try {
   
                	//启动OtaDexoptService　Ota　dex　优化服务
                    OtaDexoptService.main(mSystemContext, mPackageManagerService);
                } catch (Throwable e) {
   
                    reportWtf("starting OtaDexOptService", e);
                } finally {
   
                    traceEnd();
                }
            }
        }
    }

查看启动引导服务的startOtherServices方法。
frameworks/base/services/java/com/android/server/SystemServer.java

private void startOtherServices() {
   
	 if (!mOnlyCore) {
   
        try {
   
        	//如果设备没有加密，执行performDexOptUpgrade完成dex优化, PMS.updatePackagesIfNeeded()
            mPackageManagerService.updatePackagesIfNeeded();
        } catch (Throwable e) {
   
            reportWtf("update packages", e);
        }
    }
}

代码看注释就比较清楚了，就是开启PMS服务。下面我们看一下PMS服务::main()

2. PMS构造方法

	public static PackageManagerService main(Context context, Installer installer,
            boolean factoryTest, boolean onlyCore) {
   
        // Self-check for initial settings.
        PackageManagerServiceCompilerMapping.checkProperties();

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

main方法主要做了两件事，一个是创建PMS对象，另一个是构造PackageManagerNative，并将PMN注册到ServiceManager中。
PMS的构造方法大概有800多行，分为5个阶段，每个阶段会打印出相应的EventLog，EventLog用于打印Android系统的事件日志。

BOOT_PROGRESS_PMS_START（开始阶段）
BOOT_PROGRESS_PMS_SYSTEM_SCAN_START（扫描系统阶段）
BOOT_PROGRESS_PMS_DATA_SCAN_START（扫描Data分区阶段）
BOOT_PROGRESS_PMS_SCAN_END（扫描结束阶段）
BOOT_PROGRESS_PMS_READY（准备阶段）

2.1 开始阶段

PMS的构造方法中会获取一些包管理需要属性，如下所示。
frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java

private static final String PACKAGE_SCHEME = "package";
private static final String VENDOR_OVERLAY_DIR = "/vendor/overlay";
private static final String PRODUCT_OVERLAY_DIR = "/product/overlay";

public PackageManagerService(Context context, Installer installer,
        boolean factoryTest, boolean onlyCore) {
   
    LockGuard.installLock(mPackages, LockGuard.INDEX_PACKAGES);
    Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "create package manager");
      //打印开始阶段日志
    EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_START,SystemClock.uptimeMillis());
    ...
    //一些赋值

    // Create sub-components that provide services / data. Order here is important.
    synchronized (mInstallLock) {
   
    synchronized (mPackages) {
   
        // Expose private service for system components to use.
        LocalServices.addService(
                PackageManagerInternal.class, new PackageManagerInternalImpl());
         //创建多用户管理服务
        sUserManager = new UserManagerService(context, this,
                new UserDataPreparer(mInstaller, mInstallLock, mContext, mOnlyCore), mPackages);
         //创建权限管理服务
        mPermissionManager = PermissionManagerService.create(context,
                new DefaultPermissionGrantedCallback() {
   
                    @Override
                    public void onDefaultRuntimePermissionsGranted(int userId) {
   
                        synchronized(mPackages) {
   
                            mSettings.onDefaultRuntimePermissionsGrantedLPr(userId);
                        }
                    }
                }, mPackages /*externalLock*/);
        mDefaultPermissionPolicy = mPermissionManager.getDefaultPermissionGrantPolicy();
        //Settings指同一个目录下面的Settings.java，用于保存所有包的动态设置
        mSettings = new Settings(mPermissionManager.getPermissionSettings(), mPackages);
    }
    }
    //在Settings中添加多个默认的sharedUserId
    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