APK安装流程详解9——PackageParser解析APK(上)

APK安装流程系列文章整体内容如下：

APK安装流程详解0——前言

APK安装流程详解1——有关"安装ing"的实体类概述

APK安装流程详解2——PackageManager简介

APK安装流程详解3——PackageManager与PackageManagerService

APK安装流程详解4——安装中关于so库的哪些事

APK安装流程详解5——PackageInstallerService和Installer

APK安装流程详解6——PackageManagerService启动前奏

APK安装流程详解7——PackageManagerService的启动流程(上)

APK安装流程详解8——PackageManagerService的启动流程(下)

APK安装流程详解9——PackageParser解析APK(上)

APK安装流程详解10——PackageParser解析APK(下)

APK安装流程详解11——普通应用安装简介

APK安装流程详解12——PackageManagerService中的新安装流程上(拷贝)

APK安装流程详解13——PackageManagerService中的新安装流程下(装载)

APK安装流程详解14——PMS中的新安装流程上(拷贝)补充

APK安装流程详解15——PMS中的新安装流程下(装载)补充

APK安装流程详解16——Android包管理总结(尚未完结请期待)

本片文章的主要内容如下：

1、PackageParser类简介

2、PackageParser类的结构

3、PackageParser类的内部类简介

4、PackageParse#parsePackage(File, int)方法解析

5、PackageParse#parseMonolithicPackage(File, int)方法解析

6、PackageParse#parseMonolithicPackageLite(File, int)方法解析

7、PackageParse#parseApkLite(File,int)方法解析

8、PackageParse#parseApkLite(File,int)方法解析

9、PackageParse#parsePackageSplitNames(XmlpullParse，AttributeSet,int)方法解析

10、PackageParse#parseBaseApk(File,AssetManager,int)方法解析

11、PackageParse#parseBaseApk(Resources,XmlResourceParser,int,String[])方法解析

一、PackageParser类简介

PackageParser.java

Android 安装一个APK的时候首先会解析APK，而解析APK则需要用到一个工具类，这个工具类就是PackageParser

为了让咱们更好的理解谷歌的安卓团队对PackageParser的定位，我们来看下PackageParser的注释

(一)、PackageParser的注释

/**
 * Parser for package files (APKs) on disk. This supports apps packaged either
 * as a single "monolithic" APK, or apps packaged as a "cluster" of multiple
 * APKs in a single directory.
 * <p>
 * Apps packaged as multiple APKs always consist of a single "base" APK (with a
 * {@code null} split name) and zero or more "split" APKs (with unique split
 * names). Any subset of those split APKs are a valid install, as long as the
 * following constraints are met:
 * <ul>
 * <li>All APKs must have the exact same package name, version code, and signing
 * certificates.
 * <li>All APKs must have unique split names.
 * <li>All installations must contain a single base APK.
 * </ul>
 *
 * @hide
 */
public class PackageParser {
          ...
}

简单翻译下：

解析磁盘上的APK安装包文件。它既能解析一个"单一"APK文件，也能解析一个"集群"APK文件(即一个APK文件里面包含多个APK文件)。
一个"集群"APK有一个"基准"APK(base APK)组成和其他一些"分割"APK("split" APKs)构成，其中这些"分割"APK用一些数字来分割。这些"分割"APK的必须都是有效的安装，同时必须满足下面的几个条件：

所有的APK必须具有完全相同的软件包名称，版本代码和签名证书

所有的APK必须具有唯一的拆分名称

所有安装必须包含一个单一的APK。

(二)、PackageParser的解析步骤

所以我们知道PackageParse类，它主要用来解析手机上的APK文件(支持Single APK和MultipleAPK)，解析一个APK主要是分为两个步骤：

1、将APK解析成Package：即解析APK文件为Package对象的过程。

2、将Package转化为PackageInfo：即由Package对象生成Package对象生成PackageInfo的过程。

(三)、PackageParser中分类

上面翻译注释的时候，里面提到两个概念：Single APK与Multiple APK，那我们就来简单解释下这两种APK

Single APK就是我们通常所开发的APK，即一个应用只有一个APK文件，而Google Play 还允许你为一个应用中发布不同的APK文件，这些APK文件适用于不同的设备，例如：你现在有一个APP叫DEMO1，但是目前由于APK的体积太大或者其他因素导致不能同时适用于手机和平板，此时你就可以将原先的DEMO.apk，拆分为Demo_phone和Demo_tablet分别用于运行在android手机和Android平板，只要保存两者拥有相同的包名，并用相同key进行签名就可以在发布Demo应用的时候，一起发布Demo_phone和Demo_tablet.apk，那么这种一个应用拥有多个APK文件的程序就称为Mutiple APK。

关于Multiple APK，有想进一步研究的可以参考multiple-apks官网

二、PackageParser类的结构

PackageParser类的结构体如下：

image.png

这里面有好多内部类和方法。所以我们这里就不挨个讲解了，关于这个类的主要方法，后续在讲解APK时会用到，所以关于这个类，我们先简单讲解下PackageParse类的内部类，然后依据在安装流程中的安装入口依次讲解PackageParse类中方法

三、PackageParser类的内部类简介

(一) 静态内部类NewPermissionInfo 类

代码在PackageParser.java 120行

    /** @hide */
    public static class NewPermissionInfo {
        public final String name;
        public final int sdkVersion;
        public final int fileVersion;
        
        public NewPermissionInfo(String name, int sdkVersion, int fileVersion) {
            this.name = name;
            this.sdkVersion = sdkVersion;
            this.fileVersion = fileVersion;
        }
    }

这个类很简单，主要是记录新的权限：

name成员变量：表示权限的名称

sdkVersion成员变量：表示权限的开始版本号

fileVersion成员变量：表示文件的版本号，一般为0

(二) 静态内部类SplitPermissionInfo 类

代码在PackageParser.java 133行

    /** @hide */
    public static class SplitPermissionInfo {
        public final String rootPerm;
        public final String[] newPerms;
        public final int targetSdk;

        public SplitPermissionInfo(String rootPerm, String[] newPerms, int targetSdk) {
            this.rootPerm = rootPerm;
            this.newPerms = newPerms;
            this.targetSdk = targetSdk;
        }
    }

这个类很简单，主要是记录一个权限拆分为颗粒度更小的权限：

rootPerm成员变量：表示旧的权限

newPerms成员变量：表示旧的权限拆分为颗粒度更小的权限

targetSdk成员变量：表示在那个版本上拆分的

(三) 静态内部类ParsePackageItemArgs 类

代码在PackageParser.java 203行

    static class ParsePackageItemArgs {
        final Package owner;
        final String[] outError;
        final int nameRes;
        final int labelRes;
        final int iconRes;
        final int logoRes;
        final int bannerRes;
        
        String tag;
        TypedArray sa;
        
        ParsePackageItemArgs(Package _owner, String[] _outError,
                int _nameRes, int _labelRes, int _iconRes, int _logoRes, int _bannerRes) {
            owner = _owner;
            outError = _outError;
            nameRes = _nameRes;
            labelRes = _labelRes;
            iconRes = _iconRes;
            logoRes = _logoRes;
            bannerRes = _bannerRes;
        }
    }

这个类很简单，主要为解析包单个item的参数：

owner成员变量：表示安装包的包对象Package

outError成员变量：表示错误信息

nameRes成员变量：表示安装包中名字对应的资源id

labelRes成员变量：表示安装包中label对应的资源id

iconRes成员变量：表示安装包中icon对应的资源id

logoRes成员变量：表示安装包中logo对应的资源id

bannerRes成员变量：表示安装包中banner对应的资源id

(四) 静态内部类ParseComponentArgs 类

代码在PackageParser.java 227行

    static class ParseComponentArgs extends ParsePackageItemArgs {
        final String[] sepProcesses;
        final int processRes;
        final int descriptionRes;
        final int enabledRes;
        int flags;
        
        ParseComponentArgs(Package _owner, String[] _outError,
                int _nameRes, int _labelRes, int _iconRes, int _logoRes, int _bannerRes,
                String[] _sepProcesses, int _processRes,
                int _descriptionRes, int _enabledRes) {
            super(_owner, _outError, _nameRes, _labelRes, _iconRes, _logoRes, _bannerRes);
            sepProcesses = _sepProcesses;
            processRes = _processRes;
            descriptionRes = _descriptionRes;
            enabledRes = _enabledRes;
        }
    }

这个类很简单，主要为解析包中单个组件的参数：

sepProcesses成员变量：表示该组件对应的进程，如果设置独立进程则为独立进程的名字

processRes成员变量：表示该组件对应的进程的资源id

descriptionRes成员变量：表示该组件对应的描述id

enabledRes成员变量：表示该组件是否可用

flags成员变量：表示该组件的标志位

(五) 静态内部类PackageLite 类

代码在PackageParser.java 249行

    /**
     * Lightweight parsed details about a single package.
     */
    public static class PackageLite {
        public final String packageName;
        public final int versionCode;
        public final int installLocation;
        public final VerifierInfo[] verifiers;

        /** Names of any split APKs, ordered by parsed splitName */
        public final String[] splitNames;

        /**
         * Path where this package was found on disk. For monolithic packages
         * this is path to single base APK file; for cluster packages this is
         * path to the cluster directory.
         */
        public final String codePath;

        /** Path of base APK */
        public final String baseCodePath;
        /** Paths of any split APKs, ordered by parsed splitName */
        public final String[] splitCodePaths;

        /** Revision code of base APK */
        public final int baseRevisionCode;
        /** Revision codes of any split APKs, ordered by parsed splitName */
        public final int[] splitRevisionCodes;

        public final boolean coreApp;
        public final boolean multiArch;
        public final boolean extractNativeLibs;

        public PackageLite(String codePath, ApkLite baseApk, String[] splitNames,
                String[] splitCodePaths, int[] splitRevisionCodes) {
            this.packageName = baseApk.packageName;
            this.versionCode = baseApk.versionCode;
            this.installLocation = baseApk.installLocation;
            this.verifiers = baseApk.verifiers;
            this.splitNames = splitNames;
            this.codePath = codePath;
            this.baseCodePath = baseApk.codePath;
            this.splitCodePaths = splitCodePaths;
            this.baseRevisionCode = baseApk.revisionCode;
            this.splitRevisionCodes = splitRevisionCodes;
            this.coreApp = baseApk.coreApp;
            this.multiArch = baseApk.multiArch;
            this.extractNativeLibs = baseApk.extractNativeLibs;
        }

        public List<String> getAllCodePaths() {
            ArrayList<String> paths = new ArrayList<>();
            paths.add(baseCodePath);
            if (!ArrayUtils.isEmpty(splitCodePaths)) {
                Collections.addAll(paths, splitCodePaths);
            }
            return paths;
        }
    }

通过注释我们知道这个类表示在解析过程中的一个"轻量级的"、"独立的"安装包

packageName成员变量：表示包名

versionCode成员变量：表示版本号

installLocation成员变量：安装位置的属性，有几个常量可以选择，比如PackageInfo.INSTALL_LOCATION_AUTO的值等。

VerifierInfo成员变量：表示验证对象

splitNames成员变量：如果有拆包，则拆包的名字数组，关于拆包可以参考xxxx。

codePath成员变量：表示"代码"的路径，对于"单一APK"，则对应的是"base APK"的路径；如果是"集群APK"，则对应的是"集群APK"目录的路径

baseCodePath成员变量：表示"base APK"的路径

splitCodePaths成员变量：表示"拆分"APK的路径

baseRevisionCode成员变量：表示"base APK"的调整版本号

splitRevisionCodes成员变量：表示"拆分"APK的调整版本号

coreApp成员变量：表示是不是"核心"APP

multiArch成员变量：表示是不是支持多平台，这里主要是指CPU平台

extractNativeLibs成员变量：表示是否需要提取"Native库"(主要是指so)

(六) 静态内部类ApkLite 类

代码在PackageParser.java 309行

    /**
     * Lightweight parsed details about a single APK file.
     */
    public static class ApkLite {
        public final String codePath;
        public final String packageName;
        public final String splitName;
        public final int versionCode;
        public final int revisionCode;
        public final int installLocation;
        public final VerifierInfo[] verifiers;
        public final Signature[] signatures;
        public final boolean coreApp;
        public final boolean multiArch;
        public final boolean extractNativeLibs;

        public ApkLite(String codePath, String packageName, String splitName, int versionCode,
                int revisionCode, int installLocation, List<VerifierInfo> verifiers,
                Signature[] signatures, boolean coreApp, boolean multiArch,
                boolean extractNativeLibs) {
            this.codePath = codePath;
            this.packageName = packageName;
            this.splitName = splitName;
            this.versionCode = versionCode;
            this.revisionCode = revisionCode;
            this.installLocation = installLocation;
            this.verifiers = verifiers.toArray(new VerifierInfo[verifiers.size()]);
            this.signatures = signatures;
            this.coreApp = coreApp;
            this.multiArch = multiArch;
            this.extractNativeLibs = extractNativeLibs;
        }
    }

通过注释我们知道这个类表示在解析过程中的一个"轻量级的"、"独立的"APK

codePath成员变量：表示代码的路径

packageName成员变量：表示包名

splitName成员变量：表示"拆包"的包名

versionCode成员变量：表示版本号

revisionCode成员变量：表示调整的版本号

installLocation成员变量：安装位置的属性，有几个常量可以选择，比如PackageInfo.INSTALL_LOCATION_AUTO的值等。

VerifierInfo成员变量：表示验证对象

Signature成员变量：表示签名对象

coreApp成员变量：表示是不是"核心"APP

multiArch成员变量：表示是不是支持多平台，这里主要是指CPU平台

extractNativeLibs成员变量：表示是否需要提取"Native库"(主要是指so)

PS: PackageLite和ApkLite代表不同的含义，前者是指包，后者是指APK，一个包中是可能包含多个APK的。

(七) 私有静态内部类SplitNameComparator 类

代码在PackageParser.java 634行

    /**
     * Used to sort a set of APKs based on their split names, always placing the
     * base APK (with {@code null} split name) first.
     */
    private static class SplitNameComparator implements Comparator<String> {
        @Override
        public int compare(String lhs, String rhs) {
            if (lhs == null) {
                return -1;
            } else if (rhs == null) {
                return 1;
            } else {
                return lhs.compareTo(rhs);
            }
        }
    }

这个类其实就是一个比较器，在"拆包"中的排序用的

(八) 静态内部类Package类

代码在PackageParser.java 4254行

    /**
     * Representation of a full package parsed from APK files on disk. A package
     * consists of a single base APK, and zero or more split APKs.
     */
    public final static class Package {

        //表示包名
        public String packageName;

        /** Names of any split APKs, ordered by parsed splitName */
        // 表示"拆包"的包名，是个数组，每个元素代表一个"拆分"包名
        public String[] splitNames;

        // TODO: work towards making these paths invariant
        //对应一个volume的uid(后面会有专题去讲解volume)
        public String volumeUuid;

        /**
         * Path where this package was found on disk. For monolithic packages
         * this is path to single base APK file; for cluster packages this is
         * path to the cluster directory.
         */
        // 表示代码的路径，如果是单个包，则表示"base"的APK的路径，如果是"集群"包，则表示的"集群"包的目录。
        public String codePath;

        /** Path of base APK */
        // "base APK"的路径
        public String baseCodePath;
        /** Paths of any split APKs, ordered by parsed splitName */
       // "拆分 APK"的路径
        public String[] splitCodePaths;

        /** Revision code of base APK */
        // "base APK"的调整版本号
        public int baseRevisionCode;
        /** Revision codes of any split APKs, ordered by parsed splitName */
        //"拆分APK"的调整版本号
        public int[] splitRevisionCodes;

        /** Flags of any split APKs; ordered by parsed splitName */
        // "拆分APK"的标志数组
        public int[] splitFlags;

        /**
         * Private flags of any split APKs; ordered by parsed splitName.
         *
         * {@hide}
         */
        // "拆分APK"的私有标志数组
        public int[] splitPrivateFlags;
  
        // 是否支持硬件加速
        public boolean baseHardwareAccelerated;

        // For now we only support one application per package.
        // 对应ApplicationInfo对象 对应AndroidManifest里面的Application
        public final ApplicationInfo applicationInfo = new ApplicationInfo();

        // APK安装包中 AndroidManifest里面的<Permission>
        public final ArrayList<Permission> permissions = new ArrayList<Permission>(0);

         // APK安装包中 AndroidManifest里面的<PermissionGroup>
        public final ArrayList<PermissionGroup> permissionGroups = new ArrayList<PermissionGroup>(0);

        // APK安装包中 AndroidManifest里面的<Activity>，这里面的Activity是不是我们通常说的Activity，而是PackageParse的内部类Activity
        public final ArrayList<Activity> activities = new ArrayList<Activity>(0);

        // APK安装包中 AndroidManifest里面的<Receiver>，这里面的Activity是不是我们通常说的Activity，而是PackageParse的内部类Activity
        public final ArrayList<Activity> receivers = new ArrayList<Activity>(0);

        // APK安装包中 AndroidManifest里面的<Provider>，这里面的Provider是不是我们通常说的Provider，而是PackageParse的内部类Provider
        public final ArrayList<Provider> providers = new ArrayList<Provider>(0);

        // APK安装包中 AndroidManifest里面的<Service>，这里面的Service是不是我们通常说的Service，而是PackageParse的内部类Service
        public final ArrayList<Service> services = new ArrayList<Service>(0);

        // APK安装包中 AndroidManifest里面的<Instrumentation>，这里面的Instrumentation是不是我们通常说的Instrumentation，而是PackageParse的内部类Instrumentation
        public final ArrayList<Instrumentation> instrumentation = new ArrayList<Instrumentation>(0);

        // APK安装包中请求的权限
        public final ArrayList<String> requestedPermissions = new ArrayList<String>();

        // APK安装包中 保内广播的Action
        public ArrayList<String> protectedBroadcasts;

        // APK安装包中 依赖库的名字
        public ArrayList<String> libraryNames = null;

        // APK安装包中 使用库的名字
        public ArrayList<String> usesLibraries = null;

        // APK安装包中 使用选项库的名字
        public ArrayList<String> usesOptionalLibraries = null;

        // APK安装包中 使用库的路径数组
        public String[] usesLibraryFiles = null;

        // APK安装包中 某个Activity信息的集合，在AndroidManifest里面的<preferred>标签(不在receiver里面)
        public ArrayList<ActivityIntentInfo> preferredActivityFilters = null;

        // APK安装包中 AndroidManifest中对应"original-package"的集合
        public ArrayList<String> mOriginalPackages = null;

        // 是真实包名，通常和mOriginalPackages一起使用
        public String mRealPackage = null;

         // APK安装包中 AndroidManifest中对应"adopt-permissions"集合
        public ArrayList<String> mAdoptPermissions = null;
        
        // We store the application meta-data independently to avoid multiple unwanted references
         // 我们独立的存储应用程序元数据，以避免多个不需要的引用
        public Bundle mAppMetaData = null;

        // The version code declared for this package.
        //  版本号
        public int mVersionCode;

        // The version name declared for this package.
        // 版本名
        public String mVersionName;
        
        // The shared user id that this package wants to use.
         // 共享id
        public String mSharedUserId;

        // The shared user label that this package wants to use.
        // 共享用户标签
        public int mSharedUserLabel;

        // Signatures that were read from the package.
         // 签名
        public Signature[] mSignatures;
        // 证书
        public Certificate[][] mCertificates;

        // For use by package manager service for quick lookup of
        // preferred up order. 
        // dexopt的位置，以便PackageManagerService跟踪要执行dexopt的位置
        public int mPreferredOrder = 0;

        // For use by package manager to keep track of where it needs to do dexopt.
         //  需要进行的dexopt的集合
        public final ArraySet<String> mDexOptPerformed = new ArraySet<>(4);

        // For use by package manager to keep track of when a package was last used.
        // 最后一次使用pakcage的时间的
        public long mLastPackageUsageTimeInMills;

        // // User set enabled state.
        // public int mSetEnabled = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
        //
        // // Whether the package has been stopped.
        // public boolean mSetStopped = false;

        // Additional data supplied by callers.
        // 附加数据
        public Object mExtras;

        // Applications hardware preferences
         // 硬件配置信息，对一个AndroidManifest里面的<uses-configuration> 标签
        public ArrayList<ConfigurationInfo> configPreferences = null;

        // Applications requested features
         //特性信息，对一个AndroidManifest里面的<uses-feature> 标签 
        public ArrayList<FeatureInfo> reqFeatures = null;

        // Applications requested feature groups
         //特性组信息，对一个AndroidManifest里面的<feature-group> 标签 
        public ArrayList<FeatureGroupInfo> featureGroups = null;

         // 安装的属性
        public int installLocation;

        // 是否是核心
        public boolean coreApp;

        /* An app that's required for all users and cannot be uninstalled for a user */
        // 是否是全局必要，所有用户都需要的应用程序，无法为用户卸载
        public boolean mRequiredForAllUsers;

        /* The restricted account authenticator type that is used by this application */
        // 受限账户的 验证类型
        public String mRestrictedAccountType;

        /* The required account type without which this application will not function */
          //  账户的类型
        public String mRequiredAccountType;

        /**
         * Digest suitable for comparing whether this package's manifest is the
         * same as another.
         */
        // 对应的AndroidManifest项目摘要清单
        public ManifestDigest manifestDigest;

        //AndroidManifest中 对应<overlay> 标签
        public String mOverlayTarget;
     
        //overlay对应的优先级
        public int mOverlayPriority;

         //  是否是受信任的Overlay
        public boolean mTrustedOverlay;

        /**
         * Data used to feed the KeySetManagerService
         */
         // 下面是用来给KeySetManagerService的数据
        public ArraySet<PublicKey> mSigningKeys;  // 签名
        public ArraySet<String> mUpgradeKeySets;  //升级
        public ArrayMap<String, ArraySet<PublicKey>> mKeySetMapping;  //公钥

        /**
         * The install time abi override for this package, if any.
         *
         * TODO: This seems like a horrible place to put the abiOverride because
         * this isn't something the packageParser parsers. However, this fits in with
         * the rest of the PackageManager where package scanning randomly pushes
         * and prods fields out of {@code this.applicationInfo}.
         */
        // 如果有abi的话，abi覆盖
        public String cpuAbiOverride;

        public Package(String packageName) {
            this.packageName = packageName;
            applicationInfo.packageName = packageName;
            applicationInfo.uid = -1;
        }
         ...
    }

先来翻译一下注释：

这个类表示从磁盘上的APK文件解析出来的完整包。一个包由一个"基础"APK和多个"拆分"APK构成。

这个类其实就是通过解析APK而对应的一个"包"的类，这个包代表一个磁盘上的APK安装包。

关于每个字段的含义，我在每个字段上都添加了注释，关于这个类的一些方法，我会在后面讲解方法的时候讲解

(九) 静态内部类Component类

代码在PackageParser.java 5044行

    public static class IntentInfo extends IntentFilter {
        public boolean hasDefault; //是否有默认
        public int labelRes;  // 标签的资源id
        public CharSequence nonLocalizedLabel; // 本地化的标签
        public int icon; // icon的资源id
        public int logo; // logo的资源id
        public int banner; // banner的资源id
        public int preferred; // preferred的资源id
    }

IntentInfo类继承自IntentFilter，就是对IntentFilter进行了封装。

(十) 静态内部类Component类

代码在PackageParser.java 4542行

    public static class Component<II extends IntentInfo> {
        public final Package owner;  //包含该组件的包
        public final ArrayList<II> intents; // 该组件所包含的IntentFilter
        public final String className; // 组件的类名
        public Bundle metaData;   // 组件的元数据

        ComponentName componentName;  //组件名
        String componentShortName; //组件简称

        public Component(Package _owner) {
            owner = _owner;
            intents = null;
            className = null;
        }

        public Component(final ParsePackageItemArgs args, final PackageItemInfo outInfo) {
            owner = args.owner;
            intents = new ArrayList<II>(0);
            if (parsePackageItemInfo(args.owner, outInfo, args.outError, args.tag, args.sa,
                    true /*nameRequired*/, args.nameRes, args.labelRes, args.iconRes,
                    args.roundIconRes, args.logoRes, args.bannerRes)) {
                className = outInfo.name;
            } else {
                className = null;
            }
        }

        public Component(final ParseComponentArgs args, final ComponentInfo outInfo) {
            this(args, (PackageItemInfo)outInfo);
            if (args.outError[0] != null) {
                return;
            }

            if (args.processRes != 0) {
                CharSequence pname;
                if (owner.applicationInfo.targetSdkVersion >= Build.VERSION_CODES.FROYO) {
                    pname = args.sa.getNonConfigurationString(args.processRes,
                            Configuration.NATIVE_CONFIG_VERSION);
                } else {
                    // Some older apps have been seen to use a resource reference
                    // here that on older builds was ignored (with a warning).  We
                    // need to continue to do this for them so they don't break.
                    pname = args.sa.getNonResourceString(args.processRes);
                }
                outInfo.processName = buildProcessName(owner.applicationInfo.packageName,
                        owner.applicationInfo.processName, pname,
                        args.flags, args.sepProcesses, args.outError);
            }

            if (args.descriptionRes != 0) {
                outInfo.descriptionRes = args.sa.getResourceId(args.descriptionRes, 0);
            }

            outInfo.enabled = args.sa.getBoolean(args.enabledRes, true);
        }

        public Component(Component<II> clone) {
            owner = clone.owner;
            intents = clone.intents;
            className = clone.className;
            componentName = clone.componentName;
            componentShortName = clone.componentShortName;
        }
       ...
    }

组件类是个基类。里面包含组件对应的各个属性。

(十一) 静态内部类Permission类

代码在PackageParser.java 4663行

    public final static class Permission extends Component<IntentInfo> {
        public final PermissionInfo info;  //权限信息
        public boolean tree;  //是否权限树
        public PermissionGroup group;  //对应的权限组

        public Permission(Package _owner) {
            super(_owner);
            info = new PermissionInfo();
        }

        public Permission(Package _owner, PermissionInfo _info) {
            super(_owner);
            info = _info;
        }

        public void setPackageName(String packageName) {
            super.setPackageName(packageName);
            info.packageName = packageName;
        }

        public String toString() {
            return "Permission{"
                + Integer.toHexString(System.identityHashCode(this))
                + " " + info.name + "}";
        }
    }

该类继承自Component，对应AndroidManifest里面的<Permission>标签，含义为标签

(十二) 静态内部类PermissionGroup类

代码在PackageParser.java 4690行

    public final static class PermissionGroup extends Component<IntentInfo> {
        public final PermissionGroupInfo info;  //权限组对象

        public PermissionGroup(Package _owner) {
            super(_owner);
            info = new PermissionGroupInfo();
        }

        public PermissionGroup(Package _owner, PermissionGroupInfo _info) {
            super(_owner);
            info = _info;
        }

        public void setPackageName(String packageName) {
            super.setPackageName(packageName);
            info.packageName = packageName;
        }

        public String toString() {
            return "PermissionGroup{"
                + Integer.toHexString(System.identityHashCode(this))
                + " " + info.name + "}";
        }
    }

这个PermissionGroup继承自Component，意为权限组，对应AndroidManifest里面的<PermissionGroup>

(十三) 静态内部类Activity类

代码在PackageParser.java 4860行

    public final static class Activity extends Component<ActivityIntentInfo> {
        public final ActivityInfo info;

        public Activity(final ParseComponentArgs args, final ActivityInfo _info) {
            super(args, _info);
            info = _info;
            info.applicationInfo = args.owner.applicationInfo;
        }

        public void setPackageName(String packageName) {
            super.setPackageName(packageName);
            info.packageName = packageName;
        }

        public String toString() {
            StringBuilder sb = new StringBuilder(128);
            sb.append("Activity{");
            sb.append(Integer.toHexString(System.identityHashCode(this)));
            sb.append(' ');
            appendComponentShortName(sb);
            sb.append('}');
            return sb.toString();
        }
    }

这个Activity继承自Component，对应AndroidManifest里面的<Activity>，其实就是ActivityInfo的封装类。

(十四) 静态内部类Service类

代码在PackageParser.java 4914行

   public final static class Service extends Component<ServiceIntentInfo> {
        public final ServiceInfo info;

        public Service(final ParseComponentArgs args, final ServiceInfo _info) {
            super(args, _info);
            info = _info;
            info.applicationInfo = args.owner.applicationInfo;
        }

        public void setPackageName(String packageName) {
            super.setPackageName(packageName);
            info.packageName = packageName;
        }

        public String toString() {
            StringBuilder sb = new StringBuilder(128);
            sb.append("Service{");
            sb.append(Integer.toHexString(System.identityHashCode(this)));
            sb.append(' ');
            appendComponentShortName(sb);
            sb.append('}');
            return sb.toString();
        }
    }

这个Service继承自Component，对应AndroidManifest里面的<Service>，其实就是ServiceInfo的封装类。

(十五) 静态内部类Provider类

代码在PackageParser.java 4955行

    public final static class Provider extends Component<ProviderIntentInfo> {
        public final ProviderInfo info;
        public boolean syncable;

        public Provider(final ParseComponentArgs args, final ProviderInfo _info) {
            super(args, _info);
            info = _info;
            info.applicationInfo = args.owner.applicationInfo;
            syncable = false;
        }

        public Provider(Provider existingProvider) {
            super(existingProvider);
            this.info = existingProvider.info;
            this.syncable = existingProvider.syncable;
        }

        public void setPackageName(String packageName) {
            super.setPackageName(packageName);
            info.packageName = packageName;
        }

        public String toString() {
            StringBuilder sb = new StringBuilder(128);
            sb.append("Provider{");
            sb.append(Integer.toHexString(System.identityHashCode(this)));
            sb.append(' ');
            appendComponentShortName(sb);
            sb.append('}');
            return sb.toString();
        }
    }

这个Provider继承自Component，对应AndroidManifest里面的<Provider>，其实就是ProviderInfo的封装类。

(十六) 静态内部类Instrumentation类

代码在PackageParser.java 5009行

    public final static class Instrumentation extends Component<IntentInfo> {
        public final InstrumentationInfo info;

        public Instrumentation(final ParsePackageItemArgs args, final InstrumentationInfo _info) {
            super(args, _info);
            info = _info;
        }

        public void setPackageName(String packageName) {
            super.setPackageName(packageName);
            info.packageName = packageName;
        }

        public String toString() {
            StringBuilder sb = new StringBuilder(128);
            sb.append("Instrumentation{");
            sb.append(Integer.toHexString(System.identityHashCode(this)));
            sb.append(' ');
            appendComponentShortName(sb);
            sb.append('}');
            return sb.toString();
        }
    }

这个Instrumentation继承自Component，对应AndroidManifest里面的<Instrumentation>，其实就是InstrumentationInfo的封装类。

(十七) 静态内部类ActivityIntentInfo类

代码在PackageParser.java 5054行

    public final static class ActivityIntentInfo extends IntentInfo {
        public final Activity activity;

        public ActivityIntentInfo(Activity _activity) {
            activity = _activity;
        }

        public String toString() {
            StringBuilder sb = new StringBuilder(128);
            sb.append("ActivityIntentInfo{");
            sb.append(Integer.toHexString(System.identityHashCode(this)));
            sb.append(' ');
            activity.appendComponentShortName(sb);
            sb.append('}');
            return sb.toString();
        }
    }

这个ActivityIntentInfo继承自IntentInfo，其实就是Activity的封装类。

(十八) 静态内部类ServiceIntentInfo类

代码在PackageParser.java 5054行

    public final static class ServiceIntentInfo extends IntentInfo {
        public final Service service;

        public ServiceIntentInfo(Service _service) {
            service = _service;
        }

        public String toString() {
            StringBuilder sb = new StringBuilder(128);
            sb.append("ServiceIntentInfo{");
            sb.append(Integer.toHexString(System.identityHashCode(this)));
            sb.append(' ');
            service.appendComponentShortName(sb);
            sb.append('}');
            return sb.toString();
        }
    }

这个ServiceIntentInfo继承自IntentInfo，其实就是Service的封装类。

(十九) 静态内部类ProviderIntentInfo类

代码在PackageParser.java 5090行

    public static final class ProviderIntentInfo extends IntentInfo {
        public final Provider provider;

        public ProviderIntentInfo(Provider provider) {
            this.provider = provider;
        }

        public String toString() {
            StringBuilder sb = new StringBuilder(128);
            sb.append("ProviderIntentInfo{");
            sb.append(Integer.toHexString(System.identityHashCode(this)));
            sb.append(' ');
            provider.appendComponentShortName(sb);
            sb.append('}');
            return sb.toString();
        }
    }

这个ProviderIntentInfo继承自IntentInfo，其实就是provider的封装类。

(二十) 静态内部类PackageParserException类

代码在PackageParser.java 5142行

    public static class PackageParserException extends Exception {
        public final int error;

        public PackageParserException(int error, String detailMessage) {
            super(detailMessage);
            this.error = error;
        }

        public PackageParserException(int error, String detailMessage, Throwable throwable) {
            super(detailMessage, throwable);
            this.error = error;
        }
    }

这个PackageParserException继承自Exception，其实就是Exception的封装类。

至此整个PackageParser的内部类全部简介完毕，下面我们来看下解析的方法

四、PackageParse#parsePackage(File, int)方法解析

代码在PackageParser.java 752行

    /**
     * Parse the package at the given location. Automatically detects if the
     * package is a monolithic style (single APK file) or cluster style
     * (directory of APKs).
     * <p>
     * This performs sanity checking on cluster style packages, such as
     * requiring identical package name and version codes, a single base APK,
     * and unique split names.
     * <p>
     * Note that this <em>does not</em> perform signature verification; that
     * must be done separately in {@link #collectCertificates(Package, int)}.
     *
     * @see #parsePackageLite(File, int)
     */
    public Package parsePackage(File packageFile, int flags) throws PackageParserException {
        if (packageFile.isDirectory()) {
            return parseClusterPackage(packageFile, flags);
        } else {
            return parseMonolithicPackage(packageFile, flags);
        }
    }

这个方法有注释，先来看下注释：

解析指定位置的安装包。它自动会检测安装包的模式的是单一APK或者集群APK模式。
这样就可以对"集群APK"的安装包进行理性的检查，比如会检查"base APK"和"拆分APK"是否具有相同的包名和版本号。
请注意，这里面是不执行签名验证的，所以必须要单独执行collectCertificates(Package，int)这个方法

这个方法很简单，主要是判断是否是目录，如果是目录则调用parseMonolithicPackage(File,int)方法，如果不是目录，是文件则调用parseClusterPackage(File,int)

五、PackageParse#parseMonolithicPackage(File, int)方法解析

代码在PackageParser.java 827行

    /**
     * Parse the given APK file, treating it as as a single monolithic package.
     * <p>
     * Note that this <em>does not</em> perform signature verification; that
     * must be done separately in {@link #collectCertificates(Package, int)}.
     *
     * @deprecated external callers should move to
     *             {@link #parsePackage(File, int)}. Eventually this method will
     *             be marked private.
     */
    @Deprecated
    public Package parseMonolithicPackage(File apkFile, int flags) throws PackageParserException {
        if (mOnlyCoreApps) {
            final PackageLite lite = parseMonolithicPackageLite(apkFile, flags);
            if (!lite.coreApp) {
                throw new PackageParserException(INSTALL_PARSE_FAILED_MANIFEST_MALFORMED,
                        "Not a coreApp: " + apkFile);
            }
        }

        final AssetManager assets = new AssetManager();
        try {
            final Package pkg = parseBaseApk(apkFile, assets, flags);
            pkg.codePath = apkFile.getAbsolutePath();
            return pkg;
        } finally {
            IoUtils.closeQuietly(assets);
        }
    }

先简单翻译一下注释：

解析给定的APK文件，将其视为单一APK包
注意：这个不执行签名，必须在collectCertificates方法中独立完成。

我们知道这个方法内部主要是：

首先判断是不是mOnlyCoreApps，mOnlyCoreApps该标示表明解析只考虑应用清单属性有效的应用，主要为了创建一个最小的启动环境，如果该标示为true则表示为轻量级解析，调用parseMonolithicPackageLite来进行解析

其次如果mOnlyCoreApps不为空，则new了一个AssetManager对象

再次调用parseBaseApk()方法解析一个apk并生成一个Package对象

最后给pkg的codePath赋值

这里面涉及了两个方法分别是parseMonolithicPackageLite(apkFile, flags);和parseBaseApk()，下面我们就详细看下

六、PackageParse#parseMonolithicPackageLite(File, int)方法解析

代码在PackageParser.java 657行

    private static PackageLite parseMonolithicPackageLite(File packageFile, int flags)
            throws PackageParserException {
        final ApkLite baseApk = parseApkLite(packageFile, flags);
        final String packagePath = packageFile.getAbsolutePath();
        return new PackageLite(packagePath, baseApk, null, null, null);
    }

这个方法很贱，就是调用parseApk()方法来获取一个ApkLite对象，然后用这个ApkLite对象构造一个PackageLite对象

所以正在这个函数里面要解决三个问题

1、parseApkLite(File,int)函数内部的实现

2、ApkLite类

3、PackageLite类

parseMonolithicPackageLite内部又调用了parseApkLite函数并且返回一个ApkLite对象，根据返回的ApkLite对象和包的绝对路径构造了一个PackegeLite对象作为返回值。

下面我们来看下parseApkLite(File,int)方法

七、PackageParse#parseApkLite(File,int)方法解析

代码在PackageParser.java 1155行

    /**
     * Utility method that retrieves lightweight details about a single APK
     * file, including package name, split name, and install location.
     *
     * @param apkFile path to a single APK
     * @param flags optional parse flags, such as
     *            {@link #PARSE_COLLECT_CERTIFICATES}
     */
    public static ApkLite parseApkLite(File apkFile, int flags)
            throws PackageParserException {
        final String apkPath = apkFile.getAbsolutePath();

        AssetManager assets = null;
        XmlResourceParser parser = null;
        try {
            assets = new AssetManager();
            assets.setConfiguration(0, 0, null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                    Build.VERSION.RESOURCES_SDK_INT);

            int cookie = assets.addAssetPath(apkPath);
            if (cookie == 0) {
                throw new PackageParserException(INSTALL_PARSE_FAILED_NOT_APK,
                        "Failed to parse " + apkPath);
            }

            final DisplayMetrics metrics = new DisplayMetrics();
            metrics.setToDefaults();

            final Resources res = new Resources(assets, metrics, null);
            parser = assets.openXmlResourceParser(cookie, ANDROID_MANIFEST_FILENAME);

            final Signature[] signatures;
            if ((flags & PARSE_COLLECT_CERTIFICATES) != 0) {
                // TODO: factor signature related items out of Package object
                final Package tempPkg = new Package(null);
                collectCertificates(tempPkg, apkFile, 0);
                signatures = tempPkg.mSignatures;
            } else {
                signatures = null;
            }

            final AttributeSet attrs = parser;
            return parseApkLite(apkPath, res, parser, attrs, flags, signatures);

        } catch (XmlPullParserException | IOException | RuntimeException e) {
            throw new PackageParserException(INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION,
                    "Failed to parse " + apkPath, e);
        } finally {
            IoUtils.closeQuietly(parser);
            IoUtils.closeQuietly(assets);
        }
    }

这个方法内部的流程如下：

1、创建AssetManager对象assets

2、assets调用addAssetPath(apkPath)

3、用assets作为入参来创建Resources对象res

4、调用assets的openXmlResourceParser()来获取XmlResourceParser对象parser对象

5、设置签名

6、调用parseApkLite(String,Resource,XmlPullParser,AttributeSet,int,Signature[])方法来返回一个ApkLite对象

总结一下就是:

函数里面初始化了一个AssertMananger对象，一个DisplayMetrics对象，一个Resources对象，并调用collectCertificates函数获取了应用的签名信息，这些对象都是后续解析中需要用的，因此将这些函数传递给解析函数，这些对象都是后续解析中需要用的，因此将这些参数传递给解析函数，解析完成后关闭资源管理器与解析器，这里主要是轻量级解析，只解析了包名，安装位置等少量信息。

下面我们来看看解析过程：

八、PackageParse#parseApkLite(File,int)方法解析

代码在PackageParser.java 1274行

    private static ApkLite parseApkLite(String codePath, Resources res, XmlPullParser parser,
            AttributeSet attrs, int flags, Signature[] signatures) throws IOException,
            XmlPullParserException, PackageParserException {
        final Pair<String, String> packageSplit = parsePackageSplitNames(parser, attrs, flags);

        int installLocation = PARSE_DEFAULT_INSTALL_LOCATION;
        int versionCode = 0;
        int revisionCode = 0;
        boolean coreApp = false;
        boolean multiArch = false;
        boolean extractNativeLibs = true;

        for (int i = 0; i < attrs.getAttributeCount(); i++) {
            final String attr = attrs.getAttributeName(i);
            if (attr.equals("installLocation")) {
                installLocation = attrs.getAttributeIntValue(i,
                        PARSE_DEFAULT_INSTALL_LOCATION);
            } else if (attr.equals("versionCode")) {
                versionCode = attrs.getAttributeIntValue(i, 0);
            } else if (attr.equals("revisionCode")) {
                revisionCode = attrs.getAttributeIntValue(i, 0);
            } else if (attr.equals("coreApp")) {
                coreApp = attrs.getAttributeBooleanValue(i, false);
            }
        }

        // Only search the tree when the tag is directly below <manifest>
        int type;
        final int searchDepth = parser.getDepth() + 1;

        final List<VerifierInfo> verifiers = new ArrayList<VerifierInfo>();
        while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
                && (type != XmlPullParser.END_TAG || parser.getDepth() >= searchDepth)) {
            if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
                continue;
            }

            if (parser.getDepth() == searchDepth && "package-verifier".equals(parser.getName())) {
                final VerifierInfo verifier = parseVerifier(res, parser, attrs, flags);
                if (verifier != null) {
                    verifiers.add(verifier);
                }
            }

            if (parser.getDepth() == searchDepth && "application".equals(parser.getName())) {
                for (int i = 0; i < attrs.getAttributeCount(); ++i) {
                    final String attr = attrs.getAttributeName(i);
                    if ("multiArch".equals(attr)) {
                        multiArch = attrs.getAttributeBooleanValue(i, false);
                    }
                    if ("extractNativeLibs".equals(attr)) {
                        extractNativeLibs = attrs.getAttributeBooleanValue(i, true);
                    }
                }
            }
        }

        return new ApkLite(codePath, packageSplit.first, packageSplit.second, versionCode,
                revisionCode, installLocation, verifiers, signatures, coreApp, multiArch,
                extractNativeLibs);
    }

首先这个方法又调用了parsePackageSplitNames()方法来获取Pair<String, String> packageSplit

其次遍历属性，并获取相应的值，这里面主要是循环解析出installLocation，versionCode，revisionCode，coreApp

再次继续解析package-verifier节点，该节点主要解析两个属性：

multiArch

extractNativeLibs

最后利用解析出来的数据去构造一个ApkLite对象

九、PackageParse#parsePackageSplitNames(XmlpullParse，AttributeSet,int)方法解析

代码在PackageParser.java 1230行

    private static Pair<String, String> parsePackageSplitNames(XmlPullParser parser,
            AttributeSet attrs, int flags) throws IOException, XmlPullParserException,
            PackageParserException {

        int type;
        while ((type = parser.next()) != XmlPullParser.START_TAG
                && type != XmlPullParser.END_DOCUMENT) {
        }

        if (type != XmlPullParser.START_TAG) {
            throw new PackageParserException(INSTALL_PARSE_FAILED_MANIFEST_MALFORMED,
                    "No start tag found");
        }
        if (!parser.getName().equals("manifest")) {
            throw new PackageParserException(INSTALL_PARSE_FAILED_MANIFEST_MALFORMED,
                    "No <manifest> tag");
        }

        final String packageName = attrs.getAttributeValue(null, "package");
        if (!"android".equals(packageName)) {
            final String error = validateName(packageName, true, true);
            if (error != null) {
                throw new PackageParserException(INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME,
                        "Invalid manifest package: " + error);
            }
        }

        String splitName = attrs.getAttributeValue(null, "split");
        if (splitName != null) {
            if (splitName.length() == 0) {
                splitName = null;
            } else {
                final String error = validateName(splitName, false, false);
                if (error != null) {
                    throw new PackageParserException(INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME,
                            "Invalid manifest split: " + error);
                }
            }
        }

        return Pair.create(packageName.intern(),
                (splitName != null) ? splitName.intern() : splitName);
    }

这个方法主要是解析manifest，这里面调用了validateName(String, boolean,boolean)方法，这里简单说下，这个方法主要就是检测是否是数字、字母、下划线和点分隔符，这也是取包名的规则，比如是字母数字下划线加点分隔符，否则都不是合法的应用包名。并且合法的包名至少包含一个点分隔符。