“终于懂了”系列：APK安装过程完全解析！

胡飞洋

发布于 2021-11-12 15:03:44

6K1

发布于 2021-11-12 15:03:44

文章被收录于专栏：胡飞洋的Android进阶

点击上方胡飞洋可以关注哦~

一、背景

最近在了解插件化技术：把未安装的插件apk 集成到宿主App中，以取得减少宿主APK包体积等优点。也就是说，一个完整的APK 虽然不经过安装过程，但使用了插件化技术后却可以在宿主中使用其功能。

那么对应的，一个APK的完整安装过程是怎样的呢？用户通常能体验到的安装过程有两种：

在手机厂商的应用市场中选择目标App自动安装；

image.png

先下载APK，然后是安装过程，过程中没有跳转到其他页面，可以说是一键安装。

浏览器、QQ、抖音等应用里面下载的APK包，点击后用户确认安装：

image.png

这种通常是用户下载一个APK文件，然后手动点击，跳转到安装页面，提示这个APK的下载信息等，然后是安装包详情页面，展示版本号、所需权限等一些信息，最后是安装中的页面。我使用的是小米手机，对应的Activity信息如下，这其中PermissionInfoActivity是点击“应用权限”的权限详情页面。

com.miui.packageinstaller/com.miui.packageInstaller.NewPackageInstallerActivity: +220ms
com.miui.packageinstaller/com.miui.packageInstaller.NormalInstallReadyActivity: +97ms
com.miui.packageinstaller/com.android.packageinstaller.miui.PermissionInfoActivity: +97ms
com.miui.packageinstaller/com.miui.packageInstaller.InstallProgressActivity: +99ms

发现整个安装过程是执行在小米系统miui的"com.miui.packageinstaller"中，那么可想而知在原生Android系统也有对应的Activity。

APK包体越大，安装时间就越长，因为需要解析和校验的越多。无论哪种方式，安装完成后都会通知到桌面应用Launcher，Launcher在桌面上添加一个App图标。这就是用户感受到的安装过程。

好了，APK安装过程就讲完了！

—— 并没有😄，APK安装具体过程是怎样的？我们是Android应用开发者，read the source code！

阅读源码是一件痛苦的事情，一般需要结合其他资料一起理解。并且，重点掌握整体流程即可。

二、认识 PMS

我们先来了解一个类：PackageManagerService（PMS），通过名字你可能会想起和四大组件紧密相关的 ActivityManagerService（AMS），它俩都是运行在SystemServer进程，App端和AMS、PMS进行交互都是通过Binder跨进程完成。AMS负责Activity等四大组件的管理，而PMS则负责包package 的管理，APK的全称是Android Package，即PMS的作用就是管理APK。

除了这里的PMS，在之前相关文章中还介绍了 ActivityManagerService（AMS）、WindowManagerService（WMS）。

2.1 PMS的使用

在平时开发中，我们会需要获取当前已安装的包的相关信息，例如已安装应用列表等，就可以在Activity中这么写：

PackageManager packageManager = getPackageManager();
// 获取所有已安装程序的包信息
List<PackageInfo> packages = packageManager.getInstalledPackages(0);

getPackageManager() 实际是Context的方法，具体实现是 ContextImpl 中：

@Override
public PackageManager getPackageManager() {
    if (mPackageManager != null) {
        return mPackageManager;
    }

    final IPackageManager pm = ActivityThread.getPackageManager();
    final IPermissionManager permissionManager = ActivityThread.getPermissionManager();
    if (pm != null && permissionManager != null) {
        // Doesn't matter if we make more than one instance.
        return (mPackageManager = new ApplicationPackageManager(this, pm, permissionManager));
    }

    return null;
}

注意获取到的 PackageManager 实际是 ApplicationPackageManager，构造方法中传入了通过 ActivityThread 获取的 IPackageManager、IPermissionManager。并且查看ApplicationPackageManager，会发现基本所有方法都是对传入的 pm的封装：

public List<PackageInfo> getInstalledPackagesAsUser(int flags, int userId) {
    try {
        //调用PM的对应方法
        ParceledListSlice<PackageInfo> parceledList =
                mPM.getInstalledPackages(updateFlagsForPackage(flags, userId), userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}

我们再看看 ActivityThread.getPackageManager() 如何获取 IPackageManager ：

public static IPackageManager getPackageManager() {
    if (sPackageManager != null) {
        return sPackageManager;
    }
    final IBinder b = ServiceManager.getService("package");
    sPackageManager = IPackageManager.Stub.asInterface(b);
    return sPackageManager;
}

到这里如果你对AMS的跨进程（IPC）比较熟，就会知道这里同样是为了IPC，即获取 SystemServer中 PMS 在App端的代理 IPackageManager。也就说，上面在Activity中通过getPackageManager()获取已安装应用列表，最后是IPC到了系统进程，在 PMS 中执行。类图如下：

image.png

2.2 PMS的初始化

那么 PMS 什么时候完成初始化的呢？因为所有App运行都需要这些系统服务，所以必然是系统开机的时候完成 PMS、AMS这些的初始化：

//SystemServer.java
/**
 * The main entry point from zygote.
 */
public static void main(String[] args) {
    new SystemServer().run();
}

private void run() {
        ...
        // Here we go!
        Slog.i(TAG, "Entered the Android system server!");
        ...
        // Prepare the main looper thread (this thread).
        Looper.prepareMainLooper();
        ...
    // Start services. 
        startBootstrapServices(t); //系统开启中 具有复杂相互依赖性的 关键服务
        startCoreServices(t); //没有复杂依赖的核心服务
        startOtherServices(t); //其他服务
        ...
    // Loop forever.
    Looper.loop();
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

在开机系统启动时，zygote 进程会fork一个 SystemServer 进程然后执行上面main方法，这里进行大量的初始化，其中就包括 启动各种服务。这里我们看startBootstrapServices():

private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
    ...
    // Installer 
    Installer installer = mSystemServiceManager.startService(Installer.class);
    ...
    //AMS
    mActivityManagerService = ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm);
    mActivityManagerService.setInstaller(installer);
    ...
    //PMS
    mPackageManagerService = PackageManagerService.main(mSystemContext, installer,mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
    ...
}

发现这里开启了 AMS、PMS，并且都使用了Installer。Installer 看名字像是安装器，后面再做介绍。PMS的main方法内用构造方法创建了PMS实例，而它的构造方法内容特别多，我们关注其中一句调用scanDirTracedLI()：

/** data/app，已安装app的目录 */
private static final File sAppInstallDir = new File(Environment.getDataDirectory(), "app");

public PackageManagerService(Injector injector, boolean onlyCore, boolean factoryTest){
    ...
    //读取packages.xml中 上次的包信息，解析后将数据存放到mSettings中
    mFirstBoot = !mSettings.readLPw(mInjector.getUserManagerInternal().getUsers(false));
    ...
    //扫描 data/app
    scanDirTracedLI(sAppInstallDir, 0, scanFlags | SCAN_REQUIRE_KNOWN, 0,packageParser, executorService);
    ...
    //把新的 mSettings 内容更新到 packages.xml
    mSettings.writeLPr();
    ...
}

packages.xml：记录系统中 所有安装的应用信息，包括基本信息、签名和权限。
mSettings：用来保存和PMS相关的一些设置，它保存的内容在解析应用时会用到。

先读取packages.xml文件，解析后将数据存放到mSettings中，代表上次启动时的应用包信息。然后扫描所有APK目录并解析APK，最后更新packages.xml文件。而 packages.xml文件是在 Settings 构造方法中创建。

data/app 是用户已安装App所在的目录，另外还有system/app存放系统App。PMS构造方法中会对这两个目录在内的多个目录进行扫描，我们这里可以猜想到这是开机时对所有已安装App的初始化。scanDirTracedLI()又走到scanDirLI()，那么就来详细看看怎么扫描的：

private void scanDirLI(File scanDir, int parseFlags, int scanFlags, long currentTime,
        PackageParser2 packageParser, ExecutorService executorService) {
    ...
    ParallelPackageParser parallelPackageParser = new ParallelPackageParser(packageParser, executorService);
    //并行解析所有package
    for (File file : files) {
        parallelPackageParser.submit(file, parseFlags);
    }
    ...
    //处理解析结果
    for (; fileCount > 0; fileCount--) {
        ParallelPackageParser.ParseResult parseResult = parallelPackageParser.take();
        addForInitLI(parseResult.parsedPackage, parseFlags, scanFlags, currentTime, null);
    }
    ...
}

使用 ParallelPackageParser 对目录内的所有apk进行解析然后使用 addForInitLI()处理解析结果parseResult。ParallelPackageParser 实际是对 PackageParser2 的使用上的封装，APK解析操作会走到 PackageParser2 的 parsePackage():

//PackageParser2.java
public ParsedPackage parsePackage(File packageFile, int flags, boolean useCaches) {
    ...
    ParseResult<ParsingPackage> result = parsingUtils.parsePackage(input, packageFile, flags);
    ParsedPackage parsed = (ParsedPackage) result.getResult().hideAsParsed();
    ...
    return parsed;
}

这里parsingUtils 是 ParsingPackageUtils 的实例，继续看parsingUtils.parsePackage():

//ParsingPackageUtils.java
public ParseResult<ParsingPackage> parsePackage(ParseInput input, File packageFile,int flags){
    //两个分支 都会走到parseBaseApk()
    if (packageFile.isDirectory()) { //是目录
        return parseClusterPackage(input, packageFile, flags);
    } else {
        return parseMonolithicPackage(input, packageFile, flags);
    }
}

两个分支都会走到parseBaseApk()：

private ParseResult<ParsingPackage> parseBaseApk(ParseInput input, File apkFile,String codePath, AssetManager assets, int flags) {
    ...
    XmlResourceParser parser = assets.openXmlResourceParser(cookie,PackageParser.ANDROID_MANIFEST_FILENAME)) {
    final Resources res = new Resources(assets, mDisplayMetrics, null);
    ParseResult<ParsingPackage> result = parseBaseApk(input, apkPath, codePath, res,parser, flags);
    ...
}

这里创建了 XmlResourceParser 实例，适用于解析APK的AndroidManifest.xml 文件，然后调用了重载的parseBaseApk()：

private ParseResult<ParsingPackage> parseBaseApk(ParseInput input, String apkPath,
        String codePath, Resources res, XmlResourceParser parser, int flags){
    ...
    //创建ParsingPackage实例 用于承接解析结果
    final ParsingPackage pkg = mCallback.startParsingPackage(pkgName, apkPath, codePath, manifestArray, isCoreApp);
    //解析apk 结果存入 pkg，包括 所有的activity、sevice等信息
    final ParseResult<ParsingPackage> result = parseBaseApkTags(input, pkg, manifestArray, res, parser, flags);
    return input.success(pkg);
    ...
}

parseBaseApkTags()内部使用 XmlResourceParser 查找 AndroidManifest.xml中的 Application 标签，然后调用 parseBaseApplication() 来解析 APK中的基础 Application 节点树：

private ParseResult<ParsingPackage> parseBaseApplication(ParseInput input,  ParsingPackage pkg, Resources res, XmlResourceParser parser, int flags){
   ...
   //解析Application标签的属性：theme、AllowBackup 这些
   parseBaseAppBasicFlags(pkg, sa);
   ...
    while ((type = parser.next()) != XmlPullParser.END_DOCUMENT && (type != XmlPullParser.END_TAG || parser.getDepth() > depth)) {
       ...
        final ParseResult result;
        String tagName = parser.getName();
        boolean isActivity = false;
        switch (tagName) {
            case "activity":
                isActivity = true;
            case "receiver":
                ParseResult<ParsedActivity> activityResult = ParsedActivityUtils.parseActivityOrReceiver(mSeparateProcesses, pkg, res, parser, flags, PackageParser.sUseRoundIcon, input); 
                if (activityResult.isSuccess()) {
                    ParsedActivity activity = activityResult.getResult();
                    if (isActivity) {
                        hasActivityOrder |= (activity.getOrder() != 0);
                        pkg.addActivity(activity); //添加Activity
                    } else {
                        hasReceiverOrder |= (activity.getOrder() != 0);
                        pkg.addReceiver(activity);//添加Receiver
                    }
                } 
                result = activityResult;
                break;
            case "service":
                ParseResult<ParsedService> serviceResult =
                        ParsedServiceUtils.parseService(mSeparateProcesses, pkg, res, parser, flags, PackageParser.sUseRoundIcon, input);
                if (serviceResult.isSuccess()) {
                    ParsedService service = serviceResult.getResult();
                    hasServiceOrder |= (service.getOrder() != 0);
                    pkg.addService(service); //添加Service
                } 
                result = serviceResult;
                break;
            case "provider":
                ParseResult<ParsedProvider> providerResult = ParsedProviderUtils.parseProvider(mSeparateProcesses, pkg, res, parser, flags, PackageParser.sUseRoundIcon, input);
                if (providerResult.isSuccess()) {
                    pkg.addProvider(providerResult.getResult());//添加Provider
                } 
                result = providerResult;
                break;
            ...
        }...
    }
...
    return input.success(pkg);
}

这里就是解析Application的子节点——四大组件，并把信息存入ParsingPackage实例pkg中，最后转成 ParallelPackageParser.ParseResult。那么再回到 PMS构造方法，解析后调用了 addForInitLI()，这个方法逻辑复杂，有很多对系统应用的校验（包名修改、版本升级、签名手收集和校验)，但我们只关注下面内容:

//PMS.java
private AndroidPackage addForInitLI(ParsedPackage parsedPackage,@ParseFlags int parseFlags, @ScanFlags int scanFlags, long currentTime,@Nullable UserHandle user){
    ...
    //继续扫描
    final ScanResult scanResult = scanPackageNewLI(parsedPackage, parseFlags, scanFlags | SCAN_UPDATE_SIGNATURE, currentTime, user, null);
    if (scanResult.success) {
        synchronized (mLock) {
            boolean appIdCreated = false;
            try {
                final String pkgName = scanResult.pkgSetting.name;
                final Map<String, ReconciledPackage> reconcileResult =  reconcilePackagesLocked(new ReconcileRequest( Collections.singletonMap(pkgName, scanResult), mSharedLibraries, mPackages, Collections.singletonMap(pkgName, getSettingsVersionForPackage(parsedPackage)), Collections.singletonMap(pkgName, getSharedLibLatestVersionSetting(scanResult))),mSettings.mKeySetManagerService);
                appIdCreated = optimisticallyRegisterAppId(scanResult);
                //提交包扫描结果、更新系统状态
                commitReconciledScanResultLocked(reconcileResult.get(pkgName), mUserManager.getUserIds());
            } 
           ...
        }
    }...
    return scanResult.pkgSetting.pkg;
}

调用scanPackageNewLI()继续扫描，主要是更新 packageSetting（PackageSetting主要包含了一个APP的基本信息，如安装位置，lib位置等信息）。然后调用reconcilePackagesLocked()进行一致化处理，调用commitReconciledScanResultLocked() 提交包扫描结果、更新系统状态，内部又调用了commitPackageSettings():

//向系统添加扫描完成的包。那么这个包对于系统成为可用状态。
private void commitPackageSettings(AndroidPackage pkg,@Nullable AndroidPackage oldPkg, PackageSetting pkgSetting,inal @ScanFlags int scanFlags, booleanchatty,ReconciledPackage reconciledPkg) {
    final String pkgName = pkg.getPackageName();
    ...
    synchronized (mLock) {
        //添加到mSettings
        mSettings.insertPackageSettingLPw(pkgSetting, pkg);
        //添加到mPackages
        mPackages.put(pkg.getPackageName(), pkg);
        //添加组件到mComponentResolver：所有的四大组件信息添加到内部数据结构中
        mComponentResolver.addAllComponents(pkg, chatty);
        ...
        //记录权限到PermissionManagerService中
        mPermissionManager.addAllPermissions(pkg, chatty);
        ...
        //添加mInstrumentation
        for (i = 0; i < collectionSize; i++) {
            ParsedInstrumentation a = pkg.getInstrumentations().get(i);
            a.setPackageName(pkg.getPackageName());
            mInstrumentation.put(a.getComponentName(), a);...
        }
        ...
}

也就是包信息记录在了PMS的属性中。也就是说，系统启动后，包信息记录在了PMS管理的内存中。

小结一下，系统启动后创建并启动了PMS，并且PMS完成了对所有存在APK的目录进行了扫描，解析所有APK的AndroidManifest.xml，然后进一步扫描APK 最后提交包扫描结果到 PMS 的属性中。

以上就是对开机启动时 APK安装流程的简单理解。那么，下面就来看看 APK安装普通流程。

三、APK的安装过程

上面提到，普通的应用安装过程是执行在小米系统miui的"com.miui.packageinstaller"中，安装过程涉及几个Activity，我们来看看如何使用代码安装一个APK文件，以及原生Android系统是哪些Activity。

3.1 发起

安装APK的代码如下：

File file = new File(getExternalFilesDir(null), "xxx.apk");

Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
Uri apkUri =FileProvider.getUriForFile(this, "com.xxx.xxx.fileprovider", file);
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
intent.setDataAndType(apkUri, "application/vnd.android.package-archive");
startActivity(intent);

Action是Intent.ACTION_VIEW，type是"application/vnd.android.package-archive"，这次使用 api 30的原生模拟器，Activity信息如下：

com.google.android.packageinstaller/com.android.packageinstaller.InstallStaging: +349ms
com.google.android.packageinstaller/com.android.packageinstaller.PackageInstallerActivity: +1s516ms
com.android.settings/.Settings$ManageAppExternalSourcesActivity: +385ms
com.google.android.packageinstaller/com.android.packageinstaller.InstallInstalling: +296ms
com.google.android.packageinstaller/com.android.packageinstaller.InstallSuccess: +375ms

过程截图如下：

image.png

InstallStaging，对应图1：从content URI 读取 apk 文件
PackageInstallerActivity，对应图2、图4，解析apk 提示未知来源安装的设置，以及展示APK icon和名称并提示安装确认。
ManageAppExternalSourcesActivity，图3，设置页面-允许未知来源安装
InstallInstalling，图5，安装中
InstallSuccess，图6，安装完成。

我们从InstallStaging开始看起：

public class InstallStaging extends AlertActivity {
    private @Nullable StagingAsyncTask mStagingTask;
    private @Nullable File mStagedFile;
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState); ...
        setupAlert(); //展示ui ...
    }
    protected void onResume() {...
            mStagingTask = new StagingAsyncTask(); 
            mStagingTask.execute(getIntent().getData()); //开启AsyncTask 读取 apk文件
        }
    }
    protected void onSaveInstanceState(Bundle outState) {
        outState.putString(STAGED_FILE, mStagedFile.getPath());
    }
    ...
    private final class StagingAsyncTask extends AsyncTask<Uri, Void, Boolean> {
        protected Boolean doInBackground(Uri... params) {...
            try (InputStream in = getContentResolver().openInputStream(packageUri)) {
                ...
                try (OutputStream out = new FileOutputStream(mStagedFile)) {
                    byte[] buffer = new byte[1024 * 1024];
                    int bytesRead;
                    while ((bytesRead = in.read(buffer)) >= 0) {...
                        out.write(buffer, 0, bytesRead);...
        }
        protected void onPostExecute(Boolean success) {
            if (success) {
                // Now start the installation again from a file
                Intent installIntent = new Intent(getIntent());
                installIntent.setClass(InstallStaging.this, DeleteStagedFileOnResult.class);
                installIntent.setData(Uri.fromFile(mStagedFile));
                if (installIntent.getBooleanExtra(Intent.EXTRA_RETURN_RESULT, false)) {
                    installIntent.addFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT);
                }
                installIntent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
                startActivity(installIntent); //读取完成后，启动 DeleteStagedFileOnResult 
                InstallStaging.this.finish();
            } ...
        }
    }
}

只做了一件事，开启AsyncTask 读取 apk文件，然后启动了activity DeleteStagedFileOnResult，这是个跳板页面，里面直接透传 intent 启动了 PackageInstallerActivity：

public class PackageInstallerActivity extends AlertActivity {
    ...
    private int mSessionId = -1;
    PackageManager mPm;
    IPackageManager mIpm;...
    PackageInstaller mInstaller;
    PackageInfo mPkgInfo; //解析apk得到的PackageInfo
    ...
    protected void onCreate(Bundle icicle) {
    ...
        mPm = getPackageManager(); //ApplicationPackageManager
        mInstaller = mPm.getPackageInstaller(); // mInstaller，安装器

        final Intent intent = getIntent();
        final Uri packageUri;
        ...
        boolean wasSetUp = processPackageUri(packageUri); //解析APK
        if (!wasSetUp) {
            return;
        }

        // 初始化ui
        bindUi();
        //检查"未知来源安装"，展示 安装确认 提示
        checkIfAllowedAndInitiateInstall();
    }
...
private boolean processPackageUri(final Uri packageUri) {
    mPackageURI = packageUri;

    final String scheme = packageUri.getScheme();

    switch (scheme) {
    ...
        case ContentResolver.SCHEME_FILE: {
            File sourceFile = new File(packageUri.getPath());
            //解析APK，注意参数是 GET_PERMISSIONS
            mPkgInfo = PackageUtil.getPackageInfo(this, sourceFile,PackageManager.GET_PERMISSIONS); 
            //获取apk摘要：图标、名字
            mAppSnippet = PackageUtil.getAppSnippet(this, mPkgInfo.applicationInfo, sourceFile);
            ...
        } break;
    ...
    }
    return true;
}


//点击”安装“，跳转 InstallInstalling - 开始安装
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 (installerPackageName != null) {
        newIntent.putExtra(Intent.EXTRA_INSTALLER_PACKAGE_NAME, installerPackageName);
    }
    newIntent.addFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT);
    startActivity(newIntent);
    finish();
}

整体逻辑比较清晰：

在 PackageInstallerActivity 的 onCreate() 初始化mPm、mInstaller，
使用 PackageUtil.getPackageInfo() 解析APK权限信息（可用于安装前展示给用户），注意参数flags 是 PackageManager.GET_PERMISSIONS；使用PackageUtil.getAppSnippet()获取apk摘要：图标、名字。
然后使用 checkIfAllowedAndInitiateInstall() 是检查APK来源，展示"未知来源APK安装"的对话框，当点击"settings"按钮后跳转到设置页.
打开允许未知来源安装后回到 PackageInstallerActivity，在 onActivityResult()中，展示"确认安装"提示，点击”安装“，跳转 InstallInstalling - 开始安装.

我们先看包信息 PackageInfo 的解析过程——PackageUtil.getPackageInfo():

//PackageUtil.java
public static PackageInfo getPackageInfo(Context context, File sourceFile, int flags) {
    ...
    return context.getPackageManager().getPackageArchiveInfo(sourceFile.getAbsolutePath(),flags);
}

继续看PackageManager的getPackageArchiveInfo()：

//PackageManager.java
public PackageInfo getPackageArchiveInfo(@NonNull String archiveFilePath,@PackageInfoFlags int flags) {
    ...
    ParseInput input = ParseTypeImpl.forParsingWithoutPlatformCompat().reset();
    ParseResult<ParsingPackage> result = ParsingPackageUtils.parseDefault(input,
            new File(archiveFilePath), 0, collectCertificates);
    ...
    return PackageInfoWithoutStateUtils.generate(result.getResult(), null, flags, 0, 0, null,
            new PackageUserState(), UserHandle.getCallingUserId());
}

调用了 ParsingPackageUtils 的静态方法parseDefault()，里面创建了 ParsingPackageUtils 实例，继续调用它的 parsePackage()。上面介绍的 PMS 构造方法中解析APK 也是 ParsingPackageUtils的 parsePackage()，只是这里的参数flags 是 PackageManager.GET_PERMISSIONS，只解析了权限信息。这里不再跟踪进去了。

最终解析获取到了apk所有信息的 PackageInfo，然后点击”安装“ 跳转到了 InstallInstalling。

3.2 Session：发送包到PMS

直接看 InstallInstalling：

//两个逻辑：发送包到PMS、处理从PMS得到的安装结果
public class InstallInstalling extends AlertActivity {
    ...
    //发送包到installer
    private InstallingAsyncTask mInstallingTask;
    //安装mSessionId
    private int mSessionId;
    ...
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        ApplicationInfo appInfo = getIntent().getParcelableExtra(PackageUtil.INTENT_ATTR_APPLICATION_INFO);
        mPackageURI = getIntent().getData();
        ...
        PackageInstaller.SessionParams params = new PackageInstaller.SessionParams(PackageInstaller.SessionParams.MODE_FULL_INSTALL);
         ...
        //安装结果监听。在收到安装结果的广播后 会调用此 Observer
        mInstallId = InstallEventReceiver.addObserver(this, EventResultPersister.GENERATE_NEW_ID,this::launchFinishBasedOnResult);
        ...
        //IPC：PackageInstaller 内部会通过 IPackageInstaller 走到PackageInstallerService 的 createSession 方法来创建
        mSessionId = getPackageManager().getPackageInstaller().createSession(params);
        ...
        }
    }
    ...
    protected void onResume() {
        super.onResume();
        if (mInstallingTask == null) {
            PackageInstaller installer = getPackageManager().getPackageInstaller();
            PackageInstaller.SessionInfo sessionInfo = installer.getSessionInfo(mSessionId);
            if (sessionInfo != null && !sessionInfo.isActive()) {
            //开启任务发送包信息到 session中，实际是
                mInstallingTask = new InstallingAsyncTask();
                mInstallingTask.execute();
            }...
        }
    }
    ...
    private void launchFinishBasedOnResult(int statusCode, int legacyStatus, String statusMessage) {
        if (statusCode == PackageInstaller.STATUS_SUCCESS) {
            launchSuccess(); //打开安装成功页面 InstallSuccess
        } else {
            launchFailure(legacyStatus, statusMessage); //安装失败页面 InstallFailed
        }
    }
    ...
    //发送包到 installer
    private final class InstallingAsyncTask extends AsyncTask<Void, Void,PackageInstaller.Session> {
        @Override
        protected PackageInstaller.Session doInBackground(Void... params) {
            PackageInstaller.Session session;
            ...
            session = getPackageManager().getPackageInstaller().openSession(mSessionId);
            try {
                File file = new File(mPackageURI.getPath());
                try (InputStream in = new FileInputStream(file)) {
                    long sizeBytes = file.length();

                    //从session获取的输出流
                    try (OutputStream out = session.openWrite("PackageInstaller", 0, sizeBytes)) {
                        byte[] buffer = new byte[1024 * 1024];
                        while (true) {
                            int numRead = in.read(buffer);
                            ...
                            out.write(buffer, 0, numRead);
                            if (sizeBytes > 0) {
                                float fraction = ((float) numRead / (float) sizeBytes);
                                session.addProgress(fraction);
                    }
                }
                return session;
            }
            ...
        }
        @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后，进行提交
                session.commit(pendingIntent.getIntentSender());
                mCancelButton.setEnabled(false);
                setFinishOnTouchOutside(false);
                ...
            }
}

整体过程如下：

onCreate 中通过 PackageInstaller 创建Session 并返回 mSessionId
onResume 中开启InstallingAsyncTask，把包信息写入mSessionId对应的session，然后提交。
onCreate 中添加了安装结果的监听，在收到安装结果的广播后会调用此跳转到对应结果页面。

PackageInstaller，APK安装器，是在ApplicationPackageManager的 getPackageInstaller()中创建：

//是在ApplicationPackageManager的.java
public PackageInstaller getPackageInstaller() {
    synchronized (mLock) {
        if (mInstaller == null) {
            mInstaller = new PackageInstaller(mPM.getPackageInstaller(), mContext.getPackageName(), getUserId());
            ...
        }
        return mInstaller;
    }
}

是对 mPM.getPackageInstaller() 获取的 IPackageInstaller实例的封装，而 IPackageInstaller 在系统服务端的具体实现是 PackageInstallerService。

且 PackageInstallerService 的实例是在 PMS 的构造方法中创建的，初始化时会读取 /data/system 目录下的 install_sessions.xml 文件，这个文件中保存了系统中未完成的 Install Session。PMS 会根据文件的内容创建 PackageInstallerSession 对象并插入到 mSessions 中。

PackageInstaller 提供了应用安装、更新、移除的能力，当然具体实现是 IPC 到了 PackageInstallerService中。

Session，是与 mSessionId绑定的安装会话，代表一个进行中的安装。Session类是对 IPackageInstaller.openSession(sessionId) 获取的 PackageInstallerSession（系统服务端）的封装。Session 管理安装的参数，并提供将安装包临时复制到特定路径（data/app-staging）的能力。

Session的创建和打开具体实现是在 PackageInstallerService中，主要是初始化apk的安装信息及环境，并创建一个sessionId，将安装Session与sessionId 进行绑定。（代码较多，就不放了）

我们重点看 把包信息写入mSessionId对应的session，然后提交，回到 InstallInstalling 中，看到在 InstallingAsyncTask 中执行了对 APK包文件的读取和写入操作，写入的输出流是通过Session获取，也即是把 将APK文件写入了Session 。完成后又调用了 session.commit()，具体实现是在PackageInstallerSession，来看看：

//PackageInstallerSession.java
public void commit(@NonNull IntentSender statusReceiver, boolean forTransfer) {
    ...
    dispatchStreamValidateAndCommit();
}

private void dispatchStreamValidateAndCommit() {
    mHandler.obtainMessage(MSG_STREAM_VALIDATE_AND_COMMIT).sendToTarget();
}

发送了一个handler消息，最后执行在 handleStreamValidateAndCommit()中，然后里面又发送了消息MSG_INSTALL，这个执行在handleInstall()：

private final Handler.Callback mHandlerCallback = new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        switch (msg.what) {
            case MSG_STREAM_VALIDATE_AND_COMMIT:
                handleStreamValidateAndCommit(); //
                break;
            case MSG_INSTALL:
                handleInstall(); //
                break;
            ...
        }
        return true;
    }
};

private void handleInstall() {
    ...
    List<PackageInstallerSession> childSessions = getChildSessionsNotLocked();

    installNonStagedLocked(childSessions);
    ...
}

private void installNonStagedLocked(List<PackageInstallerSession> childSessions) {
    final PackageManagerService.ActiveInstallSession installingSession = makeSessionActiveLocked();
     ...
     //安装走到了 PMS 中
     mPm.installStage(installingSession);
  ...
}

最后，安装过程走到了 PMS 的 installStage()。

目前为止，只是通过 PackageInstaller 维持了安装 Session，把安装包写入到 Session中，真正的安装过程是 PMS 来执行。

3.3 PMS中的安装

那就直接看 PMS 的 installStage()：

//PMS
void installStage(ActiveInstallSession activeInstallSession) {
    ...
    final Message msg = mHandler.obtainMessage(INIT_COPY);
    final InstallParams params = new InstallParams(activeInstallSession);
    msg.obj = params;
    mHandler.sendMessage(msg);
}

mHandler 处理INIT_COPY是 params.startCopy():

//HandlerParams.java
final void startCopy() {
    handleStartCopy();
    handleReturnCode();
}

调用了两个方法实现是在 InstallParams 中：

public void handleStartCopy() {
    int ret = PackageManager.INSTALL_SUCCEEDED;
    ...
    PackageInfoLite pkgLite = null;
    //解析包 返回最小的细节:pkgName、versionCode、安装所需空间大小、获取安装位置等
    pkgLite = PackageManagerServiceUtils.getMinimalPackageInfo(mContext,origin.resolvedPath, installFlags, packageAbiOverride);
    ...
    if (ret == PackageManager.INSTALL_SUCCEEDED) {
        //以下是 获取安装位置失败情况
        int loc = pkgLite.recommendedInstallLocation;
        if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_LOCATION) {//安装位置无效
            ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
        } else if (loc == PackageHelper.RECOMMEND_FAILED_ALREADY_EXISTS) {//已存在包
            ret = PackageManager.INSTALL_FAILED_ALREADY_EXISTS;
        } else if (loc == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {//空间不够
            ret = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
        } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_APK) {//apk无效
            ret = PackageManager.INSTALL_FAILED_INVALID_APK;
        } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_URI) {//uri无效
            ret = PackageManager.INSTALL_FAILED_INVALID_URI;
        } else if (loc == PackageHelper.RECOMMEND_MEDIA_UNAVAILABLE) {//
            ret = PackageManager.INSTALL_FAILED_MEDIA_UNAVAILABLE;
        } else {
            ...
    }

    final InstallArgs args = createInstallArgs(this);//安装参数
    mVerificationCompleted = true;
    mIntegrityVerificationCompleted = true;
    mArgs = args;
    //如果
    if (ret == PackageManager.INSTALL_SUCCEEDED) {
        final int verificationId = mPendingVerificationToken++;

        //apk完整性校验
        if (!origin.existing) {
            PackageVerificationState verificationState =new PackageVerificationState(this);
            mPendingVerification.append(verificationId, verificationState);

            sendIntegrityVerificationRequest(verificationId, pkgLite, verificationState);
            ret = sendPackageVerificationRequest(verificationId, pkgLite, verificationState);
            ...
        }
    ...
    mRet = ret; //赋值 returnCode
}

解析包返回最小的细节：pkgName、versionCode、安装所需空间大小；确认包安装位置；校验APK完整性。获取结果mRet。然后就看 handleReturnCode()：

    void handleReturnCode() {
        if (mVerificationCompleted && mIntegrityVerificationCompleted && mEnableRollbackCompleted) {
            ...
            //如果前面校验ok，这里执行apk拷贝
            if (mRet == PackageManager.INSTALL_SUCCEEDED) {
                mRet = mArgs.copyApk();
            }
            //执行安装
            processPendingInstall(mArgs, mRet);
        }
    }
}

判断mRet，执行apk拷贝，然后执行安装。先看 mArgs.copyApk()如何拷贝：

//FileInstallArgs.java
int copyApk() {
    return doCopyApk();
}

private int doCopyApk() {
    //获取拷贝文件路径：/data/app
    try {
        final boolean isEphemeral = (installFlags & PackageManager.INSTALL_INSTANT_APP) != 0;
        final File tempDir =
                mInstallerService.allocateStageDirLegacy(volumeUuid, isEphemeral);
        codeFile = tempDir;
        resourceFile = tempDir;
    } catch (IOException e) {
        Slog.w(TAG, "Failed to create copy file: " + e);
        return PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
    }

    //拷贝apk
    int ret = PackageManagerServiceUtils.copyPackage(
            origin.file.getAbsolutePath(), codeFile);
    if (ret != PackageManager.INSTALL_SUCCEEDED) {
        Slog.e(TAG, "Failed to copy package");
        return ret;
    }

    final boolean isIncremental = isIncrementalPath(codeFile.getAbsolutePath());
    final File libraryRoot = new File(codeFile, LIB_DIR_NAME);
    NativeLibraryHelper.Handle handle = null;
    try {
        handle = NativeLibraryHelper.Handle.create(codeFile);
        //拷贝Native代码 即 .so文件
        ret = NativeLibraryHelper.copyNativeBinariesWithOverride(handle, libraryRoot,
                abiOverride, isIncremental);
    } catch (IOException e) {
        Slog.e(TAG, "Copying native libraries failed", e);
        ret = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
    }...

    return ret;
}

在FileInstallArgs中的copyApk()走到doCopyApk()，先获取了拷贝文件路径：/data/app，使用PackageManagerServiceUtils.copyPackage()进行APK拷贝，接着是 .so文件的拷贝。也就是说，把发送到 Session暂存目录 data/app-staging 的APK 拷贝到了 /data/app。

接着看执行安装processPendingInstall(mArgs, mRet)：

//PMS.java
private void processPendingInstall(final InstallArgs args, final int currentStatus) {
    ...
    //res，用于存 安装结果
    PackageInstalledInfo res = createPackageInstalledInfo(currentStatus);
    processInstallRequestsAsync(res.returnCode == PackageManager.INSTALL_SUCCEEDED,Collections.singletonList(new InstallRequest(args, res)));
    ...
}

//安装操作 使用handler入队
private void processInstallRequestsAsync(boolean success, List<InstallRequest>installRequests) {
    mHandler.post(() -> {
        if (success) {
            for (InstallRequest request : installRequests) {
                //安装前检验：returnCode不为INSTALL_SUCCEEDED就移除拷贝的apk等
                request.args.doPreInstall(request.installResult.returnCode);
            }
            synchronized (mInstallLock) {
                //安装：解析apk
                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() 又走到 installPackagesLI():

private void installPackagesLI(List<InstallRequest> requests) {
    ...
    try {
        for (InstallRequest request : requests) {
            final PrepareResult prepareResult;
            //1.准备：分析当前安装状态，解析包并初始验证
            prepareResult = preparePackageLI(request.args, request.installResult);
            ...
            try {
                //2.扫描：根据准备阶段解析的包信息上下文 进一步解析
                final ScanResult result = scanPackageTracedLI(prepareResult.packageToScan, prepareResult.parseFlags,prepareResult.scanFlags, System.currentTimeMillis(),request.args.user, request.args.abiOverride);
                ...
                //注册appId
                createdAppId.put(packageName, optimisticallyRegisterAppId(result));
               //保存version信息
                versionInfos.put(result.pkgSetting.pkg.getPackageName(),getSettingsVersionForPackage(result.pkgSetting.pkg));
            }
            ...
        }
        ReconcileRequest reconcileRequest = new ReconcileRequest(preparedScans, installArgs,installResults,prepareResults,mSharedLibraries,Collections.unmodifiableMap(mPackages), versionInfos,lastStaticSharedLibSettings);
        CommitRequest commitRequest = null;
        synchronized (mLock) {
            Map<String, ReconciledPackage> reconciledPackages;
            try {
                //3.核对：验证扫描后的包信息和系统状态，确保安装成功
                reconciledPackages = reconcilePackagesLocked(
                        reconcileRequest, mSettings.mKeySetManagerService);
            } catch (ReconcileFailure e) {
                for (InstallRequest request : requests) {
                    request.installResult.setError("Reconciliation failed...", e);
                }
                return;
            } 
            try {
                //4.提交：提交扫描的包、更新系统状态。这是唯一可以修改系统状态的地方，并且要对所有可预测的错误进行检测。
                commitRequest = new CommitRequest(reconciledPackages,
                        mUserManager.getUserIds());
                commitPackagesLocked(commitRequest);
                success = true;
            }
        }
        //安装成功的后续才做：准备app数据、编译布局资源、执行dex优化
        executePostCommitSteps(commitRequest);
    } ...
}

安装过程分四个阶段:

准备，分析当前安装状态，解析包 并初始校验：在 preparePackageLI() 内使用 PackageParser2.parsePackage() 解析AndroidManifest.xml，获取四大组件等信息；使用ParsingPackageUtils.getSigningDetails() 解析签名信息；重命名包最终路径等。
扫描，根据准备阶段解析的包信息上下文进一步解析：确认包名真实；根据解析出的信息校验包有效性（是否有签名信息等）；搜集apk信息——PackageSetting、apk的静态库/动态库信息等。
核对，验证扫描后的包信息，确保安装成功：主要就是覆盖安装的签名匹配验证。
提交，提交扫描的包、更新系统状态：添加 PackageSetting 到 PMS 的 mSettings、添加 AndroidPackage 到 PMS 的 mPackages 、添加秘钥集到系统、应用的权限添加到 mPermissionManager、四大组件信息添加到 mComponentResolver 。这是唯一可以修改系统状态的地方，并且要对所有可预测的错误进行检测。

前三步主要是解析和校验，第四部是把包信息提交到 PMS 内存数据结构中。其中解析和提交在上面的PMS初始化中扫描apk目录后也是同样的过程。这里就不再展开跟踪了。

安装完成后，调用了 executePostCommitSteps() 准备app数据、执行dex优化：

private void executePostCommitSteps(CommitRequest commitRequest) {
    ...
    for (ReconciledPackage reconciledPkg : commitRequest.reconciledPackages.values()) {
        ...
        //提供目录结构/data/user/用户ID/包名/cache（/data/user/用户ID/包名/code_cache）
        prepareAppDataAfterInstallLIF(pkg);
        ...
        //是否要dex opt
        final boolean performDexopt =
                (!instantApp || Global.getInt(mContext.getContentResolver(),
                Global.INSTANT_APP_DEXOPT_ENABLED, 0) != 0)
                && !pkg.isDebuggable()
                && (!onIncremental);

        if (performDexopt) {
            ...
            DexoptOptions dexoptOptions = new DexoptOptions(packageName,REASON_INSTALL,flags);
            ...
            //执行dex优化：dexopt 是对 dex 文件 进行 verification 和 optimization 的操作，其对 dex 文件的优化结果变成了 odex 文件，这个文件和 dex 文件很像，只是使用了一些优化操作码（譬如优化调用虚拟指令等）。
            mPackageDexOptimizer.performDexOpt(pkg, realPkgSetting,
                    null /* instructionSets */,
                    getOrCreateCompilerPackageStats(pkg),
                    mDexManager.getPackageUseInfoOrDefault(packageName),
                    dexoptOptions);
        }...
    }
}

prepareAppDataAfterInstallLIF()：提供目录结构/data/user/用户ID/包名/cache（/data/user/用户ID/包名/code_cache）
mPackageDexOptimizer.performDexOpt()：dexopt 是对 dex 文件进行 verification 和 optimization 的操作，其对 dex 文件的优化结果变成了 odex 文件，这个文件和 dex 文件很像，只是使用了一些优化操作码（譬如优化调用虚拟指令等）。

这两个操作最终都是使用 Installer 对应的方法来操作。前面介绍 PMS 创建时传入了 Installer 的实例，而 Installer 继承自 SystemService 也是一个系统服务。这里来看下：

public class Installer extends SystemService {

public void onStart() {
    if (mIsolated) {
        mInstalld = null;
    } else {
        connect();
    }
}

private void connect() {
    IBinder binder = ServiceManager.getService("installd");
    if (binder != null) {
        try {
            binder.linkToDeath(new DeathRecipient() {
                @Override
                public void binderDied() {
                    Slog.w(TAG, "installd died; reconnecting");
                    connect();
                }
            }, 0);
        } catch (RemoteException e) {
            binder = null;
        }
    }

    if (binder != null) {
        mInstalld = IInstalld.Stub.asInterface(binder);
        try {
            invalidateMounts();
        } catch (InstallerException ignored) {
        }
    } else {
        Slog.w(TAG, "installd not found; trying again");
        BackgroundThread.getHandler().postDelayed(() -> {
            connect();
        }, DateUtils.SECOND_IN_MILLIS);
    }
}

public long createAppData(String uuid, String packageName, int userId, int flags, int appId,
        String seInfo, int targetSdkVersion) throws InstallerException {
    if (!checkBeforeRemote()) return -1;
    try {
        return mInstalld.createAppData(uuid, packageName, userId, flags, appId, seInfo,
                targetSdkVersion);
    } catch (Exception e) {
        throw InstallerException.from(e);
    }
}

public void dexopt(String apkPath, int uid, @Nullable String pkgName, String instructionSet, int dexoptNeeded, @Nullable String outputPath ...) throws InstallerException {
    ...
    if (!checkBeforeRemote()) return;
    try {
        mInstalld.dexopt(apkPath, uid, pkgName, instructionSet, dexoptNeeded, outputPath,
                dexFlags, compilerFilter, volumeUuid, sharedLibraries, seInfo, downgrade,
                targetSdkVersion, profileName, dexMetadataPath, compilationReason);
    } catch (Exception e) {
        throw InstallerException.from(e);
    }
}

在 Installer onStart()方法中通过 installd 的Binder对象获取了 mInstalld 实例。可见这里是IPC操作，即 System_Server 进程中的 Installer IPC 到 具有root权限的守护进程。像目录 /data/user 的创建必须要有root权限。
PMS中使用了Installer的很多方法，Installer是Java层提供的Java API接口，Installd 则是在init进程启动的具有root权限的Daemon进程。

到这里安装完成，再回到 PMS 的 processInstallRequestsAsync()，最后调用restoreAndPostInstall()进行备份、可能的回滚、发送安装完成先关广播：

private void restoreAndPostInstall(
        int userId, PackageInstalledInfo res, @Nullable PostInstallData data) {
    ...
    Message msg = mHandler.obtainMessage(POST_INSTALL, token, 0);
    mHandler.sendMessage(msg);
    ...
}

mHandler 使用 PMS的 handlePackagePostInstall(）方法处理 POST_INSTALL：

根据安装结果发送 Intent.ACTION_PACKAGE_ADDED 等广播，桌面Launcher 收到广播后就会在桌上增加App的Icon
调用 PackageInstallSession 中保存的IPackageInstallObserver2实例的onPackageInstalled()方法，最后发送安装成功的通知显示在通知栏，通过 IntentSender 发送在 InstallInstalling 中就定义好的广播，最后 InstallInstalling页面根据结果展示安装成功/安装失败。

到这里，APK的安装过程就梳理完毕了，来回顾下：

APK用写入Session且包信息和APK安装操作都提交到了PMS；
PMS中先把APK拷贝到 /data/app，然后使用PackageParser2解析APK 获取四大组件、搜集签名、PackageSetting等信息，并进行校验确保安装成功；
接着提交信息包更新系统状态及PMS的内存数据；
然后使用 Installer 准备用户目录/data/user、进行 dexOpt；
最后发送安装结果通知UI层。

未命名文件.png

四、总结

本篇从用户感受的APK安装讲起，分别详细梳理了包管理器服务——PackageManagerService 的服务开启、初始化扫描过程；然后分析了对应原生系统的安装过程及页面；接着就是详细分析了安装流程，包括创建Session 发送APK、PMS中的APK拷贝操作、包括APK解析校验和dexOpt等具体安装流程；最后是安装结果的发送。

内容确实很多，但是我们只需要重点了解 PMS的初始化、APK安装的整体流程即可，无需关注繁杂的细节。

虽然耗费时不少时间阅读源码、也阅读了一些文章，但不免有错误和遗漏之处。欢迎讨论~

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2021-11-09，如有侵权请联系 cloudcommunity@tencent.com 删除

tcp/ip

android

xml

本文分享自胡飞洋微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

tcp/ip

android

xml