应用安装-开机安装应用

Android应用安装 阅读量

一、应用安装类型

1. 安装方式：

  1. 安装系统APK和预制APK时，通过PMS的构造函数中安装，即第一次开机时安装应用，没有安装界面。
  2. 网络下载安装，通过应用商店等，即调用PackageManager.installPackage()，有安装界面。
  3. 通过adb工具安装，没有安装界面，它通过启动pm脚本的形式，然后调用com.android.commands.pm.Pm类，之后调用到PMS.installStage()完成安装。
  4. 安装本地apk，有安装界面，由PackageInstaller系统应用安装。
    上述几种方式均通过PackageInstallObserver来监听安装是否成功。

2. 涉及到的路径
应用安装涉及到如下几个目录：

  • /system/app：系统自带的应用程序，获得adb root权限才能删除
  • data/app —————用户程序安装的目录。安装时把apk文件复制到此目录
  • data/data —————存放应用程序的数据
  • data/dalvik-cache——–将apk中的dex文件安装到dalvik-cache目录下(dex文件是dalvik虚拟机的可执行文件,其大小约为原始apk文件大小的四分之一)

安装过程中复制APK安装包到data/app目录下，解压并扫描安装包，把dex文件(Dalvik字节码)保存到dalvik-cache目录，并data/data目录下创建对应的应用数据目录。

卸载时删除安装过程中在上述几个目录下创建的文件及目录。

以上内容参考https://www.cnblogs.com/meizixiong/p/3551891.html。

二、安装过程

https://www.cnblogs.com/z1987/p/8974719.html提供了四种安装方式的时序图。

https://www.jianshu.com/p/4f16421d5c7f系统讲解了PKMS。

首次开机安装

该过程在PKMS的构造方法中进行，主要的工作是解析预置app的相关信息，写入到/data/system/packages.xml中，并处理应用的数据。之后开机的扫描过程用于处理应用发生改变的情况，比如通过adb改变包，ota升级改变apk等。

  1. 首先是设置scanFlags:
1
2
3
4
int scanFlags = SCAN_BOOTING | SCAN_INITIAL;
if (mIsUpgrade || mFirstBoot) {
    scanFlags = scanFlags | SCAN_FIRST_BOOT_OR_UPGRADE;
}

  1. 收集系统目录下的app，包括以下几个目录：

    /vendor/overlay
    /system/framework
    /system/priv-app
    /system/app
    /vendor/priv-app
    /vendor/app
    /oem/app

    代码如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
       // Collect vendor overlay packages. (Do this before scanning any apps.)
       // For security and version matching reason, only consider
       // overlay packages if they reside in the right directory.
       scanDirTracedLI(new File(VENDOR_OVERLAY_DIR), mDefParseFlags
               | PackageParser.PARSE_IS_SYSTEM
               | PackageParser.PARSE_IS_SYSTEM_DIR
               | PackageParser.PARSE_TRUSTED_OVERLAY, scanFlags | SCAN_TRUSTED_OVERLAY, 0);
    //记录AndroidManifest文件的android:isStatic为true的package
       mParallelPackageParserCallback.findStaticOverlayPackages();

       // Find base frameworks (resource packages without code).
       scanDirTracedLI(frameworkDir, mDefParseFlags
               | PackageParser.PARSE_IS_SYSTEM
               | PackageParser.PARSE_IS_SYSTEM_DIR
               | PackageParser.PARSE_IS_PRIVILEGED,
               scanFlags | SCAN_NO_DEX, 0);

       // Collected privileged system packages.
       final File privilegedAppDir = new File(Environment.getRootDirectory(), "priv-app");
       scanDirTracedLI(privilegedAppDir, mDefParseFlags
               | PackageParser.PARSE_IS_SYSTEM
               | PackageParser.PARSE_IS_SYSTEM_DIR
               | PackageParser.PARSE_IS_PRIVILEGED, scanFlags, 0);

       // Collect ordinary system packages.
       final File systemAppDir = new File(Environment.getRootDirectory(), "app");
       scanDirTracedLI(systemAppDir, mDefParseFlags
               | PackageParser.PARSE_IS_SYSTEM
               | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags, 0);

       // Collect all vendor packages.
       File vendorAppDir = new File("/vendor/app");
       try {
           vendorAppDir = vendorAppDir.getCanonicalFile();
       } catch (IOException e) {
           // failed to look up canonical path, continue with original one
       }
       scanDirTracedLI(vendorAppDir, mDefParseFlags
               | PackageParser.PARSE_IS_SYSTEM
               | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags, 0);

       // Collect all OEM packages.
       final File oemAppDir = new File(Environment.getOemDirectory(), "app");
       scanDirTracedLI(oemAppDir, mDefParseFlags
               | PackageParser.PARSE_IS_SYSTEM
               | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags, 0);

    几个目录下的扫描过程类似，/vendor/overay比较特殊，该目录下的app用于进行运行时资源替换（RRO）。该部分扫描只会处理framework-res.apk之外apk的rro，因为framework-res.apk比较特殊，必须在系统启动的时候就进行处理，该过程在native层进行，这里不做了解。/vendor/overay下的app扫描完之后，相比其他目录多了 mParallelPackageParserCallback.findStaticOverlayPackages();的操作，用于找出rro中的staticOverlay，staticOverlay是在Android O中才出现的，非static的overlay默认是disable的，但是可以在adb中进行enable，具体可以了解OverlayManagerService及其他资源管理相关内容。

    ​

    scanDirTracedLI的实现如下：

1
2
3
4
5
6
7
8
private void scanDirTracedLI(File dir, final int parseFlags, int scanFlags, long currentTime) {
    Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "scanDir [" + dir.getAbsolutePath() + "]");
    try {
        scanDirLI(dir, parseFlags, scanFlags, currentTime);
    } finally {
        Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
private void scanDirLI(File dir, int parseFlags, int scanFlags, long currentTime) {
      final File[] files = dir.listFiles();
      if (ArrayUtils.isEmpty(files)) {
          Log.d(TAG, "No files in app dir " + dir);
          return;
      }

      if (DEBUG_PACKAGE_SCANNING) {
          Log.d(TAG, "Scanning app dir " + dir + " scanFlags=" + scanFlags
                  + " flags=0x" + Integer.toHexString(parseFlags));
      }
      ParallelPackageParser parallelPackageParser = new ParallelPackageParser(
              mSeparateProcesses, mOnlyCore, mMetrics, mCacheDir,
              mParallelPackageParserCallback);

      // Submit files for parsing in parallel
      int fileCount = 0;
      for (File file : files) {
          final boolean isPackage = (isApkFile(file) || file.isDirectory())
                  && !PackageInstallerService.isStageName(file.getName());
          if (!isPackage) {
              // Ignore entries which are not packages
              continue;
          }
          parallelPackageParser.submit(file, parseFlags);
          fileCount++;
      }

      // Process results one by one
      for (; fileCount > 0; fileCount--) {
          ParallelPackageParser.ParseResult parseResult = parallelPackageParser.take();
          Throwable throwable = parseResult.throwable;
          int errorCode = PackageManager.INSTALL_SUCCEEDED;

          if (throwable == null) {
              // Static shared libraries have synthetic package names
              if (parseResult.pkg.applicationInfo.isStaticSharedLibrary()) {
                  renameStaticSharedLibraryPackage(parseResult.pkg);
              }
              try {
                  if (errorCode == PackageManager.INSTALL_SUCCEEDED) {
                      scanPackageLI(parseResult.pkg, parseResult.scanFile, parseFlags, scanFlags,
                              currentTime, null);
                  }
              } catch (PackageManagerException e) {
                  errorCode = e.error;
                  Slog.w(TAG, "Failed to scan " + parseResult.scanFile + ": " + e.getMessage());
              }
          } else if (throwable instanceof PackageParser.PackageParserException) {
              PackageParser.PackageParserException e = (PackageParser.PackageParserException)
                      throwable;
              errorCode = e.error;
              Slog.w(TAG, "Failed to parse " + parseResult.scanFile + ": " + e.getMessage());
          } else {
              throw new IllegalStateException("Unexpected exception occurred while parsing "
                      + parseResult.scanFile, throwable);
          }

          // Delete invalid userdata apps
          if ((parseFlags & PackageParser.PARSE_IS_SYSTEM) == 0 &&
                  errorCode == PackageManager.INSTALL_FAILED_INVALID_APK) {
              logCriticalInfo(Log.WARN,
                      "Deleting invalid package at " + parseResult.scanFile);
              removeCodePathLI(parseResult.scanFile);
          }
      }
      parallelPackageParser.close();
  }

scanDirTracedLI调用了scanDirLI方法,该方法的逻辑很简单，扫描/vendor/overlay目录下的所有文件，将apk文件和文件夹提交给ParallelPackageParser进行解析，ParallelPackageParser中采用了线程池和BlockingQueue进行并发的解析，解析类为PackageParser，主要是解析app的AndroidManifest.xml文件/解析结果放到BlockingQueue中，再通过take方法取出，关于ParallelPackageParser会另行总结，现在先关心主线 。解析正常的话，将结果传递给scanPackageLI方法进行进一步处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
private PackageParser.Package scanPackageLI(PackageParser.Package pkg, File scanFile,
            final int policyFlags, int scanFlags, long currentTime, @Nullable UserHandle user)
            throws PackageManagerException {
        // If the package has children and this is the first dive in the function
        // we scan the package with the SCAN_CHECK_ONLY flag set to see whether all
        // packages (parent and children) would be successfully scanned before the
        // actual scan since scanning mutates internal state and we want to atomically
        // install the package and its children.
        if ((scanFlags & SCAN_CHECK_ONLY) == 0) {
            if (pkg.childPackages != null && pkg.childPackages.size() > 0) {
                scanFlags |= SCAN_CHECK_ONLY;
            }
        } else {
            scanFlags &= ~SCAN_CHECK_ONLY;
        }

        // Scan the parent
        PackageParser.Package scannedPkg = scanPackageInternalLI(pkg, scanFile, policyFlags,
                scanFlags, currentTime, user);

        // Scan the children
        final int childCount = (pkg.childPackages != null) ? pkg.childPackages.size() : 0;
        for (int i = 0; i < childCount; i++) {
            PackageParser.Package childPackage = pkg.childPackages.get(i);
            scanPackageInternalLI(childPackage, scanFile, policyFlags, scanFlags,
                    currentTime, user);
        }


        if ((scanFlags & SCAN_CHECK_ONLY) != 0) {
            return scanPackageLI(pkg, scanFile, policyFlags, scanFlags, currentTime, user);
        }

        return scannedPkg;
    }

这里有个问题，既然已经解析出了Package信息，为什么还要对得到的Package对象再次进行解析呢？这里主要是为了处理应用升级的情况。

关于children package还不清楚是什么，这里先不去了解，还是先关心主线再说。除去children package相关的内容，其实这个方法里只有一行关键代码：

1
2
PackageParser.Package scannedPkg = scanPackageInternalLI(pkg, scanFile, policyFlags,
        scanFlags, currentTime, user);

scanPackageInternalLI方法很长，里面包含很多和升级相关的代码，这里暂时只了解应用的安装过程，应用升级以后再做了解。

1
2
PackageParser.Package scannedPkg = scanPackageLI(pkg, policyFlags, scanFlags
        | SCAN_UPDATE_SIGNATURE, currentTime, user);

scanPackageLI方法中调用了scanPackageLI方法来实现package的扫描：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private PackageParser.Package scanPackageLI(PackageParser.Package pkg, final int policyFlags,
        int scanFlags, long currentTime, @Nullable UserHandle user)
                throws PackageManagerException {
    boolean success = false;
    try {
        final PackageParser.Package res = scanPackageDirtyLI(pkg, policyFlags, scanFlags,
                currentTime, user);
        success = true;
        return res;
    } finally {
        if (!success && (scanFlags & SCAN_DELETE_DATA_ON_FAILURES) != 0) {
            // DELETE_DATA_ON_FAILURES is only used by frozen paths
  //……
    }
}

scanPackageDirtyLI的代码太多，一部分一部分的来看。

  1. applyPolicy

applyPolicy(pkg, policyFlags);该方法根据发起扫描时传递的parseFlags设置Package对象中的一些属性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
 * Applies policy to the parsed package based upon the given policy flags.
 * Ensures the package is in a good state.
 * <p>
 * Implementation detail: This method must NOT have any side effect. It would
 * ideally be static, but, it requires locks to read system state.
 */
private void applyPolicy(PackageParser.Package pkg, int policyFlags) {
    if ((policyFlags&PackageParser.PARSE_IS_SYSTEM) != 0) {
        pkg.applicationInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
        if (pkg.applicationInfo.isDirectBootAware()) {//加密时不输入密码即可访问
            // we're direct boot aware; set for all components
            for (PackageParser.Service s : pkg.services) {
                s.info.encryptionAware = s.info.directBootAware = true;
            }
            for (PackageParser.Provider p : pkg.providers) {
                p.info.encryptionAware = p.info.directBootAware = true;
            }
            for (PackageParser.Activity a : pkg.activities) {
                a.info.encryptionAware = a.info.directBootAware = true;
            }
            for (PackageParser.Activity r : pkg.receivers) {
                r.info.encryptionAware = r.info.directBootAware = true;
            }
        }
        if (compressedFileExists(pkg.codePath)) {
            pkg.isStub = true;
        }
    } else {
        // Only allow system apps to be flagged as core apps.
        pkg.coreApp = false;//也就是说不是systemapp设置了coreApp的属性也是没用的
        // clear flags not applicable to regular apps
        pkg.applicationInfo.privateFlags &=
                ~ApplicationInfo.PRIVATE_FLAG_DEFAULT_TO_DEVICE_PROTECTED_STORAGE;
        pkg.applicationInfo.privateFlags &=
                ~ApplicationInfo.PRIVATE_FLAG_DIRECT_BOOT_AWARE;
    }
    //表示/vendor/overlay下的app
    pkg.mTrustedOverlay = (policyFlags&PackageParser.PARSE_TRUSTED_OVERLAY) != 0;

    if ((policyFlags&PackageParser.PARSE_IS_PRIVILEGED) != 0) {
        pkg.applicationInfo.privateFlags |= ApplicationInfo.PRIVATE_FLAG_PRIVILEGED;
    }

    if (!isSystemApp(pkg)) {
        // Only system apps can use these features.
        pkg.mOriginalPackages = null;//关于origin-package可以参考另一个
        pkg.mRealPackage = null;
        pkg.mAdoptPermissions = null;
    }
}
  1. assertPackageIsValid

assertPackageIsValid(pkg, policyFlags, scanFlags);验证pkg是否有效，如返回PackageManagerException异常会被scanDirLI方法捕获。该方法中进行了包名重复apk的检验、StaticSharedLibrary相关检验、child package检验、路径检测和content provider冲突检测等工作，逻辑比较简单但是代码比较多，就不贴出来了，需要的时候去看下代码就好。

  1. 变量初始化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Initialize package source and resource directories
final File scanFile = new File(pkg.codePath);
final File destCodeFile = new File(pkg.applicationInfo.getCodePath());
final File destResourceFile = new File(pkg.applicationInfo.getResourcePath());

SharedUserSetting suid = null;
PackageSetting pkgSetting = null;

// Getting the package setting may have a side-effect, so if we
// are only checking if scan would succeed, stash a copy of the
// old setting to restore at the end.
PackageSetting nonMutatedPs = null;

// We keep references to the derived CPU Abis from settings in oder to reuse
// them in the case where we're not upgrading or booting for the first time.
String primaryCpuAbiFromSettings = null;
String secondaryCpuAbiFromSettings = null;
  1. **之后的代码会锁mPackages.**该部分代码的分析直接添加在注释中。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
  synchronized (mPackages) {
    if (pkg.mSharedUserId != null) {
        // SIDE EFFECTS; may potentially allocate a new shared user
        // 根据pkg中信息生成新的uid，不存在则创建一个
        suid = mSettings.getSharedUserLPw(
                pkg.mSharedUserId, 0 /*pkgFlags*/, 0 /*pkgPrivateFlags*/, true /*create*/);
    }

    // ……origin-package相关内容，该部分摘出去，单独了解

    // See comments in nonMutatedPs declaration
    if ((scanFlags & SCAN_CHECK_ONLY) != 0) {
        PackageSetting foundPs = mSettings.getPackageLPr(pkg.packageName);
        if (foundPs != null) {
            nonMutatedPs = new PackageSetting(foundPs);
        }
    }
    // 如不是第一次启动或者升级，则直接从Settings中读取ABI信息
    if ((scanFlags & SCAN_FIRST_BOOT_OR_UPGRADE) == 0) {
        PackageSetting foundPs = mSettings.getPackageLPr(pkg.packageName);
        if (foundPs != null) {
            primaryCpuAbiFromSettings = foundPs.primaryCpuAbiString;
            secondaryCpuAbiFromSettings = foundPs.secondaryCpuAbiString;
        }
    }

    pkgSetting = mSettings.getPackageLPr(pkg.packageName);
    //　pkg新扫描生成的uid和原本保存的不一致
    if (pkgSetting != null && pkgSetting.sharedUser != suid) {
      　//打印关键信息ｌｏｇ
        PackageManagerService.reportSettingsProblem(Log.WARN,
                "Package " + pkg.packageName + " shared user changed from "
                        + (pkgSetting.sharedUser != null
                                ? pkgSetting.sharedUser.name : "<nothing>")
                        + " to "
                        + (suid != null ? suid.name : "<nothing>")
                        + "; replacing with new");
        pkgSetting = null;//需要更新PackageSetting信息
    }
    
    //更新PackageSetting信息｛｛
    final PackageSetting oldPkgSetting =
            pkgSetting == null ? null : new PackageSetting(pkgSetting);
    final PackageSetting disabledPkgSetting =
            mSettings.getDisabledSystemPkgLPr(pkg.packageName);

    String[] usesStaticLibraries = null;
    if (pkg.usesStaticLibraries != null) {
        usesStaticLibraries = new String[pkg.usesStaticLibraries.size()];
        pkg.usesStaticLibraries.toArray(usesStaticLibraries);
    }
　　　　　　 //package的信息不存在（第一次扫描到该应用）或者uid发生改变
    if (pkgSetting == null) {
        final String parentPackageName = (pkg.parentPackage != null)
                ? pkg.parentPackage.packageName : null;
        final boolean instantApp = (scanFlags & SCAN_AS_INSTANT_APP) != 0;
        final boolean virtualPreload = (scanFlags & SCAN_AS_VIRTUAL_PRELOAD) != 0;
        // REMOVE SharedUserSetting from method; update in a separate call
        pkgSetting = Settings.createNewSetting(pkg.packageName, origPackage,
                disabledPkgSetting, realName, suid, destCodeFile, destResourceFile,
                pkg.applicationInfo.nativeLibraryRootDir, pkg.applicationInfo.primaryCpuAbi,
                pkg.applicationInfo.secondaryCpuAbi, pkg.mVersionCode,
                pkg.applicationInfo.flags, pkg.applicationInfo.privateFlags, user,
                true /*allowInstall*/, instantApp, virtualPreload,
                parentPackageName, pkg.getChildPackageNames(),
                UserManagerService.getInstance(), usesStaticLibraries,
                pkg.usesStaticLibrariesVersions);
        // SIDE EFFECTS; updates system state; move elsewhere
        if (origPackage != null) {
            mSettings.addRenamedPackageLPw(pkg.packageName, origPackage.name);
        }
        mSettings.addUserToSettingLPw(pkgSetting);
    } else {
        // REMOVE SharedUserSetting from method; update in a separate call.
        //
        // TODO(narayan): This update is bogus. nativeLibraryDir & primaryCpuAbi,
        // secondaryCpuAbi are not known at this point so we always update them
        // to null here, only to reset them at a later point.
        Settings.updatePackageSetting(pkgSetting, disabledPkgSetting, suid, destCodeFile,
                pkg.applicationInfo.nativeLibraryDir, pkg.applicationInfo.primaryCpuAbi,
                pkg.applicationInfo.secondaryCpuAbi, pkg.applicationInfo.flags,
                pkg.applicationInfo.privateFlags, pkg.getChildPackageNames(),
                UserManagerService.getInstance(), usesStaticLibraries,
                pkg.usesStaticLibrariesVersions);
    }
    // SIDE EFFECTS; persists system state to files on disk; move elsewhere
    // 写入信息到/data/system/users/下的文件
    mSettings.writeUserRestrictionsLPw(pkgSetting, oldPkgSetting);
    //更新PackageSetting信息｝｝
    
    // SIDE EFFECTS; modifies system state; move elsewhere
    if (pkgSetting.origPackage != null) {
        pkg.setPackageName(origPackage.name);
        // File a report about this.
        String msg = "New package " + pkgSetting.realName
                + " renamed to replace old package " + pkgSetting.name;
        reportSettingsProblem(Log.WARN, msg);
        // Make a note of it.
        if ((scanFlags & SCAN_CHECK_ONLY) == 0) {
            mTransferedPackages.add(origPackage.name);
        }
        // No longer need to retain this.
        pkgSetting.origPackage = null;
    }

    // SIDE EFFECTS; modifies system state; move elsewhere
    if ((scanFlags & SCAN_CHECK_ONLY) == 0 && realName != null) {
        // Make a note of it.
        mTransferedPackages.add(pkg.packageName);
    }

    if (mSettings.isDisabledSystemPackageLPr(pkg.packageName)) {
        pkg.applicationInfo.flags |= ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
    }

    if ((scanFlags & SCAN_BOOTING) == 0
            && (policyFlags & PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
        // Check all shared libraries and map to their actual file path.
        // We only do this here for apps not on a system dir, because those
        // are the only ones that can fail an install due to this.  We
        // will take care of the system apps by updating all of their
        // library paths after the scan is done. Also during the initial
        // scan don't update any libs as we do this wholesale after all
        // apps are scanned to avoid dependency based scanning.
        updateSharedLibrariesLPr(pkg, null);
    }

    if (mFoundPolicyFile) {
        SELinuxMMAC.assignSeInfoValue(pkg);
    }
    pkg.applicationInfo.uid = pkgSetting.appId;
    pkg.mExtras = pkgSetting;

　　　　　　 //获取签名信息（代码细节未了解）ＢＥＧＩＮ
    // Static shared libs have same package with different versions where
    // we internally use a synthetic package name to allow multiple versions
    // of the same package, therefore we need to compare signatures against
    // the package setting for the latest library version.
    PackageSetting signatureCheckPs = pkgSetting;
    if (pkg.applicationInfo.isStaticSharedLibrary()) {
        SharedLibraryEntry libraryEntry = getLatestSharedLibraVersionLPr(pkg);
        if (libraryEntry != null) {
            signatureCheckPs = mSettings.getPackageLPr(libraryEntry.apk);
        }
    }

    if (shouldCheckUpgradeKeySetLP(signatureCheckPs, scanFlags)) {
        if (checkUpgradeKeySetLP(signatureCheckPs, pkg)) {
            // We just determined the app is signed correctly, so bring
            // over the latest parsed certs.
            pkgSetting.signatures.mSignatures = pkg.mSignatures;
        } else {
            if ((policyFlags & PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
                throw new PackageManagerException(INSTALL_FAILED_UPDATE_INCOMPATIBLE,
                        "Package " + pkg.packageName + " upgrade keys do not match the "
                        + "previously installed version");
            } else {
                pkgSetting.signatures.mSignatures = pkg.mSignatures;
                String msg = "System package " + pkg.packageName
                        + " signature changed; retaining data.";
                reportSettingsProblem(Log.WARN, msg);
            }
        }
    } else {
        try {
            // SIDE EFFECTS; compareSignaturesCompat() changes KeysetManagerService
            verifySignaturesLP(signatureCheckPs, pkg);
            // We just determined the app is signed correctly, so bring
            // over the latest parsed certs.
            pkgSetting.signatures.mSignatures = pkg.mSignatures;
        } catch (PackageManagerException e) {
            if ((policyFlags & PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
                throw e;
            }
            // The signature has changed, but this package is in the system
            // image...  let's recover!
            pkgSetting.signatures.mSignatures = pkg.mSignatures;
            // However...  if this package is part of a shared user, but it
            // doesn't match the signature of the shared user, let's fail.
            // What this means is that you can't change the signatures
            // associated with an overall shared user, which doesn't seem all
            // that unreasonable.
            if (signatureCheckPs.sharedUser != null) {
                if (compareSignatures(signatureCheckPs.sharedUser.signatures.mSignatures,
                        pkg.mSignatures) != PackageManager.SIGNATURE_MATCH) {
                    throw new PackageManagerException(
                            INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES,
                            "Signature mismatch for shared user: "
                                    + pkgSetting.sharedUser);
                }
            }
            // File a report about this.
            String msg = "System package " + pkg.packageName
                    + " signature changed; retaining data.";
            reportSettingsProblem(Log.WARN, msg);
        }
    }
    //获取签名信息END
　　　　　　　//更新权限的所有者，更新mSettings中的权限信息
    if ((scanFlags & SCAN_CHECK_ONLY) == 0 && pkg.mAdoptPermissions != null) {
        // This package wants to adopt ownership of permissions from
        // another package.
        for (int i = pkg.mAdoptPermissions.size() - 1; i >= 0; i--) {
            final String origName = pkg.mAdoptPermissions.get(i);
            final PackageSetting orig = mSettings.getPackageLPr(origName);
            if (orig != null) {
                if (verifyPackageUpdateLPr(orig, pkg)) {
                    Slog.i(TAG, "Adopting permissions from " + origName + " to "
                            + pkg.packageName);
                    // SIDE EFFECTS; updates permissions system state; move elsewhere
                    mSettings.transferPermissionsLPw(origName, pkg.packageName);
                }
            }
        }
    }
}

总结一下加锁的代码里做了哪些事：更新uid、origin-package处理、ABI初始值、更新或者生成新的PackageSetting对象、处理签名信息、权限继承。

  1. Package中ApplicationInfo对象属性设置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
pkg.applicationInfo.processName = fixProcessName(
        pkg.applicationInfo.packageName,
        pkg.applicationInfo.processName);

if (pkg != mPlatformPackage) {
    // Get all of our default paths setup
    pkg.applicationInfo.initForUser(UserHandle.USER_SYSTEM);
}

final String cpuAbiOverride = deriveAbiOverride(pkg.cpuAbiOverride, pkgSetting);

if ((scanFlags & SCAN_NEW_INSTALL) == 0) {
    if ((scanFlags & SCAN_FIRST_BOOT_OR_UPGRADE) != 0) {
        Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "derivePackageAbi");
        final boolean extractNativeLibs = !pkg.isLibrary();
        derivePackageAbi(pkg, scanFile, cpuAbiOverride, extractNativeLibs,
                mAppLib32InstallDir);
        Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);

        // Some system apps still use directory structure for native libraries
        // in which case we might end up not detecting abi solely based on apk
        // structure. Try to detect abi based on directory structure.
        if (isSystemApp(pkg) && !pkg.isUpdatedSystemApp() &&
                pkg.applicationInfo.primaryCpuAbi == null) {
            setBundledAppAbisAndRoots(pkg, pkgSetting);
            setNativeLibraryPaths(pkg, mAppLib32InstallDir);
        }
    } else {
        // This is not a first boot or an upgrade, don't bother deriving the
        // ABI during the scan. Instead, trust the value that was stored in the
        // package setting.
        pkg.applicationInfo.primaryCpuAbi = primaryCpuAbiFromSettings;
        pkg.applicationInfo.secondaryCpuAbi = secondaryCpuAbiFromSettings;

        setNativeLibraryPaths(pkg, mAppLib32InstallDir);

        if (DEBUG_ABI_SELECTION) {
            Slog.i(TAG, "Using ABIS and native lib paths from settings : " +
                pkg.packageName + " " + pkg.applicationInfo.primaryCpuAbi + ", " +
                pkg.applicationInfo.secondaryCpuAbi);
        }
    }
} else {
    if ((scanFlags & SCAN_MOVE) != 0) {
        // We haven't run dex-opt for this move (since we've moved the compiled output too)
        // but we already have this packages package info in the PackageSetting. We just
        // use that and derive the native library path based on the new codepath.
        pkg.applicationInfo.primaryCpuAbi = pkgSetting.primaryCpuAbiString;
        pkg.applicationInfo.secondaryCpuAbi = pkgSetting.secondaryCpuAbiString;
    }

    // Set native library paths again. For moves, the path will be updated based on the
    // ABIs we've determined above. For non-moves, the path will be updated based on the
    // ABIs we determined during compilation, but the path will depend on the final
    // package path (after the rename away from the stage path).
    setNativeLibraryPaths(pkg, mAppLib32InstallDir);
}

// This is a special case for the "system" package, where the ABI is
// dictated by the zygote configuration (and init.rc). We should keep track
// of this ABI so that we can deal with "normal" applications that run under
// the same UID correctly.
if (mPlatformPackage == pkg) {
    pkg.applicationInfo.primaryCpuAbi = VMRuntime.getRuntime().is64Bit() ?
            Build.SUPPORTED_64_BIT_ABIS[0] : Build.SUPPORTED_32_BIT_ABIS[0];
}

// If there's a mismatch between the abi-override in the package setting
// and the abiOverride specified for the install. Warn about this because we
// would've already compiled the app without taking the package setting into
// account.
if ((scanFlags & SCAN_NO_DEX) == 0 && (scanFlags & SCAN_NEW_INSTALL) != 0) {
    if (cpuAbiOverride == null && pkgSetting.cpuAbiOverrideString != null) {
        Slog.w(TAG, "Ignoring persisted ABI override " + cpuAbiOverride +
                " for package " + pkg.packageName);
    }
}

pkgSetting.primaryCpuAbiString = pkg.applicationInfo.primaryCpuAbi;
pkgSetting.secondaryCpuAbiString = pkg.applicationInfo.secondaryCpuAbi;
pkgSetting.cpuAbiOverrideString = cpuAbiOverride;

// Copy the derived override back to the parsed package, so that we can
// update the package settings accordingly.
pkg.cpuAbiOverride = cpuAbiOverride;

if (DEBUG_ABI_SELECTION) {
    Slog.d(TAG, "Resolved nativeLibraryRoot for " + pkg.applicationInfo.packageName
            + " to root=" + pkg.applicationInfo.nativeLibraryRootDir + ", isa="
            + pkg.applicationInfo.nativeLibraryRootRequiresIsa);
}

// Push the derived path down into PackageSettings so we know what to
// clean up at uninstall time.
pkgSetting.legacyNativeLibraryPathString = pkg.applicationInfo.nativeLibraryRootDir;

if (DEBUG_ABI_SELECTION) {
    Log.d(TAG, "Abis for package[" + pkg.packageName + "] are" +
            " primary=" + pkg.applicationInfo.primaryCpuAbi +
            " secondary=" + pkg.applicationInfo.secondaryCpuAbi);
}

// SIDE EFFECTS; removes DEX files from disk; move elsewhere
if ((scanFlags & SCAN_BOOTING) == 0 && pkgSetting.sharedUser != null) {
    // We don't do this here during boot because we can do it all
    // at once after scanning all existing packages.
    //
    // We also do this *before* we perform dexopt on this package, so that
    // we can avoid redundant dexopts, and also to make sure we've got the
    // code and package path correct.
    adjustCpuAbisForSharedUserLPw(pkgSetting.sharedUser.packages, pkg);
}

if (mFactoryTest && pkg.requestedPermissions.contains(
        android.Manifest.permission.FACTORY_TEST)) {
    pkg.applicationInfo.flags |= ApplicationInfo.FLAG_FACTORY_TEST;
}

if (isSystemApp(pkg)) {
    pkgSetting.isOrphaned = true;
}

首先是设置ApplicationInfo中的进程名，然后调用ApplicationInfo#initForUser初始化System用户(0)下的应用相关路径：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/** {@hide} */
public void initForUser(int userId) {
    uid = UserHandle.getUid(userId, UserHandle.getAppId(uid));

    if ("android".equals(packageName)) {//路径：/data/system/
        dataDir = Environment.getDataSystemDirectory().getAbsolutePath();
        return;
    }

    deviceProtectedDataDir = Environment
            .getDataUserDePackageDirectory(volumeUuid, userId, packageName)
            .getAbsolutePath();// 路径：/data/user_de/0(或其他用户id，比如1000)/packageName
    credentialProtectedDataDir = Environment
            .getDataUserCePackageDirectory(volumeUuid, userId, packageName)
            .getAbsolutePath();//路径：/data/user/0(或其他用户id，比如1000)/packageName

    if ((privateFlags & PRIVATE_FLAG_DEFAULT_TO_DEVICE_PROTECTED_STORAGE) != 0
            && PackageManager.APPLY_DEFAULT_TO_DEVICE_PROTECTED_STORAGE) {
        dataDir = deviceProtectedDataDir;
    } else {
        dataDir = credentialProtectedDataDir;
    }
}

然后主要就是确定cpuAbi的过程，该过程在ABI确定过程中有详细介绍，这里就不再多说了。

  1. 设置时间戳
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Take care of first install / last update times.
final long scanFileTime = getLastModifiedTime(pkg, scanFile);
if (currentTime != 0) {
    if (pkgSetting.firstInstallTime == 0) {
        pkgSetting.firstInstallTime = pkgSetting.lastUpdateTime = currentTime;
    } else if ((scanFlags & SCAN_UPDATE_TIME) != 0) {
        pkgSetting.lastUpdateTime = currentTime;
    }
} else if (pkgSetting.firstInstallTime == 0) {
    // We need *something*.  Take time time stamp of the file.
    pkgSetting.firstInstallTime = pkgSetting.lastUpdateTime = scanFileTime;
} else if ((policyFlags & PackageParser.PARSE_IS_SYSTEM_DIR) != 0) {
    if (scanFileTime != pkgSetting.timeStamp) {
        // A package on the system image has changed; consider this
        // to be an update.
        pkgSetting.lastUpdateTime = scanFileTime;
    }
}
pkgSetting.setTimeStamp(scanFileTime);

设置第一次安装时间/上次更新时间，以及时间戳。

  1. 提交Package信息到Settings中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
if ((scanFlags & SCAN_CHECK_ONLY) != 0) {
    if (nonMutatedPs != null) {//仅用于检测扫描是否能成功
        synchronized (mPackages) {
            mSettings.mPackages.put(nonMutatedPs.name, nonMutatedPs);
        }
    }
} else {
    final int userId = user == null ? 0 : user.getIdentifier();
    // Modify state for the given package setting
    commitPackageSettings(pkg, pkgSetting, user, scanFlags,
            (policyFlags & PackageParser.PARSE_CHATTY) != 0 /*chatty*/);
    if (pkgSetting.getInstantApp(userId)) {//Instant app以后专门了解下
        mInstantAppRegistry.addInstantAppLPw(userId, pkgSetting.appId);
    }
}

前面提过scanFlags只有在存在child package的情况下& SCAN_CHECK_ONLY才不为0，这种情况上面跳过了，这里继续跳过……

前面说了那么多内容，其实都是在往PackageSetting里面填东西，最终还是要解析得到的信息吧保存到mSettings和mPackages里，该过程是在commitPackageSettings中进行的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
/**
  * Adds a scanned package to the system. When this method is finished, the package will
  * be available for query, resolution, etc...
  */
 private void commitPackageSettings(PackageParser.Package pkg, PackageSetting pkgSetting,
         UserHandle user, int scanFlags, boolean chatty) throws PackageManagerException {
     final String pkgName = pkg.packageName;
     //自定义的ResolverActivity，可以在xml资源中配置
     if (mCustomResolverComponentName != null &&
             mCustomResolverComponentName.getPackageName().equals(pkg.packageName)) {
         setUpCustomResolverActivity(pkg);
     }

     if (pkg.packageName.equals("android")) {
         synchronized (mPackages) {
             if ((scanFlags & SCAN_CHECK_ONLY) == 0) {
                 // Set up information for our fall-back user intent resolution activity.
                 mPlatformPackage = pkg;
                 pkg.mVersionCode = mSdkVersion;
                 mAndroidApplication = pkg.applicationInfo;
                 if (!mResolverReplaced) {
                     mResolveActivity.applicationInfo = mAndroidApplication;
                     //系统默认的ResolverActivity，用于在存在多个匹配Activity的情况下
                     //显示，让用户选择
                     mResolveActivity.name = ResolverActivity.class.getName();
                     //从这里看出来包名为android的不一定就是framework-res.apk
                     mResolveActivity.packageName = mAndroidApplication.packageName;
                     mResolveActivity.processName = "system:ui";
                     mResolveActivity.launchMode = ActivityInfo.LAUNCH_MULTIPLE;
                     mResolveActivity.documentLaunchMode = ActivityInfo.DOCUMENT_LAUNCH_NEVER;
                     mResolveActivity.flags = ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS;
                     mResolveActivity.theme = R.style.Theme_Material_Dialog_Alert;
                     mResolveActivity.exported = true;
                     mResolveActivity.enabled = true;
                     mResolveActivity.resizeMode = ActivityInfo.RESIZE_MODE_RESIZEABLE;
                     mResolveActivity.configChanges = ActivityInfo.CONFIG_SCREEN_SIZE
                             | ActivityInfo.CONFIG_SMALLEST_SCREEN_SIZE
                             | ActivityInfo.CONFIG_SCREEN_LAYOUT
                             | ActivityInfo.CONFIG_ORIENTATION
                             | ActivityInfo.CONFIG_KEYBOARD
                             | ActivityInfo.CONFIG_KEYBOARD_HIDDEN;
                     mResolveInfo.activityInfo = mResolveActivity;
                     mResolveInfo.priority = 0;
                     mResolveInfo.preferredOrder = 0;
                     mResolveInfo.match = 0;
                     mResolveComponentName = new ComponentName(
                             mAndroidApplication.packageName, mResolveActivity.name);
                 }
             }
         }
     }

     ArrayList<PackageParser.Package> clientLibPkgs = null;
     // writer
     synchronized (mPackages) {
         boolean hasStaticSharedLibs = false;

         // Any app can add new static shared libraries
         if (pkg.staticSharedLibName != null) {
             // Static shared libs don't allow renaming as they have synthetic package
             // names to allow install of multiple versions, so use name from manifest.
             if (addSharedLibraryLPw(null, pkg.packageName, pkg.staticSharedLibName,
                     pkg.staticSharedLibVersion, SharedLibraryInfo.TYPE_STATIC,
                     pkg.manifestPackageName, pkg.mVersionCode)) {
                 hasStaticSharedLibs = true;
             } else {
                 Slog.w(TAG, "Package " + pkg.packageName + " library "
                             + pkg.staticSharedLibName + " already exists; skipping");
             }
             // Static shared libs cannot be updated once installed since they
             // use synthetic package name which includes the version code, so
             // not need to update other packages's shared lib dependencies.
         }

         if (!hasStaticSharedLibs
                 && (pkg.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
             // Only system apps can add new dynamic shared libraries.
             if (pkg.libraryNames != null) {
                 for (int i = 0; i < pkg.libraryNames.size(); i++) {
                     String name = pkg.libraryNames.get(i);
                     boolean allowed = false;
                     if (pkg.isUpdatedSystemApp()) {
                         // New library entries can only be added through the
                         // system image.  This is important to get rid of a lot
                         // of nasty edge cases: for example if we allowed a non-
                         // system update of the app to add a library, then uninstalling
                         // the update would make the library go away, and assumptions
                         // we made such as through app install filtering would now
                         // have allowed apps on the device which aren't compatible
                         // with it.  Better to just have the restriction here, be
                         // conservative, and create many fewer cases that can negatively
                         // impact the user experience.
                         final PackageSetting sysPs = mSettings
                                 .getDisabledSystemPkgLPr(pkg.packageName);
                         if (sysPs.pkg != null && sysPs.pkg.libraryNames != null) {
                             for (int j = 0; j < sysPs.pkg.libraryNames.size(); j++) {
                                 if (name.equals(sysPs.pkg.libraryNames.get(j))) {
                                     allowed = true;
                                     break;
                                 }
                             }
                         }
                     } else {
                         allowed = true;
                     }
                     if (allowed) {
                         if (!addSharedLibraryLPw(null, pkg.packageName, name,
                                 SharedLibraryInfo.VERSION_UNDEFINED,
                                 SharedLibraryInfo.TYPE_DYNAMIC,
                                 pkg.packageName, pkg.mVersionCode)) {
                             Slog.w(TAG, "Package " + pkg.packageName + " library "
                                     + name + " already exists; skipping");
                         }
                     } else {
                         Slog.w(TAG, "Package " + pkg.packageName + " declares lib "
                                 + name + " that is not declared on system image; skipping");
                     }
                 }

                 if ((scanFlags & SCAN_BOOTING) == 0) {
                     // If we are not booting, we need to update any applications
                     // that are clients of our shared library.  If we are booting,
                     // this will all be done once the scan is complete.
                     clientLibPkgs = updateAllSharedLibrariesLPw(pkg);
                 }
             }
         }
     }

     if ((scanFlags & SCAN_BOOTING) != 0) {
         // No apps can run during boot scan, so they don't need to be frozen
     } else if ((scanFlags & SCAN_DONT_KILL_APP) != 0) {
         // Caller asked to not kill app, so it's probably not frozen
     } else if ((scanFlags & SCAN_IGNORE_FROZEN) != 0) {
         // Caller asked us to ignore frozen check for some reason; they
         // probably didn't know the package name
     } else {
         // We're doing major surgery on this package, so it better be frozen
         // right now to keep it from launching
         checkPackageFrozen(pkgName);
     }

     // Also need to kill any apps that are dependent on the library.
     if (clientLibPkgs != null) {
         for (int i=0; i<clientLibPkgs.size(); i++) {
             PackageParser.Package clientPkg = clientLibPkgs.get(i);
             killApplication(clientPkg.applicationInfo.packageName,
                     clientPkg.applicationInfo.uid, "update lib");
         }
     }

     // writer
     Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "updateSettings");

     synchronized (mPackages) {
         // We don't expect installation to fail beyond this point

         // Add the new setting to mSettings
         mSettings.insertPackageSettingLPw(pkgSetting, pkg);
         // Add the new setting to mPackages
         mPackages.put(pkg.applicationInfo.packageName, pkg);
         // Make sure we don't accidentally delete its data.
         final Iterator<PackageCleanItem> iter = mSettings.mPackagesToBeCleaned.iterator();
         while (iter.hasNext()) {
             PackageCleanItem item = iter.next();
             if (pkgName.equals(item.packageName)) {
                 iter.remove();
             }
         }

         // Add the package's KeySets to the global KeySetManagerService
         KeySetManagerService ksms = mSettings.mKeySetManagerService;
         ksms.addScannedPackageLPw(pkg);

         int N = pkg.providers.size();
         StringBuilder r = null;
         int i;
         for (i=0; i<N; i++) {
             PackageParser.Provider p = pkg.providers.get(i);
             p.info.processName = fixProcessName(pkg.applicationInfo.processName,
                     p.info.processName);
             mProviders.addProvider(p);
             p.syncable = p.info.isSyncable;
             if (p.info.authority != null) {
                 String names[] = p.info.authority.split(";");
                 p.info.authority = null;
                 for (int j = 0; j < names.length; j++) {
                     if (j == 1 && p.syncable) {
                         // We only want the first authority for a provider to possibly be
                         // syncable, so if we already added this provider using a different
                         // authority clear the syncable flag. We copy the provider before
                         // changing it because the mProviders object contains a reference
                         // to a provider that we don't want to change.
                         // Only do this for the second authority since the resulting provider
                         // object can be the same for all future authorities for this provider.
                         p = new PackageParser.Provider(p);
                         p.syncable = false;
                     }
                     if (!mProvidersByAuthority.containsKey(names[j])) {
                         mProvidersByAuthority.put(names[j], p);
                         if (p.info.authority == null) {
                             p.info.authority = names[j];
                         } else {
                             p.info.authority = p.info.authority + ";" + names[j];
                         }
                         if (DEBUG_PACKAGE_SCANNING) {
                             if (chatty)
                                 Log.d(TAG, "Registered content provider: " + names[j]
                                         + ", className = " + p.info.name + ", isSyncable = "
                                         + p.info.isSyncable);
                         }
                     } else {
                         PackageParser.Provider other = mProvidersByAuthority.get(names[j]);
                         Slog.w(TAG, "Skipping provider name " + names[j] +
                                 " (in package " + pkg.applicationInfo.packageName +
                                 "): name already used by "
                                 + ((other != null && other.getComponentName() != null)
                                         ? other.getComponentName().getPackageName() : "?"));
                     }
                 }
             }
             if (chatty) {
                 if (r == null) {
                     r = new StringBuilder(256);
                 } else {
                     r.append(' ');
                 }
                 r.append(p.info.name);
             }
         }
         if (r != null) {
             if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Providers: " + r);
         }

         N = pkg.services.size();
         r = null;
         for (i=0; i<N; i++) {
             PackageParser.Service s = pkg.services.get(i);
             s.info.processName = fixProcessName(pkg.applicationInfo.processName,
                     s.info.processName);
             mServices.addService(s);
             if (chatty) {
                 if (r == null) {
                     r = new StringBuilder(256);
                 } else {
                     r.append(' ');
                 }
                 r.append(s.info.name);
             }
         }
         if (r != null) {
             if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Services: " + r);
         }

         N = pkg.receivers.size();
         r = null;
         for (i=0; i<N; i++) {
             PackageParser.Activity a = pkg.receivers.get(i);
             a.info.processName = fixProcessName(pkg.applicationInfo.processName,
                     a.info.processName);
             mReceivers.addActivity(a, "receiver");
             if (chatty) {
                 if (r == null) {
                     r = new StringBuilder(256);
                 } else {
                     r.append(' ');
                 }
                 r.append(a.info.name);
             }
         }
         if (r != null) {
             if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Receivers: " + r);
         }

         N = pkg.activities.size();
         r = null;
         for (i=0; i<N; i++) {
             PackageParser.Activity a = pkg.activities.get(i);
             a.info.processName = fixProcessName(pkg.applicationInfo.processName,
                     a.info.processName);
             mActivities.addActivity(a, "activity");
             if (chatty) {
                 if (r == null) {
                     r = new StringBuilder(256);
                 } else {
                     r.append(' ');
                 }
                 r.append(a.info.name);
             }
         }
         if (r != null) {
             if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Activities: " + r);
         }

         N = pkg.permissionGroups.size();
         r = null;
         for (i=0; i<N; i++) {
             PackageParser.PermissionGroup pg = pkg.permissionGroups.get(i);
             PackageParser.PermissionGroup cur = mPermissionGroups.get(pg.info.name);
             final String curPackageName = cur == null ? null : cur.info.packageName;
             // Dont allow ephemeral apps to define new permission groups.
             if ((scanFlags & SCAN_AS_INSTANT_APP) != 0) {
                 Slog.w(TAG, "Permission group " + pg.info.name + " from package "
                         + pg.info.packageName
                         + " ignored: instant apps cannot define new permission groups.");
                 continue;
             }
             final boolean isPackageUpdate = pg.info.packageName.equals(curPackageName);
             if (cur == null || isPackageUpdate) {
                 mPermissionGroups.put(pg.info.name, pg);
                 if (chatty) {
                     if (r == null) {
                         r = new StringBuilder(256);
                     } else {
                         r.append(' ');
                     }
                     if (isPackageUpdate) {
                         r.append("UPD:");
                     }
                     r.append(pg.info.name);
                 }
             } else {
                 Slog.w(TAG, "Permission group " + pg.info.name + " from package "
                         + pg.info.packageName + " ignored: original from "
                         + cur.info.packageName);
                 if (chatty) {
                     if (r == null) {
                         r = new StringBuilder(256);
                     } else {
                         r.append(' ');
                     }
                     r.append("DUP:");
                     r.append(pg.info.name);
                 }
             }
         }
         if (r != null) {
             if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Permission Groups: " + r);
         }

         N = pkg.permissions.size();
         r = null;
         for (i=0; i<N; i++) {
             PackageParser.Permission p = pkg.permissions.get(i);

             // Dont allow ephemeral apps to define new permissions.
             if ((scanFlags & SCAN_AS_INSTANT_APP) != 0) {
                 Slog.w(TAG, "Permission " + p.info.name + " from package "
                         + p.info.packageName
                         + " ignored: instant apps cannot define new permissions.");
                 continue;
             }

             // Assume by default that we did not install this permission into the system.
             p.info.flags &= ~PermissionInfo.FLAG_INSTALLED;

             // Now that permission groups have a special meaning, we ignore permission
             // groups for legacy apps to prevent unexpected behavior. In particular,
             // permissions for one app being granted to someone just because they happen
             // to be in a group defined by another app (before this had no implications).
             if (pkg.applicationInfo.targetSdkVersion > Build.VERSION_CODES.LOLLIPOP_MR1) {
                 p.group = mPermissionGroups.get(p.info.group);
                 // Warn for a permission in an unknown group.
                 if (DEBUG_PERMISSIONS && p.info.group != null && p.group == null) {
                     Slog.i(TAG, "Permission " + p.info.name + " from package "
                             + p.info.packageName + " in an unknown group " + p.info.group);
                 }
             }

             ArrayMap<String, BasePermission> permissionMap =
                     p.tree ? mSettings.mPermissionTrees
                             : mSettings.mPermissions;
             BasePermission bp = permissionMap.get(p.info.name);

             // Allow system apps to redefine non-system permissions
             if (bp != null && !Objects.equals(bp.sourcePackage, p.info.packageName)) {
                 final boolean currentOwnerIsSystem = (bp.perm != null
                         && isSystemApp(bp.perm.owner));
                 if (isSystemApp(p.owner)) {
                     if (bp.type == BasePermission.TYPE_BUILTIN && bp.perm == null) {
                         // It's a built-in permission and no owner, take ownership now
                         bp.packageSetting = pkgSetting;
                         bp.perm = p;
                         bp.uid = pkg.applicationInfo.uid;
                         bp.sourcePackage = p.info.packageName;
                         p.info.flags |= PermissionInfo.FLAG_INSTALLED;
                     } else if (!currentOwnerIsSystem) {
                         String msg = "New decl " + p.owner + " of permission  "
                                 + p.info.name + " is system; overriding " + bp.sourcePackage;
                         reportSettingsProblem(Log.WARN, msg);
                         bp = null;
                     }
                 }
             }

             if (bp == null) {
                 bp = new BasePermission(p.info.name, p.info.packageName,
                         BasePermission.TYPE_NORMAL);
                 permissionMap.put(p.info.name, bp);
             }

             if (bp.perm == null) {
                 if (bp.sourcePackage == null
                         || bp.sourcePackage.equals(p.info.packageName)) {
                     BasePermission tree = findPermissionTreeLP(p.info.name);
                     if (tree == null
                             || tree.sourcePackage.equals(p.info.packageName)) {
                         bp.packageSetting = pkgSetting;
                         bp.perm = p;
                         bp.uid = pkg.applicationInfo.uid;
                         bp.sourcePackage = p.info.packageName;
                         p.info.flags |= PermissionInfo.FLAG_INSTALLED;
                         if (chatty) {
                             if (r == null) {
                                 r = new StringBuilder(256);
                             } else {
                                 r.append(' ');
                             }
                             r.append(p.info.name);
                         }
                     } else {
                         Slog.w(TAG, "Permission " + p.info.name + " from package "
                                 + p.info.packageName + " ignored: base tree "
                                 + tree.name + " is from package "
                                 + tree.sourcePackage);
                     }
                 } else {
                     Slog.w(TAG, "Permission " + p.info.name + " from package "
                             + p.info.packageName + " ignored: original from "
                             + bp.sourcePackage);
                 }
             } else if (chatty) {
                 if (r == null) {
                     r = new StringBuilder(256);
                 } else {
                     r.append(' ');
                 }
                 r.append("DUP:");
                 r.append(p.info.name);
             }
             if (bp.perm == p) {
                 bp.protectionLevel = p.info.protectionLevel;
             }
         }

         if (r != null) {
             if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Permissions: " + r);
         }

         N = pkg.instrumentation.size();
         r = null;
         for (i=0; i<N; i++) {
             PackageParser.Instrumentation a = pkg.instrumentation.get(i);
             a.info.packageName = pkg.applicationInfo.packageName;
             a.info.sourceDir = pkg.applicationInfo.sourceDir;
             a.info.publicSourceDir = pkg.applicationInfo.publicSourceDir;
             a.info.splitNames = pkg.splitNames;
             a.info.splitSourceDirs = pkg.applicationInfo.splitSourceDirs;
             a.info.splitPublicSourceDirs = pkg.applicationInfo.splitPublicSourceDirs;
             a.info.splitDependencies = pkg.applicationInfo.splitDependencies;
             a.info.dataDir = pkg.applicationInfo.dataDir;
             a.info.deviceProtectedDataDir = pkg.applicationInfo.deviceProtectedDataDir;
             a.info.credentialProtectedDataDir = pkg.applicationInfo.credentialProtectedDataDir;
             a.info.nativeLibraryDir = pkg.applicationInfo.nativeLibraryDir;
             a.info.secondaryNativeLibraryDir = pkg.applicationInfo.secondaryNativeLibraryDir;
             mInstrumentation.put(a.getComponentName(), a);
             if (chatty) {
                 if (r == null) {
                     r = new StringBuilder(256);
                 } else {
                     r.append(' ');
                 }
                 r.append(a.info.name);
             }
         }
         if (r != null) {
             if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Instrumentation: " + r);
         }

         if (pkg.protectedBroadcasts != null) {
             N = pkg.protectedBroadcasts.size();
             synchronized (mProtectedBroadcasts) {
                 for (i = 0; i < N; i++) {
                     mProtectedBroadcasts.add(pkg.protectedBroadcasts.get(i));
                 }
             }
         }
     }

     Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
 }

方法又很长，但是做的事大致就这么几件：

  • 设置PKMS中mPlatformPackage 、mAndroidApplication、mResolveActivity、mResolveInfo及mResolveComponentName等成员的值；

  • 填充mSharedLibraries和mStaticLibsByDeclaringPackage这两个ArrayMap；

  • Add the new setting to mSettings：mSettings.insertPackageSettingLPw(pkgSetting, pkg);

  • Add the new setting to mPackages： mPackages.put(pkg.applicationInfo.packageName, pkg);

  • 往下面四个解析器中添加解析后的组件：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    // All available activities, for your resolving pleasure.
    final ActivityIntentResolver mActivities =
            new ActivityIntentResolver();

    // All available receivers, for your resolving pleasure.
    final ActivityIntentResolver mReceivers =
            new ActivityIntentResolver();

    // All available services, for your resolving pleasure.
    final ServiceIntentResolver mServices = new ServiceIntentResolver();

    // All available providers, for your resolving pleasure.
    final ProviderIntentResolver mProviders = new ProviderIntentResolver();

从名字上就可以看出来四大组件的解析肯定和这四个Resolver有关。组件解析过程之后再做了解。

  • 更新权限信息；

  • 更新mInstrumentation，Instrumentation印象中是用来调试的，暂不了解；

  • 填充mProtectedBroadcasts：

    1
    2
    3
    // Broadcast actions that are only available to the system.
    @GuardedBy("mProtectedBroadcasts")
    final ArraySet<String> mProtectedBroadcasts = new ArraySet<>();

进过上面一系列的扫描过程一个apk就解析完了，不断重复该过程直到一个目录下的apk全部解析完成。六个目录下的apk解析过程类似，将所有的apk解析完之后mSetting和mPackage等信息也就构建完成了，之后就可以通过PKMS进行组件的查询和解析了。

  1. 生成data

    首先是通过reconcileAppsDataLI生成coreApp的data（在/data/user/0下面），该方法返回跳过的非coreApp列表：

    1
    2
    3
    List<String> deferPackages = reconcileAppsDataLI(StorageManager.UUID_PRIVATE_INTERNAL,
                        UserHandle.USER_SYSTEM, storageFlags, true /* migrateAppData */,
                        true /* onlyCoreApps */);

而reconcileAppsDataLI内部又调用了prepareAppDataAndMigrateLIF来准备应用的数据。

之后再通过prepareAppDataAndMigrateLIF方法逐个生成deferPackages中package的数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
mPrepareAppDataFuture = SystemServerInitThreadPool.get().submit(() -> {
                TimingsTraceLog traceLog = new TimingsTraceLog("SystemServerTimingAsync",
                        Trace.TRACE_TAG_PACKAGE_MANAGER);
                traceLog.traceBegin("AppDataFixup");
                try {
                    mInstaller.fixupAppData(StorageManager.UUID_PRIVATE_INTERNAL,
                            StorageManager.FLAG_STORAGE_DE | StorageManager.FLAG_STORAGE_CE);
                } catch (InstallerException e) {
                    Slog.w(TAG, "Trouble fixing GIDs", e);
                }
                traceLog.traceEnd();

                traceLog.traceBegin("AppDataPrepare");
                if (deferPackages == null || deferPackages.isEmpty()) {
                    return;
                }
                int count = 0;
                for (String pkgName : deferPackages) {
                    PackageParser.Package pkg = null;
                    synchronized (mPackages) {
                        PackageSetting ps = mSettings.getPackageLPr(pkgName);
                        if (ps != null && ps.getInstalled(UserHandle.USER_SYSTEM)) {
                            pkg = ps.pkg;
                        }
                    }
                    if (pkg != null) {
                        synchronized (mInstallLock) {
                            prepareAppDataAndMigrateLIF(pkg, UserHandle.USER_SYSTEM, storageFlags,
                                    true /* maybeMigrateAppData */);
                        }
                        count++;
                    }
                }
                traceLog.traceEnd();
                Slog.i(TAG, "Deferred reconcileAppsData finished " + count + " packages");
            }, "prepareAppData");

以上代码将一个Runnable和对该Runnable对象的描述作为参数传递给了SystemServerInitThreadPool，然后在线程池中执行Runnable，通过prepareAppDataAndMigrateLIF方法准备data,并最终返回一个Future对象。

也就是说，coreApp和非coreApp最终都是通过prepareAppDataAndMigrateLIF来为app准备数据的。

1
2
3
4
5
6
7
8
9
10
private void prepareAppDataAndMigrateLIF(PackageParser.Package pkg, int userId, int flags,
        boolean maybeMigrateAppData) {
    prepareAppDataLIF(pkg, userId, flags);

    if (maybeMigrateAppData && maybeMigrateAppDataLIF(pkg, userId)) {
        // We may have just shuffled around app data directories, so
        // prepare them one more time
        prepareAppDataLIF(pkg, userId, flags);
    }
}

上面的方法会通过Installer对象的createAppData方法来进行数据的准备工作，之后会到native层（frameworks/native/cmds/installd/InstalldNativeService.cpp），该过程就不了解了。

再回过头来看一下上面提到的SystemServerInitThreadPool，源码中的注释如下：

1
2
3
4
5
6
7
8
/**
 * Thread pool used during initialization of system server.
 * <p>System services can {@link #submit(Runnable)} tasks for execution during boot.
 * The pool will be shut down after {@link SystemService#PHASE_BOOT_COMPLETED}.
 * New tasks <em>should not</em> be submitted afterwards.
 *
 * @hide
 */

该类是在System server创建过程中用到的线程池，在启动过程中系统服务可以通过submit方法向线程池中提交任务，SystemService#PHASE_BOOT_COMPLETED之后线程池会关闭。来看下该类的关键代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

private static SystemServerInitThreadPool sInstance;

private ExecutorService mService = ConcurrentUtils.newFixedThreadPool(4,
        "system-server-init-thread", Process.THREAD_PRIORITY_FOREGROUND);

public static synchronized SystemServerInitThreadPool get() {
    if (sInstance == null) {
        sInstance = new SystemServerInitThreadPool();
    }
    Preconditions.checkState(sInstance.mService != null, "Cannot get " + TAG
            + " - it has been shut down");
    return sInstance;
}

public Future<?> submit(Runnable runnable, String description) {
    if (IS_DEBUGGABLE) {
        return mService.submit(() -> {
            Slog.d(TAG, "Started executing " + description);
            try {
                runnable.run();
            } catch (RuntimeException e) {
                Slog.e(TAG, "Failure in " + description + ": " + e, e);
                throw e;
            }
            Slog.d(TAG, "Finished executing "  + description);
        });
    }
    return mService.submit(runnable);
}

该类采用了单例单例模式，内部维护了一个FixedThreadPool引用mServices,提交的任务实际上是提交给mServices。mPrepareAppDataFuture = SystemServerInitThreadPool.get().submit返回的对象仅在一处用到了：

1
2
3
4
5
6
7
8
//PKMS
public void waitForAppDataPrepared() {
    if (mPrepareAppDataFuture == null) {
        return;
    }
    ConcurrentUtils.waitForFutureNoInterrupt(mPrepareAppDataFuture, "wait for prepareAppData");
    mPrepareAppDataFuture = null;
}

而该方法会在System server的startOtherService中传递给AMS的runnable中调用，用来等待数据准备完成。

总结：首次开机过程中应用的安装设计的代码很多，但是做的事情并不多，主要就是通过解析apk更新PKMS的成员变量的内容，例如mSettings、mPackages以及权限相关成员、lib库相关成员，以及更重要的四大组件的解析器信息，并准备apk的数据。

Powered by Hexo and Hexo-theme-hiker

Copyright © 2018 - 2022 得一 All Rights Reserved.

访客数 : | 访问量 :