1 引言
在文章Android Xapk装置(一)中,讨论了xapk包的组成以及装置办法，并剖析了运用adb install-multiple办法装置xapk的进程，在该文章中，咱们知道，adb install-multiple指令装置xapk,实践上是在Android体系中运行execc:cmd package install-create,exec:cmd package install-write,exec:cmd package install-commit三个指令，而这三个指令终究会进入到PackageManagerService的onShellCommand办法去履行。本文接着前文，剖析在PackageManagerService中的履行进程，本文的源码基于Android 10.
2 PackageManagerService中履行进程
2.1 onShellCommand
依据前文剖析，exec:cmd package指令终究会进入到PackageManagerService(源码位置:/frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java)的onShellCommand办法中，其源码如下:
@Override
public void onShellCommand(FileDescriptor in, FileDescriptor out,
FileDescriptor err, String[] args, ShellCallback callback,
ResultReceiver resultReceiver) {
(new PackageManagerShellCommand(this)).exec(
this, in, out, err, args, callback, resultReceiver);
}
onShellCommand办法中，会创立一个PackageManagerShellCommand方针，然后调用其exec办法.PackageManagerShellCommand源码坐落于/frameworks/base/services/core/java/com/android/server/pm/目录,PackageManagerShellCommand承继自ShellCommand(源码坐落/frameworks/base/core/java/android/os/ShellCommand.java),exec办法完结在ShellCommand类中，在该办法中，实践调用的是onCommand办法，而该办法是由各个子类去完结，所以实践上终究代码会进入大PackageManagerShellCommand的onCommand办法中,该办法用来解析和PackageManagerService有关的相关指令，如pm dump,pm list这些指令终究也会进入到该办法。和本次装置xapk有关的处理代码如下
public int onCommand(String cmd) {
if (cmd == null) {
return handleDefaultCommands(cmd);
}
final PrintWriter pw = getOutPrintWriter();
try {
switch(cmd) {
...
case "install-abandon":
case "install-destroy":
return runInstallAbandon();
case "install-commit":
return runInstallCommit();
case "install-create":
return runInstallCreate();
case "install-write":
return runInstallWrite();
...
}
} catch (RemoteException e) {
pw.println("Remote exception: " + e);
}
return -1;
}
从代码中能够看到，install-create,install-write,install-commit这三个指令别离由runInstallCreate,runInstallWrite,runInstallCommit三个办法履行，下面别离来看这三个办法
2.2 runInstallCreate
runInstallCreate办法源码如下
private int runInstallCreate() throws RemoteException {
final PrintWriter pw = getOutPrintWriter();
final InstallParams installParams = makeInstallParams();
final int sessionId = doCreateSession(installParams.sessionParams,
installParams.installerPackageName, installParams.userId);
// NOTE: adb depends on parsing this string
pw.println("Success: created install session [" + sessionId + "]");
return 0;
}
在该办法中，先是结构了一个InstallParams方针，然后运用该方针做为参数，调用doCreateSession办法生成session并回来sessionId. InstallParams是PackageManagerShellCommand的一个内部类
private static class InstallParams {
SessionParams sessionParams;
String installerPackageName;
int userId = UserHandle.USER_ALL;
}
从该类界说能够看到，InstallParams有三个成员变量:sessionParams:与session有关的参数,installerPackageName:调用装置程序或指令的运用，userId:本次装置的运用，对哪些用户可见,默许是一切用户.
了解了InstallParam的结构后，下面看结构InstallParam方针的makeInstallParams办法。在该办法中，首要创立了一个SessionParams方针，并将装置模式设为SessionParams.MODE_FULL_INSTALL,创立该方针后，创立一个InstallParams方针，并将SessionParams方针赋予其成员变量sessionParams.在完结这两步作业后，InstallParams方针就创立完结了。
private InstallParams makeInstallParams() {
final SessionParams sessionParams = new SessionParams(SessionParams.MODE_FULL_INSTALL);
final InstallParams params = new InstallParams();
params.sessionParams = sessionParams;
// Whitelist all permissions by default
//PackageManager.INSTALL_ALL_WHITELIST_RESTRICTED_PERMISSIONS 是一个用于 Android 的 //PackageManager 类的常量。该常量指示装置包管理器在装置运用程序时，是否将该运用程序添加到一切白名单受限权限的白名单中,默许是添加
sessionParams.installFlags |= PackageManager.INSTALL_ALL_WHITELIST_RESTRICTED_PERMISSIONS;
办法剩下的部分便是为SessionParams方针赋值，首要为本次装置的运用赋予白名单权限，然后解析传递过来的参数，履行相应的战略，回忆前文， install-create指令:
exec:cmd package install-create -S size au.com.metrotrains.dwtd4.apk config.arm64_v8a.apk
在该指令中，有一个-S选项参数，在本办法中，和-S参数有关的代码如下
...
switch (opt) {
....
case "-S":
final long sizeBytes = Long.parseLong(getNextArg());
if (sizeBytes <= 0) {
throw new IllegalArgumentException("Size must be positive");
}
sessionParams.setSize(sizeBytes);
break;
...
从代码中能够看到，关于选项-S,便是把本次装置的包总巨细写入到SessionParam的size特点中。至此,InstallParams方针就结构完结了，注意到，在该方针的三个特点中,installerPackageName特点为空。在完结InstallParams方针结构的剖析后，下面剖析doCreateSession办法，该办法是用来实践生成Session并回来sessionId:
private int doCreateSession(SessionParams params, String installerPackageName, int userId)
throws RemoteException {
userId = translateUserId(userId, true /*allowAll*/, "runInstallCreate");
if (userId == UserHandle.USER_ALL) {
userId = UserHandle.USER_SYSTEM;
params.installFlags |= PackageManager.INSTALL_ALL_USERS;
}
final int sessionId = mInterface.getPackageInstaller()
.createSession(params, installerPackageName, userId);
return sessionId;
}
在该办法中，首要对userId做了一些查看，首要也仍是权限方面，之后调用PackageInstallerService的createSession办法创立session,并回来sessionId。
2.2.1 PackageInstallerService#createSession
PackageInstallerService 源码坐落frameworks/services/core/java/com/android/server/pm/PackageInstallerService,createSession源码如下:
@Override
public int createSession(SessionParams params, String installerPackageName, int userId) {
try {
return createSessionInternal(params, installerPackageName, userId);
} catch (IOException e) {
throw ExceptionUtils.wrap(e);
}
}
在createSession中，实践调用的是createSessionInternal办法完结详细的生成session作业,createSessionInsternal办法中和生成session有关的代码如下
...
final int sessionId;
final PackageInstallerSession session;
synchronized (mSessions) {
// Sanity check that installer isn't going crazy
final int activeCount = getSessionCount(mSessions, callingUid);
if (activeCount >= MAX_ACTIVE_SESSIONS) {
throw new IllegalStateException(
"Too many active sessions for UID " + callingUid);
}
final int historicalCount = mHistoricalSessionsByInstaller.get(callingUid);
if (historicalCount >= MAX_HISTORICAL_SESSIONS) {
throw new IllegalStateException(
"Too many historical sessions for UID " + callingUid);
}
sessionId = allocateSessionIdLocked();
}
final long createdMillis = System.currentTimeMillis();
// We're staging to exactly one location
File stageDir = null;
String stageCid = null;
if (!params.isMultiPackage) {
if ((params.installFlags & PackageManager.INSTALL_INTERNAL) != 0) {
stageDir = buildSessionDir(sessionId, params);
} else {
stageCid = buildExternalStageCid(sessionId);
}
}
session = new PackageInstallerSession(mInternalCallback, mContext, mPm, this,
mInstallThread.getLooper(), mStagingManager, sessionId, userId,
installerPackageName, callingUid, params, createdMillis, stageDir, stageCid, false,
false, false, null, SessionInfo.INVALID_ID, false, false, false,
SessionInfo.STAGED_SESSION_NO_ERROR, "");
synchronized (mSessions) {
mSessions.put(sessionId, session);
}
if (params.isStaged) {
mStagingManager.createSession(session);
}
if ((session.params.installFlags & PackageManager.INSTALL_DRY_RUN) == 0) {
mCallbacks.notifySessionCreated(session.sessionId, session.userId);
}
writeSessionsAsync();
return sessionId;
}
在生成Session时，首要会查看当前体系中活跃的sessionId个数,有多少个sessionId就意味着现在体系有多个在装置的运用，所以需求操控sessionId个数，防止过多的运用一起装置拖垮体系；然后调用allocateSessionIdLocked办法生成一个随机的sessionId,在生成sessionId后，调用buildSessionDir和buindExternalStageCid办法别离生成stageDir和stagCid,其间stageDir是用来临时寄存apk文件的目录,其目录相似/data/app/vmdl{sessionId}.tmp;在生成stageDir和stageCid后，创立一个PackageInstallerSession方针作为本次装置的Session并将其和SessionId放在map表mSessions中，这样就将sessionId和Session关联起来了，PackageInstallerSession的源码坐落frameworks/services/core/java/com/android/server/pm/PackageInstallerSession,在结构办法中将这些参数保存到其成员变量中;在createSessionInternal办法的终究，调用writeSessionsAsync办法将session数据耐久化保存到目录/data/system/install_session.xml中，该文件保存着体系一切没有完结装置的session.若体系重启，PackageManagerService发动时会从该文件中读取session数据，持续完结装置
。
至此，install-create就完结了session的创立，并回来其对应的sessionId,下面看install-write的履行办法runInstallWrite
2.3 runInstallWrite
在履行完install-create指令创立好session后，接下来便是履行install-write办法写入apk文件，
回忆前文写入指令
exec:cmd package install-write -S apkSize sessionId au.com.metrotrains.dwtd4.apk -
install-write指令对应的履行办法便是runInstallWrite办法:
private int runInstallWrite() throws RemoteException {
long sizeBytes = -1;
String opt;
while ((opt = getNextOption()) != null) {
if (opt.equals("-S")) {
sizeBytes = Long.parseLong(getNextArg());
} else {
throw new IllegalArgumentException("Unknown option: " + opt);
}
}
final int sessionId = Integer.parseInt(getNextArg());
final String splitName = getNextArg();
final String path = getNextArg();
return doWriteSplit(sessionId, path, sizeBytes, splitName, true /*logSuccess*/);
}
在该办法中，首要获取install-write指令带着的-S选项，该选项带着了本次写入apk文件的巨细，而且该参数是有必要的，获取到该参数后，再依次获取本次操作的sessionId和apk文件的途径，获取到这些参数后，调用doWriteSplit办法完结写入：
private int doWriteSplit(int sessionId, String inPath, long sizeBytes, String splitName,
boolean logSuccess) throws RemoteException {
PackageInstaller.Session session = null;
try {
final PrintWriter pw = getOutPrintWriter();
//1. 依据输入途径，翻开对应的文件，其间STDIN_PATH为'-''
final ParcelFileDescriptor fd;
if (STDIN_PATH.equals(inPath)) {
fd = ParcelFileDescriptor.dup(getInFileDescriptor());
} else if (inPath != null) {
fd = openFileForSystem(inPath, "r");
if (fd == null) {
return -1;
}
sizeBytes = fd.getStatSize();
if (sizeBytes < 0) {
getErrPrintWriter().println("Unable to get size of: " + inPath);
return -1;
}
} else {
fd = ParcelFileDescriptor.dup(getInFileDescriptor());
}
//2. 查看本次写入的文件的巨细
if (sizeBytes <= 0) {
getErrPrintWriter().println("Error: must specify a APK size");
return 1;
}
//3. 依据seesionId翻开对应的PackageInstallerSession ，并调用其write办法
session = new PackageInstaller.Session(
mInterface.getPackageInstaller().openSession(sessionId));
session.write(splitName, 0, sizeBytes, fd);
if (logSuccess) {
pw.println("Success: streamed " + sizeBytes + " bytes");
}
return 0;
} catch (IOException e) {
getErrPrintWriter().println("Error: failed to write; " + e.getMessage());
return 1;
} finally {
IoUtils.closeQuietly(session);
}
}
能够看到，该办法首要分为3步：
- 依据指令传入的
apk文件写入途径，翻开对应的文件，在上文中的指令中，传入的写入文件途径为-,其对应的便是STDIN_PATH,即写入规范写入中， - 查看本次写入的
apk文件巨细，写入的巨细应该大于0 - 依据传入的
seesionId,翻开对应的Session,并调用其write办法完结写入Session在体系中对应的是PackageInstallerSession方针，所以实践上便是调用PackageInstallerSession的write办法。下面进入到PackageInstallerSession中,剖析其write办法
2.3.1 PackageInstallerSession#write
write办法源码如下
@Override
public void write(String name, long offsetBytes, long lengthBytes,
ParcelFileDescriptor fd) {
try {
doWriteInternal(name, offsetBytes, lengthBytes, fd);
} catch (IOException e) {
throw ExceptionUtils.wrap(e);
}
}
在write办法中，实践上是调用doWriteInternal办法完结实践的写入操作:
private ParcelFileDescriptor doWriteInternal(String name, long offsetBytes, long lengthBytes,
ParcelFileDescriptor incomingFd) throws IOException {
// Quick sanity check of state, and allocate a pipe for ourselves. We
// then do heavy disk allocation outside the lock, but this open pipe
// will block any attempted install transitions.
final RevocableFileDescriptor fd;
final FileBridge bridge;
final File stageDir;
synchronized (mLock) {
assertCallerIsOwnerOrRootLocked();
assertPreparedAndNotSealedLocked("openWrite");
//1.获取写入装置包的stageDir,该值在创立session时创立,其途径相似/data/app/vmdl{sessionId}.tmp
if (PackageInstaller.ENABLE_REVOCABLE_FD) {
fd = new RevocableFileDescriptor();
bridge = null;
mFds.add(fd);
} else {
fd = null;
bridge = new FileBridge();
mBridges.add(bridge);
}
stageDir = resolveStageDirLocked();
}
try {
// Use installer provided name for now; we always rename later
if (!FileUtils.isValidExtFilename(name)) {
throw new IllegalArgumentException("Invalid name: " + name);
}
//2. 创立要写入的方针文件，一般便是stageDir/apkName.apk
final File target;
final long identity = Binder.clearCallingIdentity();
try {
target = new File(stageDir, name);
Slog.i("InstallTrace","PackageInstallerSeiion#dowriteInternal write apk in session: targetPath="+target.getAbsolutePath());
} finally {
Binder.restoreCallingIdentity(identity);
}
// TODO: this should delegate to DCS so the system process avoids
// holding open FDs into containers.
final FileDescriptor targetFd = Os.open(target.getAbsolutePath(),
O_CREAT | O_WRONLY, 0644);
Os.chmod(target.getAbsolutePath(), 0644);
// If caller specified a total length, allocate it for them. Free up
// cache space to grow, if needed.
if (stageDir != null && lengthBytes > 0) {
mContext.getSystemService(StorageManager.class).allocateBytes(targetFd, lengthBytes,
PackageHelper.translateAllocateFlags(params.installFlags));
}
if (offsetBytes > 0) {
Os.lseek(targetFd, offsetBytes, OsConstants.SEEK_SET);
}
if (incomingFd != null) {
switch (Binder.getCallingUid()) {
case android.os.Process.SHELL_UID:
case android.os.Process.ROOT_UID:
case android.os.Process.SYSTEM_UID:
break;
default:
throw new SecurityException(
"Reverse mode only supported from shell or system");
}
// In "reverse" mode, we're streaming data ourselves from the
// incoming FD, which means we never have to hand out our
// sensitive internal FD. We still rely on a "bridge" being
// inserted above to hold the session active.
try {
final Int64Ref last = new Int64Ref(0);
//3.将apk文件从规范输入(STDIN_FIENO)copy到方针文件中
FileUtils.copy(incomingFd.getFileDescriptor(), targetFd, lengthBytes, null,
Runnable::run, (long progress) -> {
if (params.sizeBytes > 0) {
final long delta = progress - last.value;
last.value = progress;
addClientProgress((float) delta / (float) params.sizeBytes);
}
});
} finally {
IoUtils.closeQuietly(targetFd);
IoUtils.closeQuietly(incomingFd);
// We're done here, so remove the "bridge" that was holding
// the session active.
synchronized (mLock) {
if (PackageInstaller.ENABLE_REVOCABLE_FD) {
mFds.remove(fd);
} else {
bridge.forceClose();
mBridges.remove(bridge);
}
}
}
return null;
} else if (PackageInstaller.ENABLE_REVOCABLE_FD) {
fd.init(mContext, targetFd);
return fd.getRevocableFileDescriptor();
} else {
bridge.setTargetFile(targetFd);
bridge.start();
return new ParcelFileDescriptor(bridge.getClientSocket());
}
} catch (ErrnoException e) {
throw e.rethrowAsIOException();
}
}
能够看到，在该办法中，首要分为三步
- 获取写入装置包的临时目录
stageDir该目录在install-create阶段生成，一般便是/data/app/vmdl{sessionId}.tmp目录 - 创立要写入的目录文件，一般便是
stageDir/fileName.apk - 调用
FileUtils.copy办法将apk文件从规范输入中copy到方针文件中,完结本次的intall-write
在对一切的apk履行上述操作后，本次装置的xapk包就完结了install-write操作，下面剖析install-commit的履行办法runInstallCommit
2.4 runInstallCommit
在写入apk文件成功后，履行install-commit指令提交本次装置
private int runInstallCommit() throws RemoteException {
final int sessionId = Integer.parseInt(getNextArg());
return doCommitSession(sessionId, true /*logSuccess*/);
}
在runInstallCommit办法中，实践是调用doCommitSession完结commit操作而在doCommitSession中，实践上是调用PacakgeInstallerSession的commit办法并回来成果:
private int doCommitSession(int sessionId, boolean logSuccess)
throws RemoteException {
final PrintWriter pw = getOutPrintWriter();
PackageInstaller.Session session = null;
try {
session = new PackageInstaller.Session(
mInterface.getPackageInstaller().openSession(sessionId));
if (!session.isMultiPackage() && !session.isStaged()) {
// Sanity check that all .dm files match an apk.
// (The installer does not support standalone .dm files and will not process them.)
try {
DexMetadataHelper.validateDexPaths(session.getNames());
} catch (IllegalStateException | IOException e) {
pw.println(
"Warning [Could not validate the dex paths: " + e.getMessage() + "]");
}
}
final LocalIntentReceiver receiver = new LocalIntentReceiver();
session.commit(receiver.getIntentSender());
final Intent result = receiver.getResult();
final int status = result.getIntExtra(PackageInstaller.EXTRA_STATUS,
PackageInstaller.STATUS_FAILURE);
if (status == PackageInstaller.STATUS_SUCCESS) {
if (logSuccess) {
pw.println("Success");
}
} else {
pw.println("Failure ["
+ result.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE) + "]");
}
return status;
} finally {
IoUtils.closeQuietly(session);
}
}
下面进入到PacakgeInstallerSession中持续剖析commit办法
2.4.1 PackageInstallerSession#commit
commit源码如下
@Override
public void commit(@NonNull IntentSender statusReceiver, boolean forTransfer) {
if (mIsPerfLockAcquired && mPerfBoostInstall != null) {
mPerfBoostInstall.perfLockRelease();
mIsPerfLockAcquired = false;
}
if (hasParentSessionId()) {
throw new IllegalStateException(
"Session " + sessionId + " is a child of multi-package session "
+ mParentSessionId + " and may not be committed directly.");
}
//做一些准备作业，校验一下装置包，然后将运用标记为已提交
if (!markAsCommitted(statusReceiver, forTransfer)) {
return;
}
//判别是否是装置多个ap,adb install-multiple_packages指令,该值为true
//adb install-mulitple指令装置的仍是一个apk，仅仅这个apk由多个子包构成，所以该值为false
if (isMultiPackage()) {
final SparseIntArray remainingSessions = mChildSessionIds.clone();
final IntentSender childIntentSender =
new ChildStatusIntentReceiver(remainingSessions, statusReceiver)
.getIntentSender();
RuntimeException commitException = null;
boolean commitFailed = false;
for (int i = mChildSessionIds.size() - 1; i >= 0; --i) {
final int childSessionId = mChildSessionIds.keyAt(i);
try {
// commit all children, regardless if any of them fail; we'll throw/return
// as appropriate once all children have been processed
if (!mSessionProvider.getSession(childSessionId)
.markAsCommitted(childIntentSender, forTransfer)) {
commitFailed = true;
}
} catch (RuntimeException e) {
commitException = e;
}
}
if (commitException != null) {
throw commitException;
}
if (commitFailed) {
return;
}
}
mHandler.obtainMessage(MSG_COMMIT).sendToTarget();
}
在该办法中，首要会调用markAsCommitted办法对需求装置的运用做一些校验，首要是一些参数查看作业，并且在该阶段，会解分出装置的运用的包名并赋值给当前PackageInstallerSession的mPackageName特点，markAsComitted办法经过一系列调用后，终究会调用validateApkInstallLocked,该办法用来检测装置运用的各个参数，并完结一些装置的准备作业.该办法较长，下面只列出本次装置需求重视的当地:
private void validateApkInstallLocked(@Nullable PackageInfo pkgInfo)
throws PackageManagerException {
ApkLite baseApk = null;
mPackageName = null;
mVersionCode = -1;
mSigningDetails = PackageParser.SigningDetails.UNKNOWN;
...
final File[] addedFiles = mResolvedStageDir.listFiles(sAddedFilter);
if (ArrayUtils.isEmpty(addedFiles) && removeSplitList.size() == 0) {
throw new PackageManagerException(INSTALL_FAILED_INVALID_APK, "No packages staged");
}
// Verify that all staged packages are internally consistent
final ArraySet<String> stagedSplits = new ArraySet<>();
for (File addedFile : addedFiles) {
final ApkLite apk;
try {
//1.解分出apk的ApkLite
apk = PackageParser.parseApkLite(
addedFile, PackageParser.PARSE_COLLECT_CERTIFICATES);
} catch (PackageParserException e) {
throw PackageManagerException.from(e);
}
if (!stagedSplits.add(apk.splitName)) {
throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
"Split " + apk.splitName + " was defined multiple times");
}
// Use first package to define unknown values
//2. 获取apk的packageName和versionCode,关于xapk,每一个子apk的包的packName，versionCode都是相同的
if (mPackageName == null) {
mPackageName = apk.packageName;
mVersionCode = apk.getLongVersionCode();
}
if (mSigningDetails == PackageParser.SigningDetails.UNKNOWN) {
mSigningDetails = apk.signingDetails;
}
assertApkConsistentLocked(String.valueOf(addedFile), apk);
// Take this opportunity to enforce uniform naming
final String targetName;
//3.主包改名为base.apk,非主包前面加上split_前缀
if (apk.splitName == null) {
targetName = "base" + APK_FILE_EXTENSION;
} else {
targetName = "split_" + apk.splitName + APK_FILE_EXTENSION;
}
if (!FileUtils.isValidExtFilename(targetName)) {
throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
"Invalid filename: " + targetName);
}
final File targetFile = new File(mResolvedStageDir, targetName);
resolveAndStageFile(addedFile, targetFile);
// Base is coming from session
//4.将主包(base包保存下来)
if (apk.splitName == null) {
mResolvedBaseFile = targetFile;
baseApk = apk;
}
....
}
}
在该办法中，会遍历stagedDir，即写入apk文件的目录，对每一个apk做如下操作:
- 解分出apk的ApkLite
- 获取apk的packageName和versionCode,关于xapk,每一个子apk的包的packName，versionCode都是相同的
- 主包改名为base.apk,非主包前面加上split_前缀
- 假如是主包，则将主包途径保存下来
从代码中能够看到，要害的过程是第1步，即调用packageParser.parseApkLite办法生成ApkLite方针，ApkLite坐落源码/frameworks/base/core/java/android/content/pm/PackageParser.java首要是寄存AndroidMainfest.xml文件中跟装置运用有关的特点,如packageName,versionCode等
public static class ApkLite {
public final String codePath;
public final String packageName;
public final String splitName;
public boolean isFeatureSplit;
public final String configForSplit;
public final String usesSplitName;
public final int versionCode;
public final int versionCodeMajor;
public final int revisionCode;
public final int installLocation;
public final int minSdkVersion;
public final int targetSdkVersion;
public final VerifierInfo[] verifiers;
public final SigningDetails signingDetails;
public final boolean coreApp;
public final boolean debuggable;
public final boolean multiArch;
public final boolean use32bitAbi;
public final boolean extractNativeLibs;
public final boolean isolatedSplits;
public final boolean isSplitRequired;
public final boolean useEmbeddedDex;
}
在完结运用的参数查看后，下一步判别是否是MutilPackage，即批量装置多个运用的场景，一般是false,所以在该办法中，实践上是向Handler中发送一个MSG_COMMIT的Messgae,在Handler中处理该消息的代码如下
private final Handler.Callback mHandlerCallback = new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
switch (msg.what) {
case MSG_COMMIT:
handleCommit();
break;
//省掉其他case
}
return true;
}
};
在处理MSG_COMMIT时会调用handleCommit办法，该办法源码如下
private void handleCommit() {
//设备管理和设备安全相关，承认当前用户是否有权限装置运用
if (isInstallerDeviceOwnerOrAffiliatedProfileOwnerLocked()) {
DevicePolicyEventLogger
.createEvent(DevicePolicyEnums.INSTALL_PACKAGE)
.setAdmin(mInstallerPackageName)
.write();
}
//该apk是否分段传输，假如分段传输，需求指定--staged选项，一般不必
if (params.isStaged) {
mStagingManager.commitSession(this);
destroyInternal();
dispatchSessionFinished(PackageManager.INSTALL_SUCCEEDED, "Session staged", null);
return;
}
//是否装置apex
if ((params.installFlags & PackageManager.INSTALL_APEX) != 0) {
destroyInternal();
dispatchSessionFinished(PackageManager.INSTALL_FAILED_INTERNAL_ERROR,
"APEX packages can only be installed using staged sessions.", null);
return;
}
// For a multiPackage session, read the child sessions
// outside of the lock, because reading the child
// sessions with the lock held could lead to deadlock
// (b/123391593).
//多运用装置场景，获取一切的chidlSessions,单运用装置不必重视
List<PackageInstallerSession> childSessions = getChildSessions();
try {
synchronized (mLock) {
//提交一切的session
commitNonStagedLocked(childSessions);
}
} catch (PackageManagerException e) {
final String completeMsg = ExceptionUtils.getCompleteMessage(e);
Slog.e(TAG, "Commit of session " + sessionId + " failed: " + completeMsg);
destroyInternal();
dispatchSessionFinished(e.error, completeMsg, null);
}
}
在该办法中，做一些必要的校验后，假如是装置非stag应该和非apex，终究会进入到commitNonStagedLocked办法中办法中，关于单运用来说，childSessions参数为null，下面看commitNonStagedLocked办法
@GuardedBy("mLock")
private void commitNonStagedLocked(List<PackageInstallerSession> childSessions)
throws PackageManagerException {
//1.创立一个committingSession
final PackageManagerService.ActiveInstallSession committingSession =
makeSessionActiveLocked();
if (committingSession == null) {
return;
}
//处理多运用状况
if (isMultiPackage()) {
Slog.i("InstallTrace", " PackageInstallerSeiion#commitNonStagedLocked commit session: isMultiPackage");
List<PackageManagerService.ActiveInstallSession> activeChildSessions =
new ArrayList<>(childSessions.size());
boolean success = true;
PackageManagerException failure = null;
for (int i = 0; i < childSessions.size(); ++i) {
final PackageInstallerSession session = childSessions.get(i);
try {
final PackageManagerService.ActiveInstallSession activeSession =
session.makeSessionActiveLocked();
if (activeSession != null) {
activeChildSessions.add(activeSession);
}
} catch (PackageManagerException e) {
failure = e;
success = false;
}
}
if (!success) {
try {
mRemoteObserver.onPackageInstalled(
null, failure.error, failure.getLocalizedMessage(), null);
} catch (RemoteException ignored) {
}
return;
}
mPm.installStage(activeChildSessions);
} else {
//2.调用instllStage办法
mPm.installStage(committingSession);
}
}
在该办法中，实践上就做了两件事:
- 调用
makeSessionActiveLocked办法生成ActiveInstallSession方针 - 调用
PackageManagerService的installStage办法完结装置
下面先看makeSessionActiveLocked办法
@GuardedBy("mLock")
private PackageManagerService.ActiveInstallSession makeSessionActiveLocked()
throws PackageManagerException {
if (mRelinquished) {
throw new PackageManagerException(INSTALL_FAILED_INTERNAL_ERROR,
"Session relinquished");
}
if (mDestroyed) {
throw new PackageManagerException(INSTALL_FAILED_INTERNAL_ERROR, "Session destroyed");
}
if (!mSealed) {
throw new PackageManagerException(INSTALL_FAILED_INTERNAL_ERROR, "Session not sealed");
}
final IPackageInstallObserver2 localObserver;
if ((params.installFlags & PackageManager.INSTALL_APEX) != 0) {
localObserver = null;
} else {
Slog.i("InstallTrace", " PackageInstallerSeiion#makeSessionActiveLocaked commit session: isMultipackage="+params.isMultiPackage);
if (!params.isMultiPackage) {
Preconditions.checkNotNull(mPackageName);
Preconditions.checkNotNull(mSigningDetails);
Preconditions.checkNotNull(mResolvedBaseFile);
//1.是否还需求询问授权装置，关于adb装置一般不必
if (needToAskForPermissionsLocked()) {
// User needs to confirm installation;
// give installer an intent they can use to involve
// user.
final Intent intent = new Intent(PackageInstaller.ACTION_CONFIRM_INSTALL);
intent.setPackage(mPm.getPackageInstallerPackageName());
intent.putExtra(PackageInstaller.EXTRA_SESSION_ID, sessionId);
try {
mRemoteObserver.onUserActionRequired(intent);
} catch (RemoteException ignored) {
}
// Commit was keeping session marked as active until now; release
// that extra refcount so session appears idle.
closeInternal(false);
return null;
}
// Inherit any packages and native libraries from existing install that
// haven't been overridden.
//2.装置mode是否承继已有的package,adb install 一般是SessionParams.MODE_FULL_INSTALL
if (params.mode == SessionParams.MODE_INHERIT_EXISTING) {
try {
final List<File> fromFiles = mResolvedInheritedFiles;
final File toDir = resolveStageDirLocked();
if (LOGD) Slog.d(TAG, "Inherited files: " + mResolvedInheritedFiles);
if (!mResolvedInheritedFiles.isEmpty() && mInheritedFilesBase == null) {
throw new IllegalStateException("mInheritedFilesBase == null");
}
if (isLinkPossible(fromFiles, toDir)) {
if (!mResolvedInstructionSets.isEmpty()) {
final File oatDir = new File(toDir, "oat");
createOatDirs(mResolvedInstructionSets, oatDir);
}
// pre-create lib dirs for linking if necessary
if (!mResolvedNativeLibPaths.isEmpty()) {
for (String libPath : mResolvedNativeLibPaths) {
// "/lib/arm64" -> ["lib", "arm64"]
final int splitIndex = libPath.lastIndexOf('/');
if (splitIndex < 0 || splitIndex >= libPath.length() - 1) {
Slog.e(TAG,
"Skipping native library creation for linking due"
+ " to invalid path: " + libPath);
continue;
}
final String libDirPath = libPath.substring(1, splitIndex);
final File libDir = new File(toDir, libDirPath);
if (!libDir.exists()) {
NativeLibraryHelper.createNativeLibrarySubdir(libDir);
}
final String archDirPath = libPath.substring(splitIndex + 1);
NativeLibraryHelper.createNativeLibrarySubdir(
new File(libDir, archDirPath));
}
}
linkFiles(fromFiles, toDir, mInheritedFilesBase);
} else {
// TODO: this should delegate to DCS so the system process
// avoids holding open FDs into containers.
copyFiles(fromFiles, toDir);
}
} catch (IOException e) {
throw new PackageManagerException(INSTALL_FAILED_INSUFFICIENT_STORAGE,
"Failed to inherit existing install", e);
}
}
// TODO: surface more granular state from dexopt
mInternalProgress = 0.5f;
computeProgressLocked(true);
// Unpack native libraries
//3. 提取出lib库
Slog.i("InstallTrace", " PackageInstallerSeiion#makeSessionActiveLocaked commit session: mResolvedStageDir="+mResolvedStageDir+"params.abi="+params.abiOverride);
extractNativeLibraries(mResolvedStageDir, params.abiOverride,
mayInheritNativeLibs());
}
// We've reached point of no return; call into PMS to install the stage.
// Regardless of success or failure we always destroy session.
localObserver = new IPackageInstallObserver2.Stub() {
@Override
public void onUserActionRequired(Intent intent) {
throw new IllegalStateException();
}
@Override
public void onPackageInstalled(String basePackageName, int returnCode, String msg,
Bundle extras) {
destroyInternal();
dispatchSessionFinished(returnCode, msg, extras);
}
};
}
//4 确认use,一般是UserHandle.ALL
final UserHandle user;
if ((params.installFlags & PackageManager.INSTALL_ALL_USERS) != 0) {
user = UserHandle.ALL;
} else {
user = new UserHandle(userId);
}
//5.回来AcitveInstallSession方针
mRelinquished = true;
Slog.i("InstallTrace", " PackageInstallerSeiion#makeSessionActiveLocaked commit session: mPackageName="+mPackageName+" stageDir="+stageDir+" mInstallerPackageName=" + mInstallerPackageName+" uid="+ mInstallerUid);
return new PackageManagerService.ActiveInstallSession(mPackageName, stageDir,
localObserver, params, mInstallerPackageName, mInstallerUid, user,
mSigningDetails);
}
在makeSessionActiveLocked办法中，首要有下面5个过程
- 是否还需求询问授权装置，关于
adb装置一般不必 - 装置
mode是否承继已有的package,adb install一般是SessionParams.MODE_FULL_INSTALL - 提取出
lib库 - 确认
use,一般是UserHandle.ALL - 回来
AcitveInstallSession方针
这5个过程中，1,2是进行装置前的一些查看，4是承认运用的用户权限，5是回来生成的ActiveInstallSession方针，这四个过程都比较简单，比较重要的是第3步，提取运用的lib库，因为xapk的lib库和apk运用的lib库提取有一些差异，这部分内容放在下文独自剖析，咱们先持续看commitNonStagedLocked办法。
在调用makeSessionActiveLocked生成ActiveInstallSession后，commitNonStagedLocked办法下一步调用PackageManagerService的installStage完结运用装置。在Android 10中，无论是在运用商铺下载运用自动装置，仍是下载apk手动装置，亦或是运用pm install或adb install这些指令的办法装置，终究都会调用PackageManagerService#installStage办法完结运用装置，所以该办法不仅仅和xapk装置有联系。关于该办法的剖析，咱们放在下一篇中独自剖析。
在进入下一篇剖析installStage办法时，先看看xapk中比较重要的提取lib库的办法：PackageInstallSession中的extractNativeLibraries办法
3 Android运用提取lib库
3.1 Android 运用提取lib库全体流程
在android运用，尤其是游戏中，一般会包括许多的动态so库，若这些游戏是apk方式的装置包，其so库一般会打包到apk的lib目录下，在装置时，会将这些so库从apk中提取到游戏的lib目录下。而关于包括多个apk的xapk游戏装置包，其so库可能会和普通apk游戏装置包相同，将so库打包到xapk的主apk中，这样运用adb multiple-install装置时，会将so库解析到运用的lib目录；而更常见的状况是，运用会将so库打包成一个独自的apk,在运行游戏时，会将这个apk加载到内存中，以此来完结so库动态加载，关于这种状况，一般是不能将so库解压到运用的lib目录。这样，关于xapk的运用在装置时，就需求考虑是否将so库抽取到lib目录下，前文提到，在装置运用时，会调用PackageInstallSession中的extractNativeLibraries办法提取so库，下面看看该办法代码：
private static void extractNativeLibraries(File packageDir, String abiOverride, boolean inherit)
throws PackageManagerException {
//libDir:即lib目录
final File libDir = new File(packageDir, NativeLibraryHelper.LIB_DIR_NAME);
packageDir.getAbsolutePath()+";abioverride="+abiOverride+";inherit="+inherit);
//inherit一般为false
if (!inherit) {
// Start from a clean slate
NativeLibraryHelper.removeNativeBinariesFromDirLI(libDir, true);
}
NativeLibraryHelper.Handle handle = null;
try {
//依据packageDir目录生成对应的Handle
handle = NativeLibraryHelper.Handle.create(packageDir);
//解析so库到lib目录
final int res = NativeLibraryHelper.copyNativeBinariesWithOverride(handle, libDir,
abiOverride);
if (res != PackageManager.INSTALL_SUCCEEDED) {
throw new PackageManagerException(res,
"Failed to extract native libraries, res=" + res);
}
} catch (IOException e) {
throw new PackageManagerException(INSTALL_FAILED_INTERNAL_ERROR,
"Failed to extract native libraries", e);
} finally {
IoUtils.closeQuietly(handle);
}
}
从代码中能够看到，该办法首要在于NativeLibraryHelper.Handle.create和 NativeLibraryHelper.copyNativeBinariesWithOverride这两个办法的逻辑上，NativeLibraryHelper源码坐落frameworks/base/core/java/com/android/internal/content/NativeLibraryHelper.java,Handle是其一个内部类，该类的create办法为:
public static class Handle implements Closeable {
private final CloseGuard mGuard = CloseGuard.get();
private volatile boolean mClosed;
final long[] apkHandles;
final boolean multiArch;
final boolean extractNativeLibs;
final boolean debuggable;
public static Handle create(File packageFile) throws IOException {
try {
final PackageLite lite = PackageParser.parsePackageLite(packageFile, 0);
return create(lite);
} catch (PackageParserException e) {
throw new IOException("Failed to parse package: " + packageFile, e);
}
}
....
在该办法中，会先调用PackageParser.parsePackageLite办法，该办法和前文的packageParser.parseApkLite相似，会生成一个PackageLite方针,和ApkLite用来记载一个apk的要害信息不同，PackageLite用来记载整个装置包的要害信息，包括该装置包有多少个apk等信息:
/**
* Lightweight parsed details about a single package.
*/
public static class PackageLite {
@UnsupportedAppUsage
public final String packageName;
public final int versionCode;
public final int versionCodeMajor;
@UnsupportedAppUsage
public final int installLocation;
public final VerifierInfo[] verifiers;
/** Names of any split APKs, ordered by parsed splitName */
public final String[] splitNames;
/** Names of any split APKs that are features. Ordered by splitName */
public final boolean[] isFeatureSplits;
/** Dependencies of any split APKs, ordered by parsed splitName */
public final String[] usesSplitNames;
public final String[] configForSplit;
/**
* Path where this package was found on disk. For monolithic packages
* this is path to single base APK file; for cluster packages this is
* path to the cluster directory.
*/
public final String codePath;
/** Path of base APK */
public final String baseCodePath;
/** Paths of any split APKs, ordered by parsed splitName */
public final String[] splitCodePaths;
/** Revision code of base APK */
public final int baseRevisionCode;
/** Revision codes of any split APKs, ordered by parsed splitName */
public final int[] splitRevisionCodes;
public final boolean coreApp;
public final boolean debuggable;
public final boolean multiArch;
public final boolean use32bitAbi;
public final boolean extractNativeLibs;
public final boolean isolatedSplits;
在生成PackageLite方针后，再调用其他create办法完结Handle创立，终究会将Handle的体系特点由PackageLite方针中获取到，比如其extractNativeLibs特点便是PackageLite方针的extractNativeLibs特点。其apkHandles便是PackageLite方针中保存的一切apk文件途径的文件描述符.
在生成了Handle方针后，下一步便是调用NativeLibraryHelper.copyNativeBinariesWithOverride办法完结so库的复制,在该办法中，终究会调用copyNativeBinaries办法完结so库复制
/**
* Copies native binaries to a shared library directory.
*
* @param handle APK file to scan for native libraries
* @param sharedLibraryDir directory for libraries to be copied to
* @return {@link PackageManager#INSTALL_SUCCEEDED} if successful or another
* error code from that class if not
*/
public static int copyNativeBinaries(Handle handle, File sharedLibraryDir, String abi) {
for (long apkHandle : handle.apkHandles) {
int res = nativeCopyNativeBinaries(apkHandle, sharedLibraryDir.getPath(), abi,
handle.extractNativeLibs, handle.debuggable);
if (res != INSTALL_SUCCEEDED) {
return res;
}
}
return INSTALL_SUCCEEDED;
}
在该办法中，会调用nativeCopyNativeBinaries方完结复制操作，该办法中的参数 handle.extractNativeLibs是用来标识是否需求提取so库，其值即为前文说的PackageLite方针的extractNativeLibs特点值。nativeCopyNativeBinaries是一个JNI办法，其完结坐落/frameworks/base/core/jni/com_android_internal_content_NativeLibraryHelper.cpp#com_android_internal_content_NativeLibraryHelper_copyNativeBinaries，在该办法中，终究会调用其该类的copyFileIfChanged办法，下面列出来该办法部分代码
copyFileIfChanged(JNIEnv *env, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntry, const char* fileName)
{
void** args = reinterpret_cast<void**>(arg);
jstring* javaNativeLibPath = (jstring*) args[0];
jboolean extractNativeLibs = *(jboolean*) args[1];
ScopedUtfChars nativeLibPath(env, *javaNativeLibPath);
uint32_t uncompLen;
uint32_t when;
uint32_t crc;
uint16_t method;
off64_t offset;
if (!zipFile->getEntryInfo(zipEntry, &method, &uncompLen, NULL, &offset, &when, &crc)) {
ALOGE("Couldn't read zip entry info\n");
return INSTALL_FAILED_INVALID_APK;
}
//假如extractNativeLibs特点为false,则仅仅做一些校验然后回来，不会copy so库
if (!extractNativeLibs) {
// check if library is uncompressed and page-aligned
if (method != ZipFileRO::kCompressStored) {
ALOGE("Library '%s' is compressed - will not be able to open it directly from apk.\n",
fileName);
return INSTALL_FAILED_INVALID_APK;
}
if (offset % PAGE_SIZE != 0) {
ALOGE("Library '%s' is not page-aligned - will not be able to open it directly from"
" apk.\n", fileName);
return INSTALL_FAILED_INVALID_APK;
}
return INSTALL_SUCCEEDED;
}
//extractNativeLibs特点为true,解析一切apk的so库
// Build local file path
const size_t fileNameLen = strlen(fileName);
char localFileName[nativeLibPath.size() + fileNameLen + 2];
在该办法中，会判别extractNativeLibs参数的值，该参数便是PackageLite方针中的extractNativeLibs特点值，若该值为true,则解析一切apk文件的so库，若该值为false,则不解析so库
至此，Android 运用提取so库的逻辑就剖析完结了，总结起来便是：依据生成的PackageLite方针的extractNativeLibs特点来判别是否需求将运用的so库解析到lib目录，若该值为true,则解析到lib目录，若该值为false,则不解析。下面咱们持续剖析PackageLite方针的创立进程。
3.2 PackageLite方针创立进程
前文提到，create办法中的PackageLite方针是经过PackageParser#parsePackageLite办法得到的，该办法源码如下
public static PackageLite parsePackageLite(File packageFile, int flags)
throws PackageParserException {
if (packageFile.isDirectory()) {
return parseClusterPackageLite(packageFile, flags);
} else {
return parseMonolithicPackageLite(packageFile, flags);
}
}
若packageFile参数不是一个目录(即是一个apk文件),则履行parseMonolithicPackageLite办法:
private static PackageLite parseMonolithicPackageLite(File packageFile, int flags)
throws PackageParserException {
Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "parseApkLite");
final ApkLite baseApk = parseApkLite(packageFile, flags);
final String packagePath = packageFile.getAbsolutePath();
Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
return new PackageLite(packagePath, baseApk, null, null, null, null, null, null);
}
能够看到，在该办法中，便是调用parseApkLite解析apk文件，然后使用该apkLite生成一个PackageLite方针。
若packageFile参数是一个目录，则履行办法parseClusterPackageLite办法，关于xapk来说，该参数一般便是一个目录，下面看该办法代码
static PackageLite parseClusterPackageLite(File packageDir, int flags)
throws PackageParserException {
//1.获取该目录下一切apk文件
final File[] files = packageDir.listFiles();
if (ArrayUtils.isEmpty(files)) {
throw new PackageParserException(INSTALL_PARSE_FAILED_NOT_APK,
"No packages found in split");
}
String packageName = null;
int versionCode = 0;
Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "parseApkLite");
final ArrayMap<String, ApkLite> apks = new ArrayMap<>();
for (File file : files) {
//2.遍历apk文件
if (isApkFile(file)) {
//3.调用parseApkLite生成ApkLite
final ApkLite lite = parseApkLite(file, flags);
// Assert that all package names and version codes are
// consistent with the first one we encounter.
if (packageName == null) {
packageName = lite.packageName;
versionCode = lite.versionCode;
} else {
//4.查看packageName和version,关于xapk包，每一个apk的packageName和versionCode应该共同
if (!packageName.equals(lite.packageName)) {
throw new PackageParserException(INSTALL_PARSE_FAILED_BAD_MANIFEST,
"Inconsistent package " + lite.packageName + " in " + file
+ "; expected " + packageName);
}
if (versionCode != lite.versionCode) {
throw new PackageParserException(INSTALL_PARSE_FAILED_BAD_MANIFEST,
"Inconsistent version " + lite.versionCode + " in " + file
+ "; expected " + versionCode);
}
}
//5.将splitName和对应的ApkLite放入map表，注意，主包的splitName为null
// Assert that each split is defined only once
if (apks.put(lite.splitName, lite) != null) {
throw new PackageParserException(INSTALL_PARSE_FAILED_BAD_MANIFEST,
"Split name " + lite.splitName
+ " defined more than once; most recent was " + file);
}
}
}
Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
//6. 移除去主包，并报错主包的ApkLite
final ApkLite baseApk = apks.remove(null);
if (baseApk == null) {
throw new PackageParserException(INSTALL_PARSE_FAILED_BAD_MANIFEST,
"Missing base APK in " + packageDir);
}
// Always apply deterministic ordering based on splitName
final int size = apks.size();
//7.获取splitNames等参数
String[] splitNames = null;
boolean[] isFeatureSplits = null;
String[] usesSplitNames = null;
String[] configForSplits = null;
String[] splitCodePaths = null;
int[] splitRevisionCodes = null;
String[] splitClassLoaderNames = null;
if (size > 0) {
splitNames = new String[size];
isFeatureSplits = new boolean[size];
usesSplitNames = new String[size];
configForSplits = new String[size];
splitCodePaths = new String[size];
splitRevisionCodes = new int[size];
splitNames = apks.keySet().toArray(splitNames);
Arrays.sort(splitNames, sSplitNameComparator);
for (int i = 0; i < size; i++) {
final ApkLite apk = apks.get(splitNames[i]);
usesSplitNames[i] = apk.usesSplitName;
isFeatureSplits[i] = apk.isFeatureSplit;
configForSplits[i] = apk.configForSplit;
splitCodePaths[i] = apk.codePath;
splitRevisionCodes[i] = apk.revisionCode;
}
}
//8.获取codePath,即packageDir的绝对途径(stagedDir的途径)
final String codePath = packageDir.getAbsolutePath();
//9.调用对应的结构办法生成PackageLite方针
return new PackageLite(codePath, baseApk, splitNames, isFeatureSplits, usesSplitNames,
configForSplits, splitCodePaths, splitRevisionCodes);
}
如代码注释所示，该办法首要有9个过程，在这9个过程中，也包括调用parseApkLite办法生成ApkLite方针的过程，下面先看看该办法:
public static ApkLite parseApkLite(File apkFile, int flags)
throws PackageParserException {
return parseApkLiteInner(apkFile, null, null, flags);
}
private static ApkLite parseApkLiteInner(File apkFile, FileDescriptor fd, String debugPathName,
int flags) throws PackageParserException {
final String apkPath = fd != null ? debugPathName : apkFile.getAbsolutePath();
XmlResourceParser parser = null;
ApkAssets apkAssets = null;
try {
try {
apkAssets = fd != null
? ApkAssets.loadFromFd(fd, debugPathName, false, false)
: ApkAssets.loadFromPath(apkPath);
} catch (IOException e) {
throw new PackageParserException(INSTALL_PARSE_FAILED_NOT_APK,
"Failed to parse " + apkPath);
}
//读取apk的AndroidManifest.xml文件
parser = apkAssets.openXml(ANDROID_MANIFEST_FILENAME);
final SigningDetails signingDetails;
if ((flags & PARSE_COLLECT_CERTIFICATES) != 0) {
// TODO: factor signature related items out of Package object
final Package tempPkg = new Package((String) null);
final boolean skipVerify = (flags & PARSE_IS_SYSTEM_DIR) != 0;
Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "collectCertificates");
try {
collectCertificates(tempPkg, apkFile, skipVerify);
} finally {
Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
}
signingDetails = tempPkg.mSigningDetails;
} else {
signingDetails = SigningDetails.UNKNOWN;
}
final AttributeSet attrs = parser;
//解析AndroidManifest.xml文件中特点
return parseApkLite(apkPath, parser, attrs, signingDetails);
} catch (XmlPullParserException | IOException | RuntimeException e) {
Slog.w(TAG, "Failed to parse " + apkPath, e);
throw new PackageParserException(INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION,
"Failed to parse " + apkPath, e);
} finally {
IoUtils.closeQuietly(parser);
if (apkAssets != null) {
try {
apkAssets.close();
} catch (Throwable ignored) {
}
}
// TODO(b/72056911): Implement AutoCloseable on ApkAssets.
}
}
在parseApkLite办法中，实践调用的是parseApkLiteInner,在该办法中，会读取该apk文件的AndroidManifest.xml文件，然后调用重载的parseApkLite办法生成ApkLite方针:
private static ApkLite parseApkLite(String codePath, XmlPullParser parser, AttributeSet attrs,
SigningDetails signingDetails)
throws IOException, XmlPullParserException, PackageParserException {
final Pair<String, String> packageSplit = parsePackageSplitNames(parser, attrs);
int installLocation = PARSE_DEFAULT_INSTALL_LOCATION;
int versionCode = 0;
int versionCodeMajor = 0;
int targetSdkVersion = DEFAULT_TARGET_SDK_VERSION;
int minSdkVersion = DEFAULT_MIN_SDK_VERSION;
int revisionCode = 0;
boolean coreApp = false;
boolean debuggable = false;
boolean multiArch = false;
boolean use32bitAbi = false;
boolean extractNativeLibs = true;
boolean isolatedSplits = false;
boolean isFeatureSplit = false;
boolean isSplitRequired = false;
boolean useEmbeddedDex = false;
String configForSplit = null;
String usesSplitName = null;
for (int i = 0; i < attrs.getAttributeCount(); i++) {
final String attr = attrs.getAttributeName(i);
if (attr.equals("installLocation")) {
installLocation = attrs.getAttributeIntValue(i,
PARSE_DEFAULT_INSTALL_LOCATION);
} else if (attr.equals("versionCode")) {
versionCode = attrs.getAttributeIntValue(i, 0);
} else if (attr.equals("versionCodeMajor")) {
versionCodeMajor = attrs.getAttributeIntValue(i, 0);
} else if (attr.equals("revisionCode")) {
revisionCode = attrs.getAttributeIntValue(i, 0);
} else if (attr.equals("coreApp")) {
coreApp = attrs.getAttributeBooleanValue(i, false);
} else if (attr.equals("isolatedSplits")) {
isolatedSplits = attrs.getAttributeBooleanValue(i, false);
} else if (attr.equals("configForSplit")) {
configForSplit = attrs.getAttributeValue(i);
} else if (attr.equals("isFeatureSplit")) {
isFeatureSplit = attrs.getAttributeBooleanValue(i, false);
} else if (attr.equals("isSplitRequired")) {
isSplitRequired = attrs.getAttributeBooleanValue(i, false);
}
}
// Only search the tree when the tag is the direct child of <manifest> tag
int type;
final int searchDepth = parser.getDepth() + 1;
final List<VerifierInfo> verifiers = new ArrayList<VerifierInfo>();
while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
&& (type != XmlPullParser.END_TAG || parser.getDepth() >= searchDepth)) {
if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
continue;
}
if (parser.getDepth() != searchDepth) {
continue;
}
if (TAG_PACKAGE_VERIFIER.equals(parser.getName())) {
final VerifierInfo verifier = parseVerifier(attrs);
if (verifier != null) {
verifiers.add(verifier);
}
} else if (TAG_APPLICATION.equals(parser.getName())) {
for (int i = 0; i < attrs.getAttributeCount(); ++i) {
final String attr = attrs.getAttributeName(i);
if ("debuggable".equals(attr)) {
debuggable = attrs.getAttributeBooleanValue(i, false);
}
if ("multiArch".equals(attr)) {
multiArch = attrs.getAttributeBooleanValue(i, false);
}
if ("use32bitAbi".equals(attr)) {
use32bitAbi = attrs.getAttributeBooleanValue(i, false);
}
if ("extractNativeLibs".equals(attr)) {
extractNativeLibs = attrs.getAttributeBooleanValue(i, true);
}
if ("useEmbeddedDex".equals(attr)) {
useEmbeddedDex = attrs.getAttributeBooleanValue(i, false);
}
}
} else if (TAG_USES_SPLIT.equals(parser.getName())) {
if (usesSplitName != null) {
Slog.w(TAG, "Only one <uses-split> permitted. Ignoring others.");
continue;
}
usesSplitName = attrs.getAttributeValue(ANDROID_RESOURCES, "name");
if (usesSplitName == null) {
throw new PackageParserException(
PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED,
"<uses-split> tag requires 'android:name' attribute");
}
} else if (TAG_USES_SDK.equals(parser.getName())) {
for (int i = 0; i < attrs.getAttributeCount(); ++i) {
final String attr = attrs.getAttributeName(i);
if ("targetSdkVersion".equals(attr)) {
targetSdkVersion = attrs.getAttributeIntValue(i,
DEFAULT_TARGET_SDK_VERSION);
}
if ("minSdkVersion".equals(attr)) {
minSdkVersion = attrs.getAttributeIntValue(i, DEFAULT_MIN_SDK_VERSION);
}
}
}
}
return new ApkLite(codePath, packageSplit.first, packageSplit.second, isFeatureSplit,
configForSplit, usesSplitName, isSplitRequired, versionCode, versionCodeMajor,
revisionCode, installLocation, verifiers, signingDetails, coreApp, debuggable,
multiArch, use32bitAbi, useEmbeddedDex, extractNativeLibs, isolatedSplits,
minSdkVersion, targetSdkVersion);
}
能够看到，在该办法中便是解析AndroidManifest.xml的首要特点，然后运用这个特点值生成ApkLite特点，其间需求注意这些特点的默许值，其间extractNativeLibs特点的默许值为true,表示需求将动态so库解析到lib目录，若该值为false，则表示不能把so库解析到lib目录。
在剖析了parseApkLite办法后，持续看parseClusterPackageLite，在该办法的终究，会调用PackageLite的结构办法生成一个PackageLite的方针
public PackageLite(String codePath, ApkLite baseApk, String[] splitNames,
boolean[] isFeatureSplits, String[] usesSplitNames, String[] configForSplit,
String[] splitCodePaths, int[] splitRevisionCodes) {
this.packageName = baseApk.packageName;
this.versionCode = baseApk.versionCode;
this.versionCodeMajor = baseApk.versionCodeMajor;
this.installLocation = baseApk.installLocation;
this.verifiers = baseApk.verifiers;
this.splitNames = splitNames;
this.isFeatureSplits = isFeatureSplits;
this.usesSplitNames = usesSplitNames;
this.configForSplit = configForSplit;
this.codePath = codePath;
this.baseCodePath = baseApk.codePath;
this.splitCodePaths = splitCodePaths;
this.baseRevisionCode = baseApk.revisionCode;
this.splitRevisionCodes = splitRevisionCodes;
this.coreApp = baseApk.coreApp;
this.debuggable = baseApk.debuggable;
this.multiArch = baseApk.multiArch;
this.use32bitAbi = baseApk.use32bitAbi;
this.extractNativeLibs = baseApk.extractNativeLibs;
this.isolatedSplits = baseApk.isolatedSplits;
}
在该结构办法中，首要重视特点extractNativeLibs，该特点是主包(baseApk)的extractNativeLibs特点的值。该值默许是ture,若装置包的主包的AndroidManifest.xml文件中包括android:extractNativeLibs特点值，则运用其值，若不包括该特点，则运用默许值true。
至此，咱们就明白了PackageLite方针的extractNativeLibs特点是怎么来的了，其实便是解析主包的AndroidManifest.xml文件的android:extractNativeLibs特点值，若不包括该特点，则默许为true.在只包括一个apk的运用中(普通apk包或apk+obb方式的xapk包),其主包的AndroidManifest.xml文件中一般不会包括android:extractNativeLibs特点，而关于多个apk组成的xapk装置包，其主包的AndroidManifest.xml中一般都会清晰指定android:extractNativeLibs特点的值。
3.3 总结
经过对extractNativeLibraries办法的剖析，咱们得出了下面的结论:
- 若装置包主包的
AndroidManifest.xml文件中不包括android:extractNativeLibs特点或该特点值为true,体系会解分出so库到lib目录 - 若装置包主包的
AndroidManifest.xml文件中包括android:extractNativeLibs特点且该特点为false,体系不会解析so库到lib目录
剖析完了解析so库的逻辑，adb install-multiply的三个核心办法runInstallCreate, runInstallWrite, runInstallCommit三个办法全体流程就剖析完结了，在下一篇，咱们将持续剖析PackageManagerService#installStage办法，该办法完结终究的装置操作
