PacakgeManagerService学习笔记七-APK installation

1. adb install: adb intall有多个参数，只做简单学习，adb install xxx.apk, adb是一个命令，install是其参数。

/*--commandline.c--> adb_commandline*/

int adb_commandline(int argc, char **argv)
{
/*-----------省略------------*/
if(!strcmp(argv[0], "install")) {
if (argc < 2) return usage();
return install_app(ttype, serial, argc, argv);
}
/*-----------省略------------*/
}

int install_app(transport_type transport, char* serial, int argc, char** argv)
{
/*
将要安装的APK从host主机上，copy到手机中，需要先设置copy目录，
如果要安装在内存中对应的目录为/data/local/tmp;
如果要安装在sd卡中对应的目录为/sdcard/temp
*/
static const char *const DATA_DEST = "/data/local/tmp/%s";
static const char *const SD_DEST = "/sdcard/tmp/%s";
const char* where = DATA_DEST;
char apk_dest[PATH_MAX];
char verification_dest[PATH_MAX];
char* apk_file;
char* verification_file = NULL;
int file_arg = -1;
int err;
int i;
int verify_apk = 1;

for (i = 1; i < argc; i++) {
if (*argv[i] != '-') {
file_arg = i;
break;
} else if (!strcmp(argv[i], "-i")) {
// Skip the installer package name.
i++;
} else if (!strcmp(argv[i], "-s")) {
where = SD_DEST;
} else if (!strcmp(argv[i], "--algo")) {
verify_apk = 0;
i++;
} else if (!strcmp(argv[i], "--iv")) {
verify_apk = 0;
i++;
} else if (!strcmp(argv[i], "--key")) {
verify_apk = 0;
i++;
}
}

if (file_arg < 0) {
fprintf(stderr, "can't find filename in arguments\n");
return 1;
} else if (file_arg + 2 < argc) {
fprintf(stderr, "too many files specified; only takes APK file and verifier file\n");
return 1;
}

apk_file = argv[file_arg];

if (file_arg != argc - 1) {
verification_file = argv[file_arg + 1];
}

if (check_file(apk_file) || check_file(verification_file)) {
return 1;
}

snprintf(apk_dest, sizeof apk_dest, where, get_basename(apk_file));
if (verification_file != NULL) {
snprintf(verification_dest, sizeof(verification_dest), where, get_basename(verification_file));

if (!strcmp(apk_dest, verification_dest)) {
fprintf(stderr, "APK and verification file can't have the same name\n");
return 1;
}
}

/*
如果有verification.apk，先做检查
*/
err = do_sync_push(apk_file, apk_dest, verify_apk);
if (err) {
goto cleanup_apk;
} else {
argv[file_arg] = apk_dest; /* destination name, not source location */
}

if (verification_file != NULL) {
err = do_sync_push(verification_file, verification_dest, 0 /* no verify APK */);
if (err) {
goto cleanup_apk;
} else {
argv[file_arg + 1] = verification_dest; /* destination name, not source location */
}
}
/*
执行pm脚本进行安装
*/
pm_command(transport, serial, argc, argv);

cleanup_apk:
if (verification_file != NULL) {
delete_file(transport, serial, verification_dest);
}

delete_file(transport, serial, apk_dest);

return err;
}

以上代码中的3个关键点：

1> android4.0新增了APK安装过程中的Verfication的功能。该功能就是在安装的过程中将相关信息发送给指定的Verfication程序(另外一个apk)，由它对要安装的APK进行检查

2> 调用pm_command进行安装
3> 安装完后，执行删除复制的临时文件 

2. pm 

static int pm_command(transport_type transport, char* serial,
int argc, char** argv)
{
char buf[4096];

snprintf(buf, sizeof(buf), "shell:pm");

while(argc-- > 0) {
char *quoted;

quoted = dupAndQuote(*argv++);

strncat(buf, " ", sizeof(buf)-1);
strncat(buf, quoted, sizeof(buf)-1);
free(quoted);
}
/*
发送“shell:pm install 参数”到手持式终端
*/
send_shellcommand(transport, serial, buf);
return 0;
}

pm脚本：

/*
pm脚本
*/
/*
#Script to start "pm" on the device, which has a very rudimentary(基本的)
#shell
#
base=/system
export CLASSPATH=$base/frameworks/pm.jar
exec app_process $base/bin com.android.commands.pm.Pm “$@”
*/

该脚本通过app_process进程指向pm,jar中的main方法。

/*---------pm.java------------*/
public static void main(String[] args) {
new Pm().run(args);
}

public void run(String[] args) {
boolean validCommand = false;
if (args.length < 1) {
showUsage();
return;
}
/*
获得binder客户端
*/
mUm = IUserManager.Stub.asInterface(ServiceManager.getService("user"));
mPm = IPackageManager.Stub.asInterface(ServiceManager.getService("package"));
if (mPm == null) {
System.err.println(PM_NOT_RUNNING_ERR);
return;
}

mArgs = args;
String op = args[0];
mNextArg = 1;
.........

if ("install".equals(op)) {
runInstall();
return;
}

.........
}

run方法中调用runInstall方法

1. 解析安装参数

2. 调用installPackageWithVerificationAndEncrytion完成后续的安装工作

private void runInstall() {
int installFlags = PackageManager.INSTALL_ALL_USERS;
String installerPackageName = null;

String opt;

String algo = null;
byte[] iv = null;
byte[] key = null;

String macAlgo = null;
byte[] macKey = null;
byte[] tag = null;
String originatingUriString = null;
String referrer = null;

/*
省略部分
该部分对安装参数进行解析
*/

/*省略*/
final Uri apkURI;
final Uri verificationURI;
final Uri originatingURI;
final Uri referrerURI;

if (originatingUriString != null) {
originatingURI = Uri.parse(originatingUriString);
} else {
originatingURI = null;
}

if (referrer != null) {
referrerURI = Uri.parse(referrer);
} else {
referrerURI = null;
}

// Populate apkURI, must be present
final String apkFilePath = nextArg();
System.err.println("\tpkg: " + apkFilePath);
if (apkFilePath != null) {
apkURI = Uri.fromFile(new File(apkFilePath));
} else {
System.err.println("Error: no package specified");
return;
}

// Populate verificationURI, optionally present
final String verificationFilePath = nextArg();
if (verificationFilePath != null) {
System.err.println("\tver: " + verificationFilePath);
verificationURI = Uri.fromFile(new File(verificationFilePath));
} else {
verificationURI = null;
}

/*
inofify机制，接收安装结果
*/
PackageInstallObserver obs = new PackageInstallObserver();
try {
VerificationParams verificationParams = new VerificationParams(verificationURI,
originatingURI, referrerURI, VerificationParams.NO_UID, null);
/*
调用installPackageWithVerificationAndEncryption完成安装
*/
mPm.installPackageWithVerificationAndEncryption(apkURI, obs, installFlags,
installerPackageName, verificationParams, encryptionParams);

synchronized (obs) {
while (!obs.finished) {
try {
obs.wait();
} catch (InterruptedException e) {
}
}
if (obs.result == PackageManager.INSTALL_SUCCEEDED) {
System.out.println("Success");
} else {
System.err.println("Failure ["
+ installFailureToString(obs.result)
+ "]");
}
}
} catch (RemoteException e) {
System.err.println(e.toString());
System.err.println(PM_NOT_RUNNING_ERR);
}
}

installPackageWithVerfication:

/*PackageManagerService.java*/
public void installPackageWithVerification(Uri packageURI, IPackageInstallObserver observer,
int flags, String installerPackageName, Uri verificationURI,
ManifestDigest manifestDigest) {
/*
检查客户端进程是否具有安装Package权限。
*/
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.INSTALL_PACKAGES, null);

final int uid = Binder.getCallingUid();

final int filteredFlags;

if (uid == Process.SHELL_UID || uid == 0) {
if (DEBUG_INSTALL) {
Slog.v(TAG, "Install from ADB");
}
filteredFlags = flags | PackageManager.INSTALL_FROM_ADB;
} else {
filteredFlags = flags & ~PackageManager.INSTALL_FROM_ADB;
}
/*
创建一个Message对象，code = INIT_COPY,将该消息发送给PackageManagerService中的mHandler

创建一个InstallParams对象
*/
final Message msg = mHandler.obtainMessage(INIT_COPY);
msg.obj = new InstallParams(packageURI, observer, filteredFlags, installerPackageName,
verificationURI, manifestDigest);
mHandler.sendMessage(msg);
}

mHandler中的handleMessage中调用doHandleMessage方法：
1. INIT_COPY

void doHandleMessage(Message msg) {
switch (msg.what) {
case INIT_COPY: {
if (DEBUG_INSTALL) Slog.i(TAG, "init_copy");
HandlerParams params = (HandlerParams) msg.obj;
int idx = mPendingInstalls.size();
if (DEBUG_INSTALL) Slog.i(TAG, "idx=" + idx);
// If a bind was already initiated we dont really
// need to do anything. The pending install
// will be processed later on.
if (!mBound) {
// If this is the only one pending we might
// have to bind to the service again.
/*
启动DefaultContainerService服务，通过bindService来启动
*/
if (!connectToService()) {
Slog.e(TAG, "Failed to bind to media container service");
params.serviceError();
return;
} else {
// Once we bind to the service, the first
// pending request will be processed.
mPendingInstalls.add(idx, params);
}
} else {
mPendingInstalls.add(idx, params);
// Already bound to the service. Just make
// sure we trigger off processing the first request.
if (idx == 0) {
mHandler.sendEmptyMessage(MCS_BOUND);
}
}
break;
}
/*---------省略---------*/
}

connectToService方法：
private boolean connectToService() {
if (DEBUG_SD_INSTALL) Log.i(TAG, "Trying to bind to" +
" DefaultContainerService");
Intent service = new Intent().setComponent(DEFAULT_CONTAINER_COMPONENT);
Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
/*
mDefContainerConn:
*/
if (mContext.bindService(service, mDefContainerConn,
Context.BIND_AUTO_CREATE)) {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
mBound = true;
return true;
}
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
return false;
}mDefContainerConn: DefaultContainerConnection,如果链接成功内部发送MCS_BOUND
final private DefaultContainerConnection mDefContainerConn =
new DefaultContainerConnection();
class DefaultContainerConnection implements ServiceConnection {
public void onServiceConnected(ComponentName name, IBinder service) {
if (DEBUG_SD_INSTALL) Log.i(TAG, "onServiceConnected");
IMediaContainerService imcs =
IMediaContainerService.Stub.asInterface(service);
/*
连接成功后，发送MCS_BOUND给mHandler
*/
mHandler.sendMessage(mHandler.obtainMessage(MCS_BOUND, imcs));
}

public void onServiceDisconnected(ComponentName name) {
if (DEBUG_SD_INSTALL) Log.i(TAG, "onServiceDisconnected");
}
};

2.MCS_BOUND
/*省略*/
case MCS_BOUND: {
if (DEBUG_INSTALL) Slog.i(TAG, "mcs_bound");
if (msg.obj != null) {
mContainerService = (IMediaContainerService) msg.obj;
}
if (mContainerService == null) {
//服务没启动，不能安装
// Something seriously wrong. Bail out
Slog.e(TAG, "Cannot bind to media container service");
for (HandlerParams params : mPendingInstalls) {
mPendingInstalls.remove(0);
// Indicate service bind error
params.serviceError();
}
mPendingInstalls.clear();
} else if (mPendingInstalls.size() > 0) {
HandlerParams params = mPendingInstalls.get(0);
if (params != null) {
if (params.startCopy()) {
// We are done... look for more work or to
// go idle.
if (DEBUG_SD_INSTALL) Log.i(TAG,
"Checking for more work or unbind...");
// Delete pending install
if (mPendingInstalls.size() > 0) {
/*
移除队头
*/
mPendingInstalls.remove(0);
}
if (mPendingInstalls.size() == 0) {
if (mBound) {
if (DEBUG_SD_INSTALL) Log.i(TAG,
"Posting delayed MCS_UNBIND");
/*
安装完成，与服务断开，通过发送MCS_UNBIND断开与Service
*/
removeMessages(MCS_UNBIND);
Message ubmsg = obtainMessage(MCS_UNBIND);
// Unbind after a little delay, to avoid
// continual thrashing.
sendMessageDelayed(ubmsg, 10000);
}
} else {
// There are more pending requests in queue.
// Just post MCS_BOUND message to trigger processing
// of next pending install.
if (DEBUG_SD_INSTALL) Log.i(TAG,
"Posting MCS_BOUND for next woek");
mHandler.sendEmptyMessage(MCS_BOUND);
}
}
}
} else {
// Should never happen ideally.
Slog.w(TAG, "Empty queue");
}
break;
}
/*省略*/1> 抽象类HandlerParams，及其子类：
InstallParams: 处理APK的安装;

MoveParams:处理APK用于处理某个已经安装的APK"搬家";

MeasureParams:用于查询某个已安装的APK占存储空间的大小;

2> 抽象类InstallArgs及其子类：

FileInstallArgs: 针对的是安装在内部存储的APK

SdInstallArgs: 针对的是安装在sd卡的APK

final boolean startCopy() {
boolean res;
try {
if (DEBUG_INSTALL) Slog.i(TAG, "startCopy");

if (++mRetries > MAX_RETRIES) {
Slog.w(TAG, "Failed to invoke remote methods on default container service. Giving up");
mHandler.sendEmptyMessage(MCS_GIVE_UP);
handleServiceError();
return false;
} else {
handleStartCopy();
res = true;
}
} catch (RemoteException e) {
if (DEBUG_INSTALL) Slog.i(TAG, "Posting install MCS_RECONNECT");
mHandler.sendEmptyMessage(MCS_RECONNECT);
res = false;
}
handleReturnCode();
return res;
}

public void handleStartCopy() throws RemoteException {
int ret = PackageManager.INSTALL_SUCCEEDED;
/*
根据adb install 的参数，判断安装位置
*/
final boolean fwdLocked = (flags & PackageManager.INSTALL_FORWARD_LOCK) != 0;
final boolean onSd = (flags & PackageManager.INSTALL_EXTERNAL) != 0;
final boolean onInt = (flags & PackageManager.INSTALL_INTERNAL) != 0;
PackageInfoLite pkgLite = null;

if (onInt && onSd) {
// Check if both bits are set.
/*
不能同时安装在内部存储和SD卡
*/
Slog.w(TAG, "Conflicting flags specified for installing on both internal and external");
ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
} else if (fwdLocked && onSd) {
// Check for forward locked apps
Slog.w(TAG, "Cannot install fwd locked apps on sdcard");
ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
} else {
final long lowThreshold;
/*
获取DeviceStorageMonitorService的binder客户端
*/
final DeviceStorageMonitorService dsm = (DeviceStorageMonitorService) ServiceManager
.getService(DeviceStorageMonitorService.SERVICE);
if (dsm == null) {
Log.w(TAG, "Couldn't get low memory threshold; no free limit imposed");
lowThreshold = 0L;
} else {
/*查询最小余量*/
lowThreshold = dsm.getMemoryLowThreshold();
}

// Remote call to find out default install location
try {
/*给DefaultContainerService URI读权限*/
mContext.grantUriPermission(DEFAULT_CONTAINER_PACKAGE, packageURI,
Intent.FLAG_GRANT_READ_URI_PERMISSION);
/*获取轻量级的PackageInfoLite对象*/
pkgLite = mContainerService.getMinimalPackageInfo(packageURI, flags,
lowThreshold);
} finally {
/*收回权限*/
mContext.revokeUriPermission(packageURI, Intent.FLAG_GRANT_READ_URI_PERMISSION);
}
/*推荐安装路径*/
int loc = pkgLite.recommendedInstallLocation;
if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_LOCATION) {
ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
} else if (loc == PackageHelper.RECOMMEND_FAILED_ALREADY_EXISTS) {
ret = PackageManager.INSTALL_FAILED_ALREADY_EXISTS;
} else if (loc == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
ret = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
} else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_APK) {
ret = PackageManager.INSTALL_FAILED_INVALID_APK;
} else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_URI) {
ret = PackageManager.INSTALL_FAILED_INVALID_URI;
} else if (loc == PackageHelper.RECOMMEND_MEDIA_UNAVAILABLE) {
ret = PackageManager.INSTALL_FAILED_MEDIA_UNAVAILABLE;
} else {
// Override with defaults if needed.
/*apk检查*/
loc = installLocationPolicy(pkgLite, flags);
if (!onSd && !onInt) {
// Override install location with flags
if (loc == PackageHelper.RECOMMEND_INSTALL_EXTERNAL) {
// Set the flag to install on external media.
flags |= PackageManager.INSTALL_EXTERNAL;
flags &= ~PackageManager.INSTALL_INTERNAL;
} else {
// Make sure the flag for installing on external
// media is unset
flags |= PackageManager.INSTALL_INTERNAL;
flags &= ~PackageManager.INSTALL_EXTERNAL;
}
}
}
}
/*创建一个安装参数对象，内部安装该对象实际为FileInstallArgs*/
final InstallArgs args = createInstallArgs(this);
mArgs = args;

if (ret == PackageManager.INSTALL_SUCCEEDED) {
/*
* Determine if we have any installed package verifiers. If we
* do, then we'll defer to them to verify the packages.
*/
final int requiredUid = mRequiredVerifierPackage == null ? -1
: getPackageUid(mRequiredVerifierPackage);
/*verification处理*/
if (requiredUid != -1 && isVerificationEnabled()) {
final Intent verification = new Intent(Intent.ACTION_PACKAGE_NEEDS_VERIFICATION);
verification.setDataAndType(packageURI, PACKAGE_MIME_TYPE);
verification.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);

final List<ResolveInfo> receivers = queryIntentReceivers(verification, null,
PackageManager.GET_DISABLED_COMPONENTS);

if (DEBUG_VERIFY) {
Slog.d(TAG, "Found " + receivers.size() + " verifiers for intent "
+ verification.toString() + " with " + pkgLite.verifiers.length
+ " optional verifiers");
}

final int verificationId = mPendingVerificationToken++;

verification.putExtra(PackageManager.EXTRA_VERIFICATION_ID, verificationId);

verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALLER_PACKAGE,
installerPackageName);

verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALL_FLAGS, flags);

if (verificationURI != null) {
verification.putExtra(PackageManager.EXTRA_VERIFICATION_URI,
verificationURI);
}

final PackageVerificationState verificationState = new PackageVerificationState(
requiredUid, args);

mPendingVerification.append(verificationId, verificationState);

final List<ComponentName> sufficientVerifiers = matchVerifiers(pkgLite,
receivers, verificationState);

/*
* If any sufficient verifiers were listed in the package
* manifest, attempt to ask them.
*/
if (sufficientVerifiers != null) {
final int N = sufficientVerifiers.size();
if (N == 0) {
Slog.i(TAG, "Additional verifiers required, but none installed.");
ret = PackageManager.INSTALL_FAILED_VERIFICATION_FAILURE;
} else {
for (int i = 0; i < N; i++) {
final ComponentName verifierComponent = sufficientVerifiers.get(i);

final Intent sufficientIntent = new Intent(verification);
sufficientIntent.setComponent(verifierComponent);

mContext.sendBroadcast(sufficientIntent);
}
}
}

final ComponentName requiredVerifierComponent = matchComponentForVerifier(
mRequiredVerifierPackage, receivers);
if (ret == PackageManager.INSTALL_SUCCEEDED
&& mRequiredVerifierPackage != null) {
/*
* Send the intent to the required verification agent,
* but only start the verification timeout after the
* target BroadcastReceivers have run.
*/
verification.setComponent(requiredVerifierComponent);
mContext.sendOrderedBroadcast(verification,
android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
final Message msg = mHandler
.obtainMessage(CHECK_PENDING_VERIFICATION);
msg.arg1 = verificationId;
mHandler.sendMessageDelayed(msg, getVerificationTimeout());
}
}, null, 0, null, null);

/*
* We don't want the copy to proceed until verification
* succeeds, so null out this field.
*/
mArgs = null;
}
} else {
/*
* No package verification is enabled, so immediately start
* the remote call to initiate copy using temporary file.
*/
/*调用FileInstallArgs的copyApk方法*/
ret = args.copyApk(mContainerService, true);
}
}

mRet = ret;
}

以上代码知识点：
1> 调用DefaultContainerService的getMinimalPackageInfo函数，得到一个PackageInfoLite对象，该对象是一个轻量级的用于描述APK的机构，这个不同于PackageLite,这两个中的成员非常相似，只是PackageInfoLite实现了Parcelable接口，因此，该类可通过binder在进程间通信,该函数中可以获得一个合理的recommandedInstallLocation的值,该值表示该APK推荐的安装路径;

2> 调用installLocationPolicy检查推荐安装路径。（系统Package不能安装在SD卡上）

3> createInstallArgs根据安装位置创建不同的InstallArgs，如果是内部安装，为FileInstallArgs对象，否则为SdInstallArgs对象

4> 正式安装前需要对APK进行必要的检查

5> 调用InstallArgs的copyAPK方法

<---待续--->