进而介绍了第一个关键类:PackageManager。
PackageManager是一个抽象类,具体实现类是ApplicationPackageManager。
PackageManager提供了以下几个主要功能:
1.获取一个应用程序的所有信息
2.获取四大组件的信息
3.查询permission的相关信息
4.获取包的信息
5.安装、卸载apk
寻找PackageInstaller入口,
当我们在程序中调用以下代码时(7.0以前):
进而介绍了第一个关键类:PackageManager。 1.获取一个应用程序的所有信息 寻找PackageInstaller入口,
PackageManager是一个抽象类,具体实现类是ApplicationPackageManager。
PackageManager提供了以下几个主要功能:
2.获取四大组件的信息
3.查询permission的相关信息
4.获取包的信息
5.安装、卸载apk
当我们在程序中调用以下代码时(7.0以前):
Intent intent = new Intent(Intent.ACTION_VIEW); intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); intent.setDataAndType(Uri.parse("file://" + path), "application/vnd.android.package-archive"); startActivity(intent);
或者(7.0及以后)
因为7.0以后,Android要求使用ContentProvider替代原有的直接暴露Uri的方式访问文件。
Intent intent = new Intent(Intent.ACTION_VIEW);intent.setDataAndType(xxx, "application/vnd.android.package-archive");startActivity(intent);
最终我们都是跳转到一个Activity去进行安装应用,那这个Activity到底是哪个Activity呢?因为是隐式跳转,所以我们要找到对应匹配的Activity。
通过阅读源码,我们发现在7.0及以前能隐式匹配的Activity为PackageInstallerActivity,而在8.0及以后能匹配到的是InstallStart。
那就以InstallStart为入口跟踪整个流程吧!
InstallStart是PackageInstaller中的入口Activity,其中PackageInstaller是系统内置的应用程序,用于安装和卸载应用。
进入到InstallStart以后经过对安装路径的解析,最终将其传给InstallStaging页面,在InstallStaging页面中会开启一个StagingAsyncTask任务。这个任务会将传入的packageUri的内容写入到mStagedFile中,写入成功的话,则将mStagedFile传入到PackageInstallerActivity中,开启PackageInstallerActivity页面。所以,最终还是回到了PackageInstallerActivity里。
所以,你看人家google工程师就是牛逼,在写代码的时候就考虑到了代码的可扩展性。在7.0之后加入ContentProvider读取文件信息的时候,也同样可以复用之前PackageInstallerActivity的流程。
进入到PackageInstallerActivity中,首先初始化了一堆安装应用所需要的对象:PackageManager、IPackageManager、UserManager等。然后,经过解析PackageInfo等信息,最终调用checkIfAllowedAndInitiateInstall方法。
private void checkIfAllowedAndInitiateInstall() { // Check for install apps user restriction first. final int installAppsRestrictionSource = mUserManager.getUserRestrictionSource( UserManager.DISALLOW_INSTALL_APPS, Process.myUserHandle()); if ((installAppsRestrictionSource & UserManager.RESTRICTION_SOURCE_SYSTEM) != 0) { showDialogInner(DLG_INSTALL_APPS_RESTRICTED_FOR_USER); return; } else if (installAppsRestrictionSource != UserManager.RESTRICTION_NOT_SET) { startActivity(new Intent(Settings.ACTION_SHOW_ADMIN_SUPPORT_DETAILS)); finish(); return; } if (mAllowUnknownSources || !isInstallRequestFromUnknownSource(getIntent())) { initiateInstall(); } else { // Check for unknown sources restrictions. final int unknownSourcesRestrictionSource = mUserManager.getUserRestrictionSource( UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES, Process.myUserHandle()); final int unknownSourcesGlobalRestrictionSource = mUserManager.getUserRestrictionSource( UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY, Process.myUserHandle()); final int systemRestriction = UserManager.RESTRICTION_SOURCE_SYSTEM & (unknownSourcesRestrictionSource | unknownSourcesGlobalRestrictionSource); if (systemRestriction != 0) { showDialogInner(DLG_UNKNOWN_SOURCES_RESTRICTED_FOR_USER); } else if (unknownSourcesRestrictionSource != UserManager.RESTRICTION_NOT_SET) { startAdminSupportDetailsActivity(UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES); } else if (unknownSourcesGlobalRestrictionSource != UserManager.RESTRICTION_NOT_SET) { startAdminSupportDetailsActivity( UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY); } else { handleUnknownSources(); } } }
大概看一下这个方法,主要是判断是不是允许安装未知来源应用或者判断是不是未知来源应用,如果不是的话进入正常安装流程即走initiateInstall方法,如果是未知来源应用则会提示跳转到设置页面去开启允许安装未知来源应用的开关。
下面就进入到初始化安装的确认页面了,即走startInstallConfirm方法。
这个方法会初始化安装确认页面,然后会列出安装apk需要访问的系统权限。
至此,PackageInstaller初始化的工作就完成了。
简单总结一下PackageInstaller初始化的过程:
1.根据Uri的scheme协议的不同,跳转到不同的页面。如果是Content协议,也就是走ContentProvider类型的则跳转InstallStart页面,其他的则跳转的PackageInstallerActivity页面。不过最终都会进入到PackageInstallerActivity页面进行安装的初始化流程。
2.PackageInstallerActivity会对package协议和file协议进行分别处理,如果是file协议,会解析apk文件进而得到包信息PackageInfo。
3.PackageInstallerActivity会对未知来源的APK进行处理,如果允许未知来源的应用或者APK不属于未知来源则会初始化安装确认页面。否则,弹出提示对话框或者跳转到设置页面。
ok,准备工作已经做完了,那正式进入到安装流程了。
当我们点击安装确认页面的确认按钮时,我们就正式进入了安装流程了。
private void startInstall() { // Start subactivity to actually install the application Intent newIntent = new Intent(); newIntent.putExtra(PackageUtil.INTENT_ATTR_APPLICATION_INFO, mPkgInfo.applicationInfo); newIntent.setData(mPackageURI); newIntent.setClass(this, InstallInstalling.class); String installerPackageName = getIntent().getStringExtra( Intent.EXTRA_INSTALLER_PACKAGE_NAME); if (mOriginatingURI != null) { newIntent.putExtra(Intent.EXTRA_ORIGINATING_URI, mOriginatingURI); } if (mReferrerURI != null) { newIntent.putExtra(Intent.EXTRA_REFERRER, mReferrerURI); } if (mOriginatingUid != PackageInstaller.SessionParams.UID_UNKNOWN) { newIntent.putExtra(Intent.EXTRA_ORIGINATING_UID, mOriginatingUid); } if (installerPackageName != null) { newIntent.putExtra(Intent.EXTRA_INSTALLER_PACKAGE_NAME, installerPackageName); } if (getIntent().getBooleanExtra(Intent.EXTRA_RETURN_RESULT, false)) { newIntent.putExtra(Intent.EXTRA_RETURN_RESULT, true); } newIntent.addFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT); if(localLOGV) Log.i(TAG, "downloaded app uri="+mPackageURI); startActivity(newIntent); finish(); }
可以看出会跳转到InstallInstalling这个Activity中,并关闭当前PackageInstallerActivity。
在InstallInstalling中,会注册一个广播来监听安装apk最后的结果。即InstallEventReceiver。然后会开启一个InstallingAsyncTask任务,执行这个任务即是安装apk的过程。
@Override protected void onResume() { super.onResume(); // This is the first onResume in a single life of the activity if (mInstallingTask == null) { PackageInstaller installer = getPackageManager().getPackageInstaller(); PackageInstaller.SessionInfo sessionInfo = installer.getSessionInfo(mSessionId); if (sessionInfo != null && !sessionInfo.isActive()) { mInstallingTask = new InstallingAsyncTask(); mInstallingTask.execute(); } else { // we will receive a broadcast when the install is finished mCancelButton.setEnabled(false); setFinishOnTouchOutside(false); } } }
我们看一下InstallingAsyncTask最终的执行结果,
@Override protected void onPostExecute(PackageInstaller.Session session) { if (session != null) { Intent broadcastIntent = new Intent(BROADCAST_ACTION); broadcastIntent.setFlags(Intent.FLAG_RECEIVER_FOREGROUND); broadcastIntent.setPackage(getPackageName()); broadcastIntent.putExtra(EventResultPersister.EXTRA_ID, mInstallId); PendingIntent pendingIntent = PendingIntent.getBroadcast( InstallInstalling.this, mInstallId, broadcastIntent, PendingIntent.FLAG_UPDATE_CURRENT); session.commit(pendingIntent.getIntentSender()); mCancelButton.setEnabled(false); setFinishOnTouchOutside(false); } else { getPackageManager().getPackageInstaller().abandonSession(mSessionId); if (!isCancelled()) { launchFailure(PackageManager.INSTALL_FAILED_INVALID_APK, null); } } }
最终调用的session.commit方法,将这个intent发出去了。
而这个session其实是PackageInstallerSession,最终调用的是PMS的installState方法。
那么现在我们就来到了我们的主角PMS了。
上面我们分析到,最终是调用到PMS的installStage了。
void installStage(ActiveInstallSession activeInstallSession) { if (DEBUG_INSTANT) { if ((activeInstallSession.getSessionParams().installFlags & PackageManager.INSTALL_INSTANT_APP) != 0) { Slog.d(TAG, "Ephemeral install of " + activeInstallSession.getPackageName()); } } final Message msg = mHandler.obtainMessage(INIT_COPY); final InstallParams params = new InstallParams(activeInstallSession); params.setTraceMethod("installStage").setTraceCookie(System.identityHashCode(params)); msg.obj = params; Trace.asyncTraceBegin(TRACE_TAG_PACKAGE_MANAGER, "installStage", System.identityHashCode(msg.obj)); Trace.asyncTraceBegin(TRACE_TAG_PACKAGE_MANAGER, "queueInstall", System.identityHashCode(msg.obj)); mHandler.sendMessage(msg); }
可以发现,其实是向mHandler发送了一个INIT_COPY的message。而这个mHandler其实是PackageHandler。它继承自Handler,我们大概看一下对INIT_COPY消息的处理。
[图片上传失败...(image-9176ee-1608472714341)]
那我们知道,其实安装apk的过程就是将对应的apk的文件解压并copy到指定目录的过程。在copy的过程当中实际上是将对应的文件存储到了临时的一个目录当中。
PackageHandler处理安装消息调用时序图(摘自刘望舒https://blog.csdn.net/itachi85/article/details/81321138?utm_source=blogxgwz1)
复制工作完成之后,才最后进入到apk的安装。
先上一张大神的时序图,完了我们再来跟代码:
安装apk的时序图
我们上面跟到,handleStartCopy。下面紧接着就调用handleReturnCode方法。
@Override void handleReturnCode() { for (InstallParams params : mChildParams) { params.handleReturnCode(); if (params.mRet != INSTALL_SUCCEEDED) { mRet = params.mRet; } } }
最终调用 processPendingInstall(mArgs, mRet);
// Queue up an async operation since the package installation may take a little while. private void processInstallRequestsAsync(boolean success, List<InstallRequest> installRequests) { mHandler.post(() -> { if (success) { for (InstallRequest request : installRequests) { request.args.doPreInstall(request.installResult.returnCode); } synchronized (mInstallLock) { installPackagesTracedLI(installRequests); } for (InstallRequest request : installRequests) { request.args.doPostInstall( request.installResult.returnCode, request.installResult.uid); } } for (InstallRequest request : installRequests) { restoreAndPostInstall(request.args.user.getIdentifier(), request.installResult, new PostInstallData(request.args, request.installResult, null)); } }); }
最终调用的是installPackagesTracedLI
方法。
private void installPackagesLI(List<InstallRequest> requests) { final Map<String, ScanResult> preparedScans = new ArrayMap<>(requests.size()); final Map<String, InstallArgs> installArgs = new ArrayMap<>(requests.size()); final Map<String, PackageInstalledInfo> installResults = new ArrayMap<>(requests.size()); final Map<String, PrepareResult> prepareResults = new ArrayMap<>(requests.size()); final Map<String, VersionInfo> versionInfos = new ArrayMap<>(requests.size()); final Map<String, PackageSetting> lastStaticSharedLibSettings = new ArrayMap<>(requests.size()); final Map<String, Boolean> createdAppId = new ArrayMap<>(requests.size()); boolean success = false; try { Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "installPackagesLI"); for (InstallRequest request : requests) { // TODO(b/109941548): remove this once we've pulled everything from it and into // scan, reconcile or commit. final PrepareResult prepareResult; try { Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "preparePackage"); prepareResult = preparePackageLI(request.args, request.installResult); } catch (PrepareFailure prepareFailure) { request.installResult.setError(prepareFailure.error, prepareFailure.getMessage()); request.installResult.origPackage = prepareFailure.conflictingPackage; request.installResult.origPermission = prepareFailure.conflictingPermission; return; } finally { Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER); } request.installResult.setReturnCode(PackageManager.INSTALL_SUCCEEDED); request.installResult.installerPackageName = request.args.installSource.installerPackageName; final String packageName = prepareResult.packageToScan.getPackageName(); prepareResults.put(packageName, prepareResult); installResults.put(packageName, request.installResult); installArgs.put(packageName, request.args); try { final ScanResult result = scanPackageTracedLI( prepareResult.packageToScan, prepareResult.parseFlags, prepareResult.scanFlags, System.currentTimeMillis(), request.args.user, request.args.abiOverride); if (null != preparedScans.put(result.pkgSetting.pkg.getPackageName(), result)) { request.installResult.setError( PackageManager.INSTALL_FAILED_DUPLICATE_PACKAGE, "Duplicate package " + result.pkgSetting.pkg.getPackageName() + " in multi-package install request."); return; } createdAppId.put(packageName, optimisticallyRegisterAppId(result)); versionInfos.put(result.pkgSetting.pkg.getPackageName(), getSettingsVersionForPackage(result.pkgSetting.pkg)); if (result.staticSharedLibraryInfo != null) { final PackageSetting sharedLibLatestVersionSetting = getSharedLibLatestVersionSetting(result); if (sharedLibLatestVersionSetting != null) { lastStaticSharedLibSettings.put(result.pkgSetting.pkg.getPackageName(), sharedLibLatestVersionSetting); } } } catch (PackageManagerException e) { request.installResult.setError("Scanning Failed.", e); return; } } ReconcileRequest reconcileRequest = new ReconcileRequest(preparedScans, installArgs, installResults, prepareResults, mSharedLibraries, Collections.unmodifiableMap(mPackages), versionInfos, lastStaticSharedLibSettings); CommitRequest commitRequest = null; synchronized (mLock) { Map<String, ReconciledPackage> reconciledPackages; try { Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "reconcilePackages"); reconciledPackages = reconcilePackagesLocked( reconcileRequest, mSettings.mKeySetManagerService); } catch (ReconcileFailure e) { for (InstallRequest request : requests) { request.installResult.setError("Reconciliation failed...", e); } return; } finally { Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER); } try { Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "commitPackages"); commitRequest = new CommitRequest(reconciledPackages, mUserManager.getUserIds()); commitPackagesLocked(commitRequest); success = true; } finally { Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER); } } executePostCommitSteps(commitRequest); } finally { if (success) { for (InstallRequest request : requests) { final InstallArgs args = request.args; if (args.mDataLoaderType != DataLoaderType.INCREMENTAL) { continue; } if (args.signingDetails.signatureSchemeVersion != SIGNING_BLOCK_V4) { continue; } // For incremental installs, we bypass the verifier prior to install. Now // that we know the package is valid, send a notice to the verifier with // the root hash of the base.apk. final String baseCodePath = request.installResult.pkg.getBaseCodePath(); final String[] splitCodePaths = request.installResult.pkg.getSplitCodePaths(); final Uri originUri = Uri.fromFile(args.origin.resolvedFile); final int verificationId = mPendingVerificationToken++; final String rootHashString = PackageManagerServiceUtils .buildVerificationRootHashString(baseCodePath, splitCodePaths); broadcastPackageVerified(verificationId, originUri, PackageManager.VERIFICATION_ALLOW, rootHashString, args.mDataLoaderType, args.getUser()); } } else { for (ScanResult result : preparedScans.values()) { if (createdAppId.getOrDefault(result.request.parsedPackage.getPackageName(), false)) { cleanUpAppIdCreation(result); } } // TODO(patb): create a more descriptive reason than unknown in future release // mark all non-failure installs as UNKNOWN so we do not treat them as success for (InstallRequest request : requests) { if (request.installResult.freezer != null) { request.installResult.freezer.close(); } if (request.installResult.returnCode == PackageManager.INSTALL_SUCCEEDED) { request.installResult.returnCode = PackageManager.INSTALL_UNKNOWN; } } } Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER); } }
大概总结一下installPackageLI:
1.创建PackageParser,解析APK
2.检查APK是否存在,如果存在就获取此前没被改名前的包名并在注释1处赋值给PackageParser.Package类型的pkg。
3.如果Settings中存在要安装的APK的信息,说明此前安装过该APK,则需要校验APK的签名信息,确保替换安装是安全的
4.重命名临时文件。
5.系统App的更新安装会有两个限制,一个是系统App不能安装在sd卡上,另一个是系统app不能被Instant App替换。
至此,PMS处理APK安装就完成了。
总结一下步骤:
1.PackageInstaller安装APK时会将APK的信息交由PMS处理,PMS通过向PackageHandler发送消息来驱动apk的复制和安装工作。
2.PMS发送INIT_COPY和MCS_BOUND类型的消息,控制PackageHandler来绑定DefaultContainerService,完成复制APK等工作
3.复制完APK后,开始进行安装APK的流程,包括安装前的检查、安装APK和安装后的收尾工作。
后续,作者还介绍了PMS的创建过程。简单的说就是在开机过程中,由SystemServer完成的启动关键服务过程中创建的。具体过程看如下代码:
public static void main(String[] args) { new SystemServer().run(); }//run方法中 // Start services. try { t.traceBegin("StartServices"); startBootstrapServices(t); startCoreServices(t); startOtherServices(t); } catch (Throwable ex) { Slog.e("System", "******************************************"); Slog.e("System", "************ Failure starting system services", ex); throw ex; } finally { t.traceEnd(); // StartServices }//而PMS就是在startBootstrapServices中private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) { t.traceBegin("startBootstrapServices"); // Start the watchdog as early as possible so we can crash the system server // if we deadlock during early boot t.traceBegin("StartWatchdog"); final Watchdog watchdog = Watchdog.getInstance(); watchdog.start(); t.traceEnd(); Slog.i(TAG, "Reading configuration..."); final String TAG_SYSTEM_CONFIG = "ReadingSystemConfig"; t.traceBegin(TAG_SYSTEM_CONFIG); SystemServerInitThreadPool.submit(SystemConfig::getInstance, TAG_SYSTEM_CONFIG); t.traceEnd(); // Platform compat service is used by ActivityManagerService, PackageManagerService, and // possibly others in the future. b/135010838. t.traceBegin("PlatformCompat"); PlatformCompat platformCompat = new PlatformCompat(mSystemContext); ServiceManager.addService(Context.PLATFORM_COMPAT_SERVICE, platformCompat); ServiceManager.addService(Context.PLATFORM_COMPAT_NATIVE_SERVICE, new PlatformCompatNative(platformCompat)); AppCompatCallbacks.install(new long[0]); t.traceEnd(); // FileIntegrityService responds to requests from apps and the system. It needs to run after // the source (i.e. keystore) is ready, and before the apps (or the first customer in the // system) run. t.traceBegin("StartFileIntegrityService"); mSystemServiceManager.startService(FileIntegrityService.class); t.traceEnd(); // Wait for installd to finish starting up so that it has a chance to // create critical directories such as /data/user with the appropriate // permissions. We need this to complete before we initialize other services. t.traceBegin("StartInstaller"); Installer installer = mSystemServiceManager.startService(Installer.class); t.traceEnd(); // In some cases after launching an app we need to access device identifiers, // therefore register the device identifier policy before the activity manager. t.traceBegin("DeviceIdentifiersPolicyService"); mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class); t.traceEnd(); // Uri Grants Manager. t.traceBegin("UriGrantsManagerService"); mSystemServiceManager.startService(UriGrantsManagerService.Lifecycle.class); t.traceEnd(); // Activity manager runs the show. t.traceBegin("StartActivityManager"); // TODO: Might need to move after migration to WM. ActivityTaskManagerService atm = mSystemServiceManager.startService( ActivityTaskManagerService.Lifecycle.class).getService(); mActivityManagerService = ActivityManagerService.Lifecycle.startService( mSystemServiceManager, atm); mActivityManagerService.setSystemServiceManager(mSystemServiceManager); mActivityManagerService.setInstaller(installer); mWindowManagerGlobalLock = atm.getGlobalLock(); t.traceEnd(); // Data loader manager service needs to be started before package manager t.traceBegin("StartDataLoaderManagerService"); mDataLoaderManagerService = mSystemServiceManager.startService( DataLoaderManagerService.class); t.traceEnd(); // Incremental service needs to be started before package manager t.traceBegin("StartIncrementalService"); mIncrementalServiceHandle = startIncrementalService(); t.traceEnd(); // Power manager needs to be started early because other services need it. // Native daemons may be watching for it to be registered so it must be ready // to handle incoming binder calls immediately (including being able to verify // the permissions for those calls). t.traceBegin("StartPowerManager"); mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class); t.traceEnd(); t.traceBegin("StartThermalManager"); mSystemServiceManager.startService(ThermalManagerService.class); t.traceEnd(); // Now that the power manager has been started, let the activity manager // initialize power management features. t.traceBegin("InitPowerManagement"); mActivityManagerService.initPowerManagement(); t.traceEnd(); // Bring up recovery system in case a rescue party needs a reboot t.traceBegin("StartRecoverySystemService"); mSystemServiceManager.startService(RecoverySystemService.Lifecycle.class); t.traceEnd(); // Now that we have the bare essentials of the OS up and running, take // note that we just booted, which might send out a rescue party if // we're stuck in a runtime restart loop. RescueParty.registerHealthObserver(mSystemContext); PackageWatchdog.getInstance(mSystemContext).noteBoot(); // Manages LEDs and display backlight so we need it to bring up the display. t.traceBegin("StartLightsService"); mSystemServiceManager.startService(LightsService.class); t.traceEnd(); t.traceBegin("StartSidekickService"); // Package manager isn't started yet; need to use SysProp not hardware feature if (SystemProperties.getBoolean("config.enable_sidekick_graphics", false)) { mSystemServiceManager.startService(WEAR_SIDEKICK_SERVICE_CLASS); } t.traceEnd(); // Display manager is needed to provide display metrics before package manager // starts up. t.traceBegin("StartDisplayManager"); mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class); t.traceEnd(); // We need the default display before we can initialize the package manager. t.traceBegin("WaitForDisplay"); mSystemServiceManager.startBootPhase(t, SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY); t.traceEnd(); // Only run "core" apps if we're encrypting the device. String cryptState = VoldProperties.decrypt().orElse(""); 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) { FrameworkStatsLog.write(FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED, FrameworkStatsLog .BOOT_TIME_EVENT_ELAPSED_TIME__EVENT__PACKAGE_MANAGER_INIT_START, SystemClock.elapsedRealtime()); } t.traceBegin("StartPackageManagerService"); try { Watchdog.getInstance().pauseWatchingCurrentThread("packagemanagermain"); mPackageManagerService = PackageManagerService.main(mSystemContext, installer, mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore); } finally { Watchdog.getInstance().resumeWatchingCurrentThread("packagemanagermain"); } // Now that the package manager has started, register the dex load reporter to capture any // dex files loaded by system server. // These dex files will be optimized by the BackgroundDexOptService. SystemServerDexLoadReporter.configureSystemServerDexReporter(mPackageManagerService); mFirstBoot = mPackageManagerService.isFirstBoot(); mPackageManager = mSystemContext.getPackageManager(); t.traceEnd(); if (!mRuntimeRestart && !isFirstBootOrUpgrade()) { FrameworkStatsLog.write(FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED, FrameworkStatsLog .BOOT_TIME_EVENT_ELAPSED_TIME__EVENT__PACKAGE_MANAGER_INIT_READY, 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) { t.traceBegin("StartOtaDexOptService"); try { Watchdog.getInstance().pauseWatchingCurrentThread("moveab"); OtaDexoptService.main(mSystemContext, mPackageManagerService); } catch (Throwable e) { reportWtf("starting OtaDexOptService", e); } finally { Watchdog.getInstance().resumeWatchingCurrentThread("moveab"); t.traceEnd(); } } } t.traceBegin("StartUserManagerService"); mSystemServiceManager.startService(UserManagerService.LifeCycle.class); t.traceEnd(); // Initialize attribute cache used to cache resources from packages. t.traceBegin("InitAttributerCache"); AttributeCache.init(mSystemContext); t.traceEnd(); // Set up the Application instance for the system process and get started. t.traceBegin("SetSystemProcess"); mActivityManagerService.setSystemProcess(); t.traceEnd(); // Complete the watchdog setup with an ActivityManager instance and listen for reboots // Do this only after the ActivityManagerService is properly started as a system process t.traceBegin("InitWatchdog"); watchdog.init(mSystemContext, mActivityManagerService); t.traceEnd(); // DisplayManagerService needs to setup android.display scheduling related policies // since setSystemProcess() would have overridden policies due to setProcessGroup mDisplayManagerService.setupSchedulerPolicies(); // Manages Overlay packages t.traceBegin("StartOverlayManagerService"); mSystemServiceManager.startService(new OverlayManagerService(mSystemContext)); t.traceEnd(); t.traceBegin("StartSensorPrivacyService"); mSystemServiceManager.startService(new SensorPrivacyService(mSystemContext)); t.traceEnd(); if (SystemProperties.getInt("persist.sys.displayinset.top", 0) > 0) { // DisplayManager needs the overlay immediately. mActivityManagerService.updateSystemUiContext(); LocalServices.getService(DisplayManagerInternal.class).onOverlayChanged(); } // The sensor service needs access to package manager service, app ops // service, and permissions service, therefore we start it after them. // Start sensor service in a separate thread. Completion should be checked // before using it. mSensorServiceStart = SystemServerInitThreadPool.submit(() -> { TimingsTraceAndSlog traceLog = TimingsTraceAndSlog.newAsyncLog(); traceLog.traceBegin(START_SENSOR_SERVICE); startSensorService(); traceLog.traceEnd(); }, START_SENSOR_SERVICE); t.traceEnd(); // startBootstrapServices }
可以看到,PMS和AMS的初始化都在其中,那还有另一个常见的WMS在哪里初始化的呢?
WMS以及IMS都是在startOtherServices方法中初始化的。
好了,下次再看WMS和AMS吧!!!
联系客服