1
public static PackageManagerService main(Context context, Installer installer,
2
  boolean factoryTest, boolean onlyCore) {
3
    //初始化 PKMS 对象
4
    PackageManagerService m = new PackageManagerService(context, installer,
5
            factoryTest, onlyCore);
6
    //将 package 服务注册到 ServiceManager，这是 binder 服务的常规注册流程
7
    ServiceManager.addService("package", m);
8
    return m;
9
}

1
public PackageManagerService(Context context, Installer installer,
2
  boolean factoryTest, boolean onlyCore) {
3

4
    //PackageManagerService 启动开始
5
    EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_START, SystemClock.uptimeMillis());
6
    //SDK 版本检查
7
    if (mSdkVersion <= 0) {
8
        Slog.w(TAG, "**** ro.build.version.sdk not set!");
9
    }
10

11
    //读取开机启动模式
12
    String mode = SystemProperties.get("ro.bootmode", "mode");
13
    engModeEnable = "engtest".equals(mode) ? true : false;
14
    Slog.i(TAG, "engModeEnable: " + engModeEnable + " ,mode:" + mode);
15
    mContext = context;
16
    mFactoryTest = factoryTest;//开机模式
17
    mOnlyCore = onlyCore;//是否对包做 dex 优化
18
    //如果编译版本为 eng，则不需要 dex 优化
19
    mNoDexOpt = "eng".equals(SystemProperties.get("ro.build.type"));
20
    //创建显示尺寸信息
21
    mMetrics = new DisplayMetrics();
22
    //存储系统运行过程中的设置信息
23
    mSettings = new Settings();//【1】
24
    /*创建 SharedUserSetting 对象并添加到 Settings 的成员变量 mSharedUsers 中，
25
        在 Android 系统中，多个 package 通过设置 sharedUserId 属性可以运行在同一个进程，共享同一个 UID */
26
    mSettings.addSharedUserLPw("android.uid.system", Process.SYSTEM_UID, ApplicationInfo.FLAG_SYSTEM);
27
    mSettings.addSharedUserLPw("android.uid.phone", RADIO_UID, ApplicationInfo.FLAG_SYSTEM);
28
    mSettings.addSharedUserLPw("android.uid.log", LOG_UID, ApplicationInfo.FLAG_SYSTEM);
29
    mSettings.addSharedUserLPw("android.uid.nfc", NFC_UID, ApplicationInfo.FLAG_SYSTEM);
30
    String separateProcesses = SystemProperties.get("debug.separate_processes");
31
    if (separateProcesses != null && separateProcesses.length() > 0) {
32
        if ("*".equals(separateProcesses)) {
33
            mDefParseFlags = PackageParser.PARSE_IGNORE_PROCESSES;
34
            mSeparateProcesses = null;
35
            Slog.w(TAG, "Running with debug.separate_processes: * (ALL)");
36
        } else {
37
            mDefParseFlags = 0;
38
            mSeparateProcesses = separateProcesses.split(",");
39
            Slog.w(TAG, "Running with debug.separate_processes: "
40
                   + separateProcesses);
41
        }
42
    } else {
43
        mDefParseFlags = 0;
44
        mSeparateProcesses = null;
45
    }
46

47
    mPreInstallDir = new File("/system/preloadapp");
48
    //创建应用安装器
49
    mInstaller = new Installer();
50

51
    //获取屏幕尺寸大小
52
    WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
53
    Display d = wm.getDefaultDisplay();
54
    d.getMetrics(mMetrics);
55
    synchronized (mInstallLock) {
56
        // writer
57
        synchronized (mPackages) {
58
            //启动消息处理线程
59
            mHandlerThread.start();
60
            //为消息处理线程创建一个消息分发handler
61
            mHandler = new PackageHandler(mHandlerThread.getLooper());
62
            // dataDir =/data/
63
            File dataDir = Environment.getDataDirectory();
64
            // mAppDataDir = /data/data
65
            mAppDataDir = new File(dataDir, "data");
66
            // mAsecInternalPath = /data/app-asec
67
            mAsecInternalPath = new File(dataDir, "app-asec").getPath();
68
            // mUserAppDataDir = /data/user
69
            mUserAppDataDir = new File(dataDir, "user");
70
            // mDrmAppPrivateInstallDir = /data/app-private
71
            mDrmAppPrivateInstallDir = new File(dataDir, "app-private");
72
            sUserManager = new UserManager(mInstaller, mUserAppDataDir);
73
            //读取并解析/etc/permissions下的XML文件
74
            readPermissions();
75
            mRestoredSettings = mSettings.readLPw();
76
             long startTime = SystemClock.uptimeMillis();//【2】
77
        }
78
    }
79

80
    Runtime.getRuntime().gc();
81
    //暴露私有服务，用于系统组件的使用
82
    LocalServices.addService(PackageManagerInternal.class,
83
    new PackageManagerInternalImpl());
84
}

1
mSettings.addSharedUserLPw("android.uid.system",//字符串
2
    Process.SYSTEM_UID, //系统进程使用的用户id，值为1000
3
    ApplicationInfo.FLAG_SYSTEM//标志系统 Package
4
);

1
SharedUserSetting addSharedUserLPw(String name, int uid, int pkgFlags) {
2
    /*
3
        注意这里的参数：name 为字符串”android.uid.system”，uid 为 1000，pkgFlags 为
4
        ApplicationInfo.FLAG_SYSETM (以后简写为FLAG_SYSTEM)
5
      */
6
    //mSharedUsers 是一个 HashMap，key 为字符串，值为 SharedUserSetting 对象
7
    SharedUserSetting s = mSharedUsers.get(name);
8
    if (s != null) {
9
        if (s.userId == uid) {
10
            return s;
11
        }
12
        //...
13
        return null;
14
    }
15

16
    //创建一个新的 SharedUserSettings 对象，并设置的 userId 为 uid
17
    s = new SharedUserSetting(name, pkgFlags);
18
    s.userId = uid;
19
    if (addUserIdLPw(uid, s, name)) {
20
        mSharedUsers.put(name, s);//将name与s键值对添加到mSharedUsers中保存
21
        return s;
22
    }
23
    return null;
24
}

1
<manifestxmlns:android="http://schemas.android.com/apk/res/android"
2
       package="com.android.systemui"
3
       coreApp="true"
4
       android:sharedUserId="android.uid.system"
5
       android:process="system">
6
...

1
private boolean addUserIdLPw(int uid, Object obj, Objectname) {
2
    //uid 不能超出限制。Android 对 UID 进行了分类，应用 APK 所在进程的 UID 从 10000 开始，
3
    //而系统 APK 所在进程小于 10000
4
    if (uid >= PackageManagerService.FIRST_APPLICATION_UID + PackageManagerService.MAX_APPLICATION_UIDS) {
5
        return false;
6
    }
7

8
    if (uid >= PackageManagerService.FIRST_APPLICATION_UID) {
9
        int N = mUserIds.size();
10
        //计算索引，其值是 uid 和 FIRST_APPLICATION_UID 的差
11
        final int index = uid - PackageManagerService.FIRST_APPLICATION_UID;
12
        while (index >= N) {
13
            mUserIds.add(null);
14
            N++;
15
        }
16
        //...
17
        //判断该索引位置的内容是否为空，为空才保存
18
        mUserIds.set(index, obj);//mUserIds 保存应用 Package 的 UID
19
    } else {
20
        //...
21
        mOtherUserIds.put(uid, obj);//系统 Package 的 UID 由 mOtherUserIds 保存
22
    }
23
    return true;
24
}

1
void readPermissions() {
2
    // 指向 /system/etc/permission 目录，该目录中存储了和设备相关的一些权限信息
3
    FilelibraryDir = new File(Environment.getRootDirectory(), "etc/permissions");
4
    //...
5
    for (File f : libraryDir.listFiles()) {
6
        //先处理该目录下的非platform.xml文件
7
        if (f.getPath().endsWith("etc/permissions/platform.xml")) {
8
            continue;
9
        }
10
        //...
11
        // 调用 readPermissionFromXml 解析此 XML 文件
12
        readPermissionsFromXml(f);
13
    }
14

15
    finalFile permFile = new File(Environment.getRootDirectory(), "etc/permissions/platform.xml");
16

17
    //解析 platform.xml 文件，看来该文件优先级最高
18
    readPermissionsFromXml(permFile);
19
}

1
private void readPermissionsFromXml(File permFile) {
2
    FileReader permReader = null;
3
    try {
4
        permReader = new FileReader(permFile);
5
    }
6
    //...
7
    try {
8
        XmlPullParser parser = Xml.newPullParser();
9
        parser.setInput(permReader);
10
        XmlUtils.beginDocument(parser, "permissions");
11
        while (true) {
12
            //...
13
            String name = parser.getName();
14
            //解析 group 标签，前面介绍的 XML 文件中没有单独使用该标签的地方
15
            if ("group".equals(name)) {
16
                String gidStr = parser.getAttributeValue(null, "gid");
17
                if (gidStr != null) {
18
                    int gid = Integer.parseInt(gidStr);
19
                    //转换 XML 中的 gi d字符串为整型，并保存到 mGlobalGids 中
20
                    mGlobalGids = appendInt(mGlobalGids, gid);
21
                }
22
                //...
23
            } else if ("permission".equals(name)) {//解析 permission 标签
24
                String perm = parser.getAttributeValue(null, "name");
25
                //...
26
                perm = perm.intern();
27
                //调用 readPermission 处理
28
                readPermission(parser, perm);
29
            } else if ("assign-permission".equals(name)) {//下面解析的是assign-permission标签
30
                String perm = parser.getAttributeValue(null, "name");
31
                //...
32
                String uidStr = parser.getAttributeValue(null, "uid");
33
                //...
34
                //如果是 assign-permission，则取出 uid 字符串，然后获得 Linux 平台上
35
                //的整型 uid 值
36
                int uid = Process.getUidForName(uidStr);
37
                //...
38
                perm = perm.intern();
39
                //和 assign 相关的信息保存在 mSystemPermissions 中
40
                HashSet<String> perms = mSystemPermissions.get(uid);
41
                if (perms == null) {
42
                    perms = newHashSet < String > ();
43
                    mSystemPermissions.put(uid, perms);
44
                }
45
                perms.add(perm);
46
                //...
47
            } else if ("library".equals(name)) {//解析 library 标签
48
                String lname = parser.getAttributeValue(null, "name");
49
                String lfile = parser.getAttributeValue(null, "file");
50
                if (lname == null) {
51
                    //...
52
                } else if (lfile == null) {
53
                    //...
54
                } else {
55
                    //将 XML 中的 name 和 library 属性值存储到 mSharedLibraries 中
56
                    mSharedLibraries.put(lname, lfile);
57
                }
58
                //...
59
            } else if ("feature".equals(name)) {//解析 feature 标签
60
                String fname = parser.getAttributeValue(null, "name");
61
                //...
62
                {
63
                    //在 XML 中定义的 feature 由 FeatureInfo 表达
64
                    FeatureInfo fi = newFeatureInfo();
65
                    fi.name = fname;
66
                    //存储 feature 名和对应的 FeatureInfo 到 mAvailableFeatures 中
67
                    mAvailableFeatures.put(fname, fi);
68
                }//...
69
            } //...
70
        } //...
71
    }
72
}

1
Settings() {
2
    FiledataDir = Environment.getDataDirectory();
3
    FilesystemDir = new File(dataDir, "system");//指向/data/system目录
4
    systemDir.mkdirs();//创建该目录
5
    //...
6
    /*
7
        一共有 5 个文件，packages.xml 和 packages-backup.xml 为一组，用于描述系统中
8
        所安装的 Package 的信息，其中 backup 是临时文件。PKMS 先把数据写到 backup 中，
9
        信息都写成功后再改名成非 backup 的文件。其目的是防止在写文件过程中出错，导致信息丢失。
10

11
        packages-stopped.xml 和 packages-stopped-backup.xml 为一组，用于描述系统中
12
        强制停止运行的 pakcage 的信息，backup 也是临时文件。如果此处存在该临时文件，表明
13
        此前系统因为某种原因中断了正常流程 packages.list 列出当前系统中应用级（即UID大于10000）Package 的信息
14
        */
15
    mSettingsFilename = new File(systemDir, "packages.xml");
16
    mBackupSettingsFilename = new File(systemDir, "packages-backup.xml");
17
    mPackageListFilename = new File(systemDir, "packages.list");
18
    mStoppedPackagesFilename = new File(systemDir, "packages-stopped.xml");
19
    mBackupStoppedPackagesFilename = new File(systemDir, "packages-stopped-backup.xml");
20
}

1
//...
2
mRestoredSettings = mSettings.readLPw();//接第一段的结尾
3
longstartTime = SystemClock.uptimeMillis();//记录扫描开始的时间
4
//定义扫描参数
5
intscanMode = SCAN_MONITOR | SCAN_NO_PATHS | SCAN_DEFER_DEX;
6
if (mNoDexOpt) {
7
    scanMode |= SCAN_NO_DEX; //在控制扫描过程中是否对 APK 文件进行 dex 优化
8
}
9
finalHashSet<String> libFiles = new HashSet<String>();
10
// mFrameworkDir指向/system/frameworks目录
11
mFrameworkDir = newFile(Environment.getRootDirectory(), "framework");
12
// mDalvikCacheDir指向/data/dalvik-cache目录
13
mDalvikCacheDir = new File(dataDir, "dalvik-cache");
14
booleandidDexOpt = false;
15
/*
16
  获取 Java 启动类库的路径，在 init.rc 文件中通过 BOOTCLASSPATH 环境变量输出，该值如下
17
  /system/framework/core.jar:/system/frameworks/core-junit.jar:
18
  /system/frameworks/bouncycastle.jar:/system/frameworks/ext.jar:
19
  /system/frameworks/framework.jar:/system/frameworks/android.policy.jar:
20
  /system/frameworks/services.jar:/system/frameworks/apache-xml.jar:
21
  /system/frameworks/filterfw.jar
22
  该变量指明了 framework 所有核心库及文件位置
23
 */
24
StringbootClassPath = System.getProperty("java.boot.class.path");
25
if (bootClassPath != null) {
26
    String[] paths = splitString(bootClassPath, ':');
27
    for (int i = 0; i < paths.length; i++) {
28
        try {  //判断该 jar 包是否需要重新做 dex 优化
29
            if (dalvik.system.DexFile.isDexOptNeeded(paths[i])) {
30
              /*
31
               将该 jar 包文件路径保存到 libFiles 中，然后通过 mInstall 对象发送
32
               命令给 installd，让其对该 jar 包进行 dex 优化
33
              */
34
                libFiles.add(paths[i]);
35
                mInstaller.dexopt(paths[i], Process.SYSTEM_UID, true);
36
                didDexOpt = true;
37
            }
38
        }
39
        //...
40
    }
41
}
42
//...
43
/*
44
还记得 mSharedLibrarires 的作用吗？它保存的是 platform.xml 中声明的系统库的信息。
45
这里也要判断系统库是否需要做 dex 优化。处理方式同上
46
*/
47
if (mSharedLibraries.size() > 0) {
48
    //...
49
}
50
//将 framework-res.apk 添加到 libFiles 中。framework-res.apk 定义了系统常用的
51
//资源，还有几个重要的 Activity，如长按 Power 键后弹出的选择框
52
libFiles.add(mFrameworkDir.getPath() + "/framework-res.apk");
53
//列举 /system/frameworks 目录中的文件
54
String[] frameworkFiles = mFrameworkDir.list();
55
if (frameworkFiles != null) {
56
    //...
57
    // 判断该目录下的 apk 或 jar 文件是否需要做 dex 优化。处理方式同上
58
}
59
/*
60
上面代码对系统库（BOOTCLASSPATH 指定，或 platform.xml 定义，或
61
/system/frameworks目录下的 jar 包与 apk 文件）进行一次仔细检查，该优化的一定要优化。
62
如果发现期间对任何一个文件进行了优化，则设置 didDexOpt 为 true
63
*/
64
if (didDexOpt) {
65
    String[] files = mDalvikCacheDir.list();
66
    if (files != null) {
67
        /*
68
        如果前面对任意一个系统库重新做过 dex 优化，就需要删除 cache 文件。原因和
69
        dalvik 虚拟机的运行机制有关。暂不探讨 dex 及 cache 文件的作用。
70
        从删除 cache 文件这个操作来看，这些 cache 文件应该使用了 dex 优化后的系统库
71
        所以当系统库重新做 dex 优化后，就需要删除旧的 cache 文件。可简单理解为缓存失效
72
        */
73
        for (int i = 0; i < files.length; i++) {
74
            String fn = files[i];
75
            if (fn.startsWith("data@app@") || fn.startsWith("data@app-private@")) {
76
                (newFile(mDalvikCacheDir, fn)).delete();
77
                //...
78
            }
79
        }
80
    }
81
}

1
//创建文件夹监控对象，监视 /system/frameworks 目录。利用了 Linux 平台的 notify 机制
2
mFrameworkInstallObserver = new AppDirObserver(mFrameworkDir.getPath(), OBSERVER_EVENTS, true);
3
mFrameworkInstallObserver.startWatching();
4

5
/*
6
 调用 scanDirLI 函数扫描 /system/frameworks 目录，这个函数很重要，稍后会再分析。
7
 注意，在第三个参数中设置了SCAN_NO_DEX标志，因为该目录下的package在前面的流程
8
 中已经过判断并根据需要做过dex优化了
9
 */
10
scanDirLI(mFrameworkDir, PackageParser.PARSE_IS_SYSTEM
11
                | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode | SCAN_NO_DEX, 0);
12
//创建文件夹监控对象，监视 /system/app 目录
13
mSystemAppDir = new File(Environment.getRootDirectory(), "app");
14
mSystemInstallObserver = new AppDirObserver(mSystemAppDir.getPath(), OBSERVER_EVENTS, true);
15
mSystemInstallObserver.startWatching();
16

17
//扫描 /system/app 下的 package
18
scanDirLI(mSystemAppDir, PackageParser.PARSE_IS_SYSTEM | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);
19

20
//监视并扫描 /vendor/app 目录
21
mVendorAppDir = new File("/vendor/app");
22
mVendorInstallObserver = new AppDirObserver(mVendorAppDir.getPath(), OBSERVER_EVENTS, true);
23
mVendorInstallObserver.startWatching();
24

25
//扫描 /vendor/app 下的 package
26
scanDirLI(mVendorAppDir, PackageParser.PARSE_IS_SYSTEM | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);
27

28
//和 installd 交互。以后单独分析 installd
29
mInstaller.moveFiles();

1
private void scanDirLI(File dir, int flags, int scanMode, long currentTime) {
2
    String[] files = dir.list();//列举该目录下的文件
3
    //...
4
    int i;
5
    for (i = 0; i < files.length; i++) {
6
        File file = new File(dir, files[i]);
7
        if (!isPackageFilename(files[i])) {
8
            continue; //根据文件名后缀，判断是否为APK 文件。这里只扫描APK 文件
9
        }
10

11
        /*
12
            调用scanPackageLI函数扫描一个特定的文件，返回值是PackageParser的内部类
13
            Package，该类的实例代表一个APK文件，所以它就是和APK文件对应的数据结构
14
            */
15
        PackageParser.Package pkg = scanPackageLI(file,
16
                                                  flags | PackageParser.PARSE_MUST_BE_APK, scanMode, currentTime);
17
        if (pkg == null && (flags & PackageParser.PARSE_IS_SYSTEM) == 0 &&
18
            mLastScanError == PackageManager.INSTALL_FAILED_INVALID_APK) {
19
            //注意此处flags的作用，只有非系统Package扫描失败，才会删除该文件
20
            file.delete();
21
        }
22
    }
23
}

1
private PackageParser.Package scanPackageLI(FilescanFile, int parseFlags,
2
                                                int scanMode, long currentTime) {
3
    mLastScanError = PackageManager.INSTALL_SUCCEEDED;
4
    StringscanPath = scanFile.getPath();
5
    parseFlags |= mDefParseFlags;//默认的扫描标志，正常情况下为0
6

7
    //创建一个 PackageParser 对象
8
    PackageParser pp = new PackageParser(scanPath);
9
    pp.setSeparateProcesses(mSeparateProcesses);// mSeparateProcesses 为空
10
    pp.setOnlyCoreApps(mOnlyCore);// mOnlyCore 为 false
11

12
    /*
13
           调用 PackageParser 的 parsePackage 函数解析APK文件。注意，这里把代表屏幕
14
           信息的 mMetrics 对象也传了进去
15
        */
16
    finalPackageParser.Package pkg = pp.parsePackage(scanFile,
17
                                                     scanPath, mMetrics, parseFlags);
18
    //...
19
    PackageSetting ps = null;
20
    PackageSetting updatedPkg;
21
    //...
22

23
    /*
24
            这里略去一大段代码，主要是关于 Package 升级方面的工作。
25
        */
26
    //收集签名信息，这部分内容涉及 signature。
27
    if (!collectCertificatesLI(pp, ps, pkg, scanFile, parseFlags))
28
        return null;
29

30
    //判断是否需要设置 PARSE_FORWARD_LOCK 标志，这个标志针对资源文件和 Class 文件
31
    //不在同一个目录的情况。目前只有 /vendor/app 目录下的扫描会使用该标志。这里不讨论
32
    //这种情况。
33
    if (ps != null && !ps.codePath.equals(ps.resourcePath))
34
        parseFlags |= PackageParser.PARSE_FORWARD_LOCK;
35

36
    String codePath = null;
37
    String resPath = null;
38
    if ((parseFlags & PackageParser.PARSE_FORWARD_LOCK) != 0) {
39
        //...//这里不考虑 PARSE_FORWARD_LOCK的情况。
40
    } else {
41
        resPath = pkg.mScanPath;
42
    }
43

44
    codePath = pkg.mScanPath;//mScanPath 指向该 APK 文件所在位置
45
    //设置文件路径信息，codePath 和 resPath 都指向 APK 文件所在位置
46
    setApplicationInfoPaths(pkg, codePath, resPath);
47

48
    //调用第二个 scanPackageLI 函数
49
    return scanPackageLI(pkg, parseFlags, scanMode | SCAN_UPDATE_SIGNATURE,
50
                         currentTime);
51
}

1
public Package parsePackage(File sourceFile, String destCodePath,
2
                                DisplayMetrics metrics, int flags) {
3
    mParseError = PackageManager.INSTALL_SUCCEEDED;
4
    mArchiveSourcePath = sourceFile.getPath();
5
    //...//检查是否为 APK 文件
6
    XmlResourceParser parser = null;
7
    AssetManager assmgr = null;
8
    Resources res = null;
9
    boolean assetError = true;
10
    try {
11
        assmgr = new AssetManager();
12
        int cookie = assmgr.addAssetPath(mArchiveSourcePath);
13
        if (cookie != 0) {
14
            res = new Resources(assmgr, metrics, null);
15
            assmgr.setConfiguration(0, 0, null, 0, 0, 0, 0, 0, 0, 0, 0, 0,
16
                                    0, 0, 0, 0, Build.VERSION.RESOURCES_SDK_INT);
17
            /*
18
              获得一个 XML 资源解析对象，该对象解析的是 APK 中的 AndroidManifest.xml 文件。
19
              以后再讨论 AssetManager、Resource 及相关的知识
20
             */
21
            parser = assmgr.openXmlResourceParser(cookie,
22
                                                  ANDROID_MANIFEST_FILENAME);
23
            assetError = false;
24
        } //...//出错处理
25
        String[] errorText = new String[1];
26
        Package pkg = null;
27
        Exception errorException = null;
28
        try {
29
            //调用另外一个 parsePackage 函数
30
            pkg = parsePackage(res, parser, flags, errorText);
31
        }//...
32

33
        //...//错误处理
34
        parser.close();
35
        assmgr.close();
36
        //保存文件路径，都指向 APK 文件所在的路径
37
        pkg.mPath = destCodePath;
38
        pkg.mScanPath = mArchiveSourcePath;
39
        pkg.mSignatures = null;
40
        return pkg;
41
    }
42
}

1
private Package parsePackage(Resources res, XmlResourceParser parser, int flags, String[] outError)
2
        throws XmlPullParserException, IOException {
3
    AttributeSet attrs = parser;
4
    mParseInstrumentationArgs = null;
5
    mParseActivityArgs = null;
6
    mParseServiceArgs = null;
7
    mParseProviderArgs = null;
8
    //得到 Package 的名字，其实就是得到 AndroidManifest.xml 中 package 属性的值，
9
    //每个 APK 都必须定义该属性
10
    String pkgName = parsePackageName(parser, attrs, flags, outError);
11
    //...
12
    int type;
13
    //...
14
    //以 pkgName 名字为参数，创建一个 Package 对象。后面的工作就是解析 XML 并填充
15
    //该 Package 信息
16
    final Package pkg = new Package(pkgName);
17
    boolean foundApp = false;
18
    //...//下面开始解析该文件中的标签，由于这段代码功能简单，所以这里仅列举相关函数
19
    while (如果解析未完成) {
20
        //...
21
        StringtagName = parser.getName(); //得到标签名
22
        if (tagName.equals("application")) {
23
            //...//解析 application 标签
24
            parseApplication(pkg, res, parser, attrs, flags, outError);
25
        } else if (tagName.equals("permission-group")) {
26
            //...//解析 permission-group 标签
27
            parsePermissionGroup(pkg, res, parser, attrs, outError);
28
        } else if (tagName.equals("permission")) {
29
            //...//解析 permission 标签
30
            parsePermission(pkg, res, parser, attrs, outError);
31
        } else if (tagName.equals("uses-permission")) {
32
            //从 XML 文件中获取 uses-permission 标签的属性
33
            sa = res.obtainAttributes(attrs,
34
                    com.android.internal.R.styleable.AndroidManifestUsesPermission);
35
            //取出属性值，也就是对应的权限使用声明
36
            String name = sa.getNonResourceString(com.android.internal.
37
                    R.styleable.AndroidManifestUsesPermission_name);
38
            //添加到 Package 的 requestedPermissions 数组
39
            if (name != null && !pkg.requestedPermissions.contains(name)) {
40
                pkg.requestedPermissions.add(name.intern());
41
            }
42
        } else if (tagName.equals("uses-configuration")) {
43
            /*
44
                该标签用于指明本 package 对硬件的一些设置参数，目前主要针对输入设备（触摸屏、键盘
45
                等）。游戏类的应用可能对此有特殊要求。
46
            */
47
            ConfigurationInfocPref = new ConfigurationInfo();
48
            //...//解析该标签所支持的各种属性
49
            pkg.configPreferences.add(cPref);//保存到 Package 的 configPreferences 数组
50
        }
51
        //...//对其他标签解析和处理
52
    }
53
}

1
private PackageParser.PackagescanPackageLI(
2
    PackageParser.Package pkg, int parseFlags, int scanMode, long currentTime) {
3
    FilescanFile = new File(pkg.mScanPath);
4
    //...
5
    mScanningPath = scanFile;
6
    //设置 package 对象中 applicationInfo 的 flags 标签，用于标示该 Package 为系统
7
    //Package
8
    if ((parseFlags & PackageParser.PARSE_IS_SYSTEM) != 0) {
9
        pkg.applicationInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
10
    }
11

12
    //下面这句 if 判断极为重要，见下面的解释
13
    if (pkg.packageName.equals("android")) {
14
        synchronized (mPackages) {
15
            if (mAndroidApplication != null) {
16
                //...
17

18
                mPlatformPackage = pkg;
19
                pkg.mVersionCode = mSdkVersion;
20
                mAndroidApplication = pkg.applicationInfo;
21
                mResolveActivity.applicationInfo = mAndroidApplication;
22
                mResolveActivity.name = ResolverActivity.class.getName();
23
                mResolveActivity.packageName = mAndroidApplication.packageName;
24
                mResolveActivity.processName = mAndroidApplication.processName;
25
                mResolveActivity.launchMode = ActivityInfo.LAUNCH_MULTIPLE;
26
                mResolveActivity.flags = ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS;
27
                mResolveActivity.theme = com.android.internal.R.style.Theme_Holo_Dialog_Alert;
28
                mResolveActivity.exported = true;
29
                mResolveActivity.enabled = true;
30
                //mResoveInfo 的 activityInfo 成员指向 mResolveActivity
31
                mResolveInfo.activityInfo = mResolveActivity;
32
                mResolveInfo.priority = 0;
33
                mResolveInfo.preferredOrder = 0;
34
                mResolveInfo.match = 0;
35
                mResolveComponentName = new ComponentName(
36
                        mAndroidApplication.packageName, mResolveActivity.name);
37
            }
38
        }
39
    }
40
}

1
//...//mPackages 用于保存系统内的所有 Package，以 packageName 为 key
2
if (mPackages.containsKey(pkg.packageName)
3
        || mSharedLibraries.containsKey(pkg.packageName)) {
4
    return null;
5
}
6

7
File destCodeFile = newFile(pkg.applicationInfo.sourceDir);
8
FiledestResourceFile = new File(pkg.applicationInfo.publicSourceDir);
9
SharedUserSettingsuid = null;//代表该 Package 的 SharedUserSetting 对象
10
PackageSetting pkgSetting = null;//代表该 Package 的 PackageSetting 对象
11
synchronized (mPackages) {
12
    //...//此段代码大约有300行左右，主要做了以下几方面工作
13
    /*
14
      1. 如果该 Package 声明了”uses-libraries” 话，那么系统要判断该 library 是否在 mSharedLibraries 中
15
      2. 如果 package 声明了 SharedUser，则需要处理 SharedUserSettings 相关内容，由 Settings 的 getSharedUserLPw 函数处理
16
      3. 处理 pkgSetting，通过调用 Settings 的 getPackageLPw 函数完成
17
      4. 调用 verifySignaturesLP 函数，检查该 Package 的 signature
18
     */
19
}
20
final long scanFileTime = scanFile.lastModified();
21
final boolean forceDex = (scanMode & SCAN_FORCE_DEX) != 0;
22
//确定运行该 package 的进程的进程名，一般用 packageName 作为进程名
23
pkg.applicationInfo.processName = fixProcessName(
24
        pkg.applicationInfo.packageName,
25
        pkg.applicationInfo.processName,
26
        pkg.applicationInfo.uid);
27

28
if (mPlatformPackage == pkg) {
29
    dataPath = new File(Environment.getDataDirectory(), "system");
30
    pkg.applicationInfo.dataDir = dataPath.getPath();
31
} else {
32
    /*
33
     getDataPathForPackage 函数返回该 package 的目录，一般是 /data/data/packageName/
34
   */
35
    dataPath = getDataPathForPackage(pkg.packageName, 0);
36
    if (dataPath.exists()) {
37
        //...//如果该目录已经存在，则要处理 uid 的问题
38
    } else {
39
        //...//向 installd 发送 install 命令，实际上就是在 /data/data 下
40
        //建立 packageName 目录。后续将分析 installd 相关知识
41
        int ret = mInstaller.install(pkgName, pkg.applicationInfo.uid,
42
                pkg.applicationInfo.uid);
43
        //为系统所有 user 安装此程序
44
        mUserManager.installPackageForAllUsers(pkgName,
45
                pkg.applicationInfo.uid);
46
        if (dataPath.exists()) {
47
            pkg.applicationInfo.dataDir = dataPath.getPath();
48
        } //...
49

50
        if (pkg.applicationInfo.nativeLibraryDir == null &&
51
                pkg.applicationInfo.dataDir != null) {
52
            //...//为该 Package 确定 native library 所在目录
53
            //一般是 /data/data/packagename/lib
54
        }
55
    }
56

57
    //如果该 APK 包含了 native 动态库，则需要将它们从 APK 文件中解压并复制到对应目录中
58
    if (pkg.applicationInfo.nativeLibraryDir != null) {
59
        try {
60
            final File nativeLibraryDir = new
61
                    File(pkg.applicationInfo.nativeLibraryDir);
62
            final String dataPathString = dataPath.getCanonicalPath();
63

64
            //从 2.3 开始，系统 package 的 native 库统一放在 /system/lib 下。所以
65
            //系统不会提取系统 Package 目录下 APK 包中的 native 库
66
            if (isSystemApp(pkg) && !isUpdatedSystemApp(pkg)) {
67
                NativeLibraryHelper.removeNativeBinariesFromDirLI(
68
                        nativeLibraryDir)){
69
                } else if (nativeLibraryDir.getParentFile().getCanonicalPath()
70
                        .equals(dataPathString)) {
71
                    boolean isSymLink;
72
                    try {
73
                        isSymLink = S_ISLNK(Libcore.os.lstat(
74
                                nativeLibraryDir.getPath()).st_mode);
75

76
                    } //...//判断是否为链接，如果是，需要删除该链接
77
                    if (isSymLink) {
78
                        mInstaller.unlinkNativeLibraryDirectory(dataPathString);
79
                    }
80

81
                    //在 lib 下建立和 CPU 类型对应的目录，例如 ARM 平台的是 arm/，MIPS 平台的是 mips/
82
                    NativeLibraryHelper.copyNativeBinariesIfNeededLI(scanFile,
83
                            nativeLibraryDir);
84
                } else {
85
                    mInstaller.linkNativeLibraryDirectory(dataPathString,
86
                            pkg.applicationInfo.nativeLibraryDir);
87
                }
88
            } //...
89
        }
90
        pkg.mScanPath = path;
91
        if ((scanMode & SCAN_NO_DEX) == 0) {
92
            //...//对该 APK 做 dex 优化
93
            performDexOptLI(pkg, forceDex, (scanMode & SCAN_DEFER_DEX);
94
        }
95
        //如果该 APK 已经存在，要先杀掉运行该 APK 的进程
96
        if ((parseFlags & PackageManager.INSTALL_REPLACE_EXISTING) != 0) {
97
            killApplication(pkg.applicationInfo.packageName,
98
                    pkg.applicationInfo.uid);
99
        }
100
        //...
101
        /*
102
         在此之前，四大组件信息都属于 Package 的私有财产，现在需要把它们登记注册到 PKMS 内部的
103
         财产管理对象中。这样，PKMS 就可对外提供统一的组件信息，而不必拘泥于具体的 Package
104
         */
105
        synchronized (mPackages) {
106
            if ((scanMode & SCAN_MONITOR) != 0) {
107
                mAppDirs.put(pkg.mPath, pkg);
108
            }
109
            mSettings.insertPackageSettingLPw(pkgSetting, pkg);
110
            mPackages.put(pkg.applicationInfo.packageName, pkg);
111
            //处理该 Package 中的 Provider 信息
112
            int N = pkg.providers.size();
113
            int i;
114
            for (i = 0; i < N; i++) {
115
                PackageParser.Providerp = pkg.providers.get(i);
116
                p.info.processName = fixProcessName(
117
                        pkg.applicationInfo.processName,
118
                        p.info.processName, pkg.applicationInfo.uid);
119
                //mProvidersByComponent 提供基于 ComponentName 的 Provider 信息查询
120
                mProvidersByComponent.put(new ComponentName(
121
                        //...
122
            }
123
            //处理该 Package 中的 Service 信息
124
            N = pkg.services.size();
125
            r = null;
126
            for (i = 0; i < N; i++) {
127
                PackageParser.Service s = pkg.services.get(i);
128
                mServices.addService(s);
129
            }
130
            //处理该 Package 中的 BroadcastReceiver 信息
131
            N = pkg.receivers.size();
132
            r = null;
133
            for (i = 0; i < N; i++) {
134
                PackageParser.Activity a = pkg.receivers.get(i);
135
                mReceivers.addActivity(a, "receiver");
136
                //...
137
            }
138
            //处理该 Package 中的 Activity 信息
139
            N = pkg.activities.size();
140
            r = null;
141
            for (i = 0; i < N; i++) {
142
                PackageParser.Activity a = pkg.activities.get(i);
143
                mActivities.addActivity(a, "activity");
144
            }
145
            //处理该 Package 中的 PermissionGroups 信息
146
            N = pkg.permissionGroups.size();
147
            //...//permissionGroups 处理
148
            N = pkg.permissions.size();
149
            //...//permissions 处理
150
            N = pkg.instrumentation.size();
151
            //...//instrumentation 处理
152
            if (pkg.protectedBroadcasts != null) {
153
                N = pkg.protectedBroadcasts.size();
154
                for (i = 0; i < N; i++) {
155
                    mProtectedBroadcasts.add(pkg.protectedBroadcasts.get(i));
156
                }
157
            }
158
            //...//Package 的私有财产终于完成了公有化改造
159
            return pkg;
160
        }
161
    }
162
}

1
if (!mOnlyCore) {//mOnlyCore 用于控制是否扫描非系统 Package
2
    Iterator<PackageSetting> psit = mSettings.mPackages.values().iterator();
3

4
    while (psit.hasNext()) {
5
        //...//删除系统package中那些不存在的APK
6
    }
7

8
    mAppInstallDir = new File(dataDir, "app");
9
    //...//删除安装不成功的文件及临时文件
10
    if (!mOnlyCore) {
11
        //在普通模式下，还需要扫描 /data/app 以及 /data/app_private 目录
12
        mAppInstallObserver = new AppDirObserver(
13
                mAppInstallDir.getPath(), OBSERVER_EVENTS, false);
14
        mAppInstallObserver.startWatching();
15
        scanDirLI(mAppInstallDir, 0, scanMode, 0);
16
        mDrmAppInstallObserver = newAppDirObserver(
17
                mDrmAppPrivateInstallDir.getPath(), OBSERVER_EVENTS, false);
18
        mDrmAppInstallObserver.startWatching();
19
        scanDirLI(mDrmAppPrivateInstallDir,
20
                PackageParser.PARSE_FORWARD_LOCK, scanMode, 0);
21
    } else {
22
        mAppInstallObserver = null;
23
        mDrmAppInstallObserver = null;
24
    }
25
}

1
mSettings.mInternalSdkPlatform= mSdkVersion;
2

3
    //汇总并更新和 Permission 相关的信息
4
    updatePermissionsLPw(null, null, true, regrantPermissions,regrantPermissions);
5

6
    //将信息写到 package.xml、package.list 及 package-stopped.xml 文件中
7
    mSettings.writeLPr();
8
    Runtime.getRuntime().gc();
9
    mRequiredVerifierPackage= getRequiredVerifierLPr();
10
    //...//PKMS 构造函数返回
11
}

1
public PackageManager getPackageManager() {
2
    if (mPackageManager != null) {
3
        return mPackageManager;
4
    }
5
  //见下面分析
6
    IPackageManager pm = ActivityThread.getPackageManager();
7
    if (pm != null) {
8
        //创建 ApplicationPackageManager 对象
9
        return (mPackageManager = new ApplicationPackageManager(this, pm));
10
    }
11
    return null;
12
}

1
public static IPackageManager getPackageManager() {
2
    if (sPackageManager != null) {
3
        return sPackageManager;
4
    }
5
    IBinder b = ServiceManager.getService("package");
6
    sPackageManager = IPackageManager.Stub.asInterface(b);
7
    return sPackageManager;
8
}

1
public void performBootDexOpt() {
2
   // 确保只有 system 或者 root uid 有权限执行该方法
3
   enforceSystemOrRoot("Only the system can request dexopt be performed");
4

5
   //运行在同一个进程,此处拿到的 MountService 的服务端
6
   IMountService ms = PackageHelper.getMountService();
7
   if (ms != null) {
8
       final boolean isUpgrade = isUpgrade(); //处于更新状态，则执行fstrim
9
       boolean doTrim = isUpgrade;
10
       if (doTrim) {
11
           Slog.w(TAG, "Running disk maintenance immediately due to system update");
12
       } else {
13
           //interval 默认值为 3 天
14
           final long interval = android.provider.Settings.Global.getLong(
15
                   mContext.getContentResolver(),
16
                   android.provider.Settings.Global.FSTRIM_MANDATORY_INTERVAL,
17
                   DEFAULT_MANDATORY_FSTRIM_INTERVAL);
18
           if (interval > 0) {
19
               final long timeSinceLast = System.currentTimeMillis() - ms.lastMaintenance();
20
               if (timeSinceLast > interval) {
21
                   doTrim = true; //距离上次 fstrim 时间超过 3 天，则执行 fstrim
22
               }
23
           }
24
       }
25
       //此处 ms 是指 MountService，该过程发送消息 H_FSTRIM 给 handler，然后再向 vold 发送 fstrim 命令
26
       if (doTrim) {
27
           ms.runMaintenance();
28
       }
29
   }
30

31
   final ArraySet<PackageParser.Package> pkgs;
32
   synchronized (mPackages) {
33
       //清空延迟执行 dexopt 操作的 app，获取 dexopt 操作的 app 集合
34
       pkgs = mPackageDexOptimizer.clearDeferredDexOptPackages();
35
   }
36

37
   if (pkgs != null) {
38
       ArrayList<PackageParser.Package> sortedPkgs = new ArrayList<PackageParser.Package>();
39

40
       for (Iterator<PackageParser.Package> it = pkgs.iterator(); it.hasNext();) {
41
           PackageParser.Package pkg = it.next();
42
           //将 pkgs 中的核心 app 添加到 sortedPkgs
43
           if (pkg.coreApp) {
44
               sortedPkgs.add(pkg);
45
               it.remove();
46
           }
47
       }
48

49
       //获取监听 PRE_BOOT_COMPLETE 的系统 app 集合
50
       Intent intent = new Intent(Intent.ACTION_PRE_BOOT_COMPLETED);
51
       ArraySet<String> pkgNames = getPackageNamesForIntent(intent);
52

53
       for (Iterator<PackageParser.Package> it = pkgs.iterator(); it.hasNext();) {
54
           PackageParser.Package pkg = it.next();
55
           //将 pkg 中监听 PRE_BOOT_COMPLETE 的 app 添加到 sortedPkgs
56
           if (pkgNames.contains(pkg.packageName)) {
57
               sortedPkgs.add(pkg);
58
               it.remove();
59
           }
60
       }
61

62
       //获取 pkgs 中最近一周使用过的 app，详见下面
63
       filterRecentlyUsedApps(pkgs);
64

65
       //将最近一周的 app 添加到 sortedPkgs
66
       for (PackageParser.Package pkg : pkgs) {
67
           sortedPkgs.add(pkg);
68
       }
69

70
       if (mLazyDexOpt) {
71
           filterRecentlyUsedApps(sortedPkgs);
72
       }
73

74
       int i = 0;
75
       int total = sortedPkgs.size();
76
       File dataDir = Environment.getDataDirectory();
77
       long lowThreshold = StorageManager.from(mContext).getStorageLowBytes(dataDir);
78
       ...
79

80
       for (PackageParser.Package pkg : sortedPkgs) {
81
           long usableSpace = dataDir.getUsableSpace();
82
           if (usableSpace < lowThreshold) {
83
               break;
84
           }
85
           //详见下面
86
           performBootDexOpt(pkg, ++i, total);
87
       }
88
   }
89
}
90

91
private void filterRecentlyUsedApps(Collection<PackageParser.Package> pkgs) {
92

93
     if (mLazyDexOpt || (!isFirstBoot() && mPackageUsage.isHistoricalPackageUsageAvailable())) {
94
         int total = pkgs.size();
95
         int skipped = 0;
96
         long now = System.currentTimeMillis();
97
         for (Iterator<PackageParser.Package> i = pkgs.iterator(); i.hasNext();) {
98
             PackageParser.Package pkg = i.next();
99
             // 过滤出最近使用过的 app
100
             long then = pkg.mLastPackageUsageTimeInMills;
101
             if (then + mDexOptLRUThresholdInMills < now) {
102
                 i.remove();
103
                 skipped++;
104
             }
105
         }
106
     }
107
}
108

109
private void performBootDexOpt(PackageParser.Package pkg, int curr, int total) {
110
    if (!isFirstBoot()) {
111
        ActivityManagerNative.getDefault().showBootMessage(
112
              mContext.getResources().getString(R.string.android_upgrading_apk,
113
                  curr, total), true);
114
    }
115
    PackageParser.Package p = pkg;
116
    synchronized (mInstallLock) {
117
        mPackageDexOptimizer.performDexOpt(p, null /* instruction sets */,
118
                false /* force dex */, false /* defer */, true /* include dependencies */,
119
                false /* boot complete */, false /*useJit*/);
120
    }
121
}