devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Framework篇 - APK 安装流程简介_awareframework-398.apk

作者：盐析白兔 | 2024-03-06 13:33:03

赞

踩

awareframework-398.apk

本文源代码基于 Android 7.0。 

在 Android 系统下，我们一般会使用 "adb install -r" 命令来安装应用，此时应用会被安装到 /data/app/ 下。这篇文章，我们就简要分析 PackageManagerService 安装 APK 的中间处理过程。

 

目录：

  1. 安装流程图
  2. adb 方式安装 APK
  3. PackageManager 安装 APK

 

 

1. 安装流程图

 

 

2. adb 方式安装 APK

在进入 PackageManager 之前，我们先看下有关 adb 安装应用的内容。在 Android 中，adbd 以后台进程运行 (init 进程解析 init.rc 生成的进程，Installer 中真正干活的进程)。

当我们输入 "adb install" 命令时，/system/core/adb/ 目录下 commandline.cpp 文件会被执行，其中 adb_commandline() 函数会接受该条指令，并进行处理，这里只看 install 命令的执行：

  1. else if (!strcmp(argv[0], "install")) {
  2.         if (argc < 2) return usage();
  3.         if (_use_legacy_install()) {
  4.             // 安装应用(legacy模式)
  5.             return install_app_legacy(transport_type, serial, argc, argv);
  6.         }
  7.         // 安装应用
  8.         return install_app(transport_type, serial, argc, argv);
  9.     }
  10.  
  11. ......
  12. }

这里以 legacy 模式为例：

  1. static int install_app_legacy(TransportType transport, const char* serial, int argc, const char** argv) {
  2.     static const char *const DATA_DEST = "/data/local/tmp/%s";// 安装到 data 目录下时,会将 apk 先拷贝一份到该目录下
  3.     static const char *const SD_DEST = "/sdcard/tmp/%s";//安装到 SD 卡上时，会将 apk 先拷贝一份到 /sdcard/tmp/ 目录下; 一般带参数 -s
  4.     const char* where = DATA_DEST;
  5.     int i;
  6.     struct stat sb;
  7.  
  8.     for (i = 1; i < argc; i++) {
  9.         if (!strcmp(argv[i], "-s")) {
  10.             where = SD_DEST;
  11.         }
  12.     }
  13.  
  14.     // Find last APK argument.
  15.     // All other arguments passed through verbatim.
  16.     int last_apk = -1;
  17.     for (i = argc - 1; i >= 0; i--) {
  18.         const char* file = argv[i];
  19.         const char* dot = strrchr(file, '.');
  20.         if (dot && !strcasecmp(dot, ".apk")) {
  21.             if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) {
  22.                 fprintf(stderr, "Invalid APK file: %s\n", file);
  23.                 return EXIT_FAILURE;
  24.             }
  25.  
  26.             last_apk = i;
  27.             break;
  28.         }
  29.     }
  30.  
  31.     if (last_apk == -1) {
  32.         fprintf(stderr, "Missing APK file\n");
  33.         return EXIT_FAILURE;
  34.     }
  35.  
  36.     int result = -1;
  37.     std::vector<const char*> apk_file = {argv[last_apk]};
  38.     std::string apk_dest = android::base::StringPrintf(
  39.         where, adb_basename(argv[last_apk]).c_str());
  40.     // 我们即将安装的 apk 文件也许会在客户机上, 这里会先将该apk文件推送到系统的 /data/local/tmp/目录下
  41.     if (!do_sync_push(apk_file, apk_dest.c_str())) goto cleanup_apk;
  42.     argv[last_apk] = apk_dest.c_str(); /* destination name, not source location */
  43.     // 执行 pm 脚本, 进行安装
  44.     result = pm_command(transport, serial, argc, argv);
  45.  
  46. cleanup_apk:
  47.     // 安装过程结束后,会清掉事先拷贝的那一份apk
  48.     delete_file(transport, serial, apk_dest);
  49.     return result;
  50. }

由于我们使用 adb 安装的 APK 有可能会在客户机上，所以这里会先将 APK 文件拷贝一份到系统的 /data/local/tmp/ 目录下。
然后流程会去执行 pm 脚本进行安装操作。手机的端的 adbd 程序接收到客户机发送的 shell pm 命令后，会开启一个 shell 去执行 pm 脚本。pm 脚本的内容如下：

  1. # Script to start "pm" on the device, which has a very rudimentary
  2. # shell.
  3. #
  4. base=/system
  5. export CLASSPATH=$base/framework/pm.jar
  6. exec app_process $base/bin com.android.commands.pm.Pm "$@"

该脚本在系统编译时会被打包成 /system/bin/pm 可执行程序，执行 pm 可执行程序其实就是执行这段脚本。

我们知道，app_process 在系统启动过程中会去启动 Zygote 系统进程。同时，它也可以被用来启动一些其他的普通进程，比如此时的 pm。我们直接看启动 pm 时调用的 main() 函数，com.android.commands.pm.Pm::main()：

  1.     public static void main(String[] args) {
  2.         int exitCode = 1;
  3.         try {
  4.             exitCode = new Pm().run(args);
  5.         } catch (Exception e) {
  6.             Log.e(TAG, "Error", e);
  7.             System.err.println("Error: " + e);
  8.             if (e instanceof RemoteException) {
  9.                 System.err.println(PM_NOT_RUNNING_ERR);
  10.             }
  11.         }
  12.         System.exit(exitCode);
  13.     }

创建 Pm 实例并调用它的 run() 方法：

  1. public int run(String[] args) throws RemoteException {
  2.         boolean validCommand = false;
  3.         if (args.length < 1) {
  4.             return showUsage();
  5.         }
  6.         mAm = IAccountManager.Stub.asInterface(ServiceManager.getService(Context.ACCOUNT_SERVICE));
  7.         mUm = IUserManager.Stub.asInterface(ServiceManager.getService(Context.USER_SERVICE));
  8.         // IPackageManager实例,通过它可以调用到PackageManagerServcie中，就是binder的客户端
  9.         mPm = IPackageManager.Stub.asInterface(ServiceManager.getService("package"));
  10.  
  11.         // IPackageManager实例为空,即返回
  12.         if (mPm == null) {
  13.             System.err.println(PM_NOT_RUNNING_ERR);
  14.             return 1;
  15.         }
  16.         // IPackageInstaller实例,它会管理android中的应用安装状态
  17.         mInstaller = mPm.getPackageInstaller();
  18.  
  19.         mArgs = args;
  20.         String op = args[0];
  21.         mNextArg = 1;
  22.  
  23.         if ("list".equals(op)) {
  24.             return runList();
  25.         }
  26.  
  27.         if ("path".equals(op)) {
  28.             return runPath();
  29.         }
  30.  
  31.         if ("dump".equals(op)) {
  32.             return runDump();
  33.         }
  34.  
  35.         if ("install".equals(op)) {
  36.             // 此处分析的是install命令,走这条分支
  37.             return runInstall();
  38.         }
  39. ......
  40. }

因为我们传入的是 install 命令，所以执行 runInstall() 函数；至此，安装过程就即将进入 PackageManagerService 了。同时我们也可以调用 PackageManager::installPackage() 函数安装应用，这种方式的安装与 adb install 的安装流程在进入PackageManagerService 之后，都是一样的。

 

 

3. PackageManager 安装 APK

PackageManager 的功能由 ApplicationPackageManager 实现，ApplicationPackageManager 内部持有一个指向PackageManagerService 的 mPM 对象来传递函数调用。当我们调用 PackageManager::installPackage() 时，实际调用ApplicationPackageManager 中的实现函数：

  1. @Override
  2.     public void installPackage(Uri packageURI, IPackageInstallObserver observer, int flags,
  3.                                String installerPackageName) {
  4.         installCommon(packageURI, new LegacyPackageInstallObserver(observer), flags,
  5.                 installerPackageName, mContext.getUserId());
  6.     }
  7.  
  8.     @Override
  9.     public void installPackage(Uri packageURI, PackageInstallObserver observer,
  10.             int flags, String installerPackageName) {
  11.         installCommon(packageURI, observer, flags, installerPackageName, mContext.getUserId());
  12.     }
  13.  
  14.     private void installCommon(Uri packageURI,
  15.             PackageInstallObserver observer, int flags, String installerPackageName,
  16.             int userId) {
  17.         if (!"file".equals(packageURI.getScheme())) {
  18.             throw new UnsupportedOperationException("Only file:// URIs are supported");
  19.         }
  20.  
  21.         final String originPath = packageURI.getPath();
  22.         try {
  23.             mPM.installPackageAsUser(originPath, observer.getBinder(), flags, installerPackageName,
  24.                     userId);
  25.         } catch (RemoteException e) {
  26.             throw e.rethrowFromSystemServer();
  27.         }
  28.     }

方法中传入了一个 PackageInstallObserver 对象，它是用户用来监听 APK 安装的最后结果的。PackageInstallObserver 的定义如下：

  1. public class PackageInstallObserver {
  2.     private final IPackageInstallObserver2.Stub mBinder = new IPackageInstallObserver2.Stub() {
  3.         @Override
  4.         public void onUserActionRequired(Intent intent) {
  5.             PackageInstallObserver.this.onUserActionRequired(intent);
  6.         }
  7.  
  8.         @Override
  9.         public void onPackageInstalled(String basePackageName, int returnCode,
  10.                 String msg, Bundle extras) {
  11.             PackageInstallObserver.this.onPackageInstalled(basePackageName, returnCode, msg,
  12.                     extras);
  13.         }
  14.     };
  15.  
  16.     /** {@hide} */
  17.     public IPackageInstallObserver2 getBinder() {
  18.         return mBinder;
  19.     }
  20.  
  21.     public void onUserActionRequired(Intent intent) {
  22.     }
  23.  
  24.     public void onPackageInstalled(String basePackageName, int returnCode, String msg,
  25.             Bundle extras) {
  26.     }
  27. }

其中，当 APK 安装结束时，系统会回调 onPackageInstalled() 接口通知用户当前 APK 安装的结果信息。

接着分析 APK 安装的流程，系统会调用 PKMS 的 installPackageAsUser() 接口，将安装流程带入到 PKMS 中：

  1.     @Override
  2.     public void installPackageAsUser(String originPath, IPackageInstallObserver2 observer,
  3.             int installFlags, String installerPackageName, int userId) {
  4.         mContext.enforceCallingOrSelfPermission(android.Manifest.permission.INSTALL_PACKAGES, null);
  5.  
  6.         final int callingUid = Binder.getCallingUid();
  7.         enforceCrossUserPermission(callingUid, userId,
  8.                 true /* requireFullPermission */, true /* checkShell */, "installPackageAsUser");//检查调用进程的权限
  9.  
  10.         if (isUserRestricted(userId, UserManager.DISALLOW_INSTALL_APPS)) {//检查指定的用户是否被限制安装应用
  11.             try {
  12.                 if (observer != null) {
  13.                     observer.onPackageInstalled("", INSTALL_FAILED_USER_RESTRICTED, null, null);
  14.                 }
  15.             } catch (RemoteException re) {
  16.             }
  17.             return;
  18.         }
  19.  
  20.         if ((callingUid == Process.SHELL_UID) || (callingUid == Process.ROOT_UID)) {
  21.             installFlags |= PackageManager.INSTALL_FROM_ADB;
  22.  
  23.         } else {
  24.             // Caller holds INSTALL_PACKAGES permission, so we're less strict
  25.             // about installerPackageName.
  26.  
  27.             installFlags &= ~PackageManager.INSTALL_FROM_ADB;
  28.             installFlags &= ~PackageManager.INSTALL_ALL_USERS;
  29.         }
  30.  
  31.         UserHandle user;
  32.         if ((installFlags & PackageManager.INSTALL_ALL_USERS) != 0) {//如果带有ISNASLL_ALL_USERS标记,则给所有用户安装
  33.             user = UserHandle.ALL;
  34.         } else {
  35.             user = new UserHandle(userId);
  36.         }
  37.  
  38.         // Only system components can circumvent runtime permissions when installing.
  39.         if ((installFlags & PackageManager.INSTALL_GRANT_RUNTIME_PERMISSIONS) != 0
  40.                 && mContext.checkCallingOrSelfPermission(Manifest.permission
  41.                 .INSTALL_GRANT_RUNTIME_PERMISSIONS) == PackageManager.PERMISSION_DENIED) {
  42.             throw new SecurityException("You need the "
  43.                     + "android.permission.INSTALL_GRANT_RUNTIME_PERMISSIONS permission "
  44.                     + "to use the PackageManager.INSTALL_GRANT_RUNTIME_PERMISSIONS flag");
  45.         }
  46.  
  47.         final File originFile = new File(originPath);
  48.         final OriginInfo origin = OriginInfo.fromUntrustedFile(originFile);
  49.  
  50.         final Message msg = mHandler.obtainMessage(INIT_COPY);//要发送INIT_COPY消息,开始拷贝需要安装的Apk
  51. 		
  52.         final VerificationInfo verificationInfo = new VerificationInfo(
  53.                 null /*originatingUri*/, null /*referrer*/, -1 /*originatingUid*/, callingUid);
  54.  
  55. 	     //将安装参数信息保存到InstallParams对象中
  56.         final InstallParams params = new InstallParams(origin, null /*moveInfo*/, observer,
  57.                 installFlags, installerPackageName, null /*volumeUuid*/, verificationInfo, user,
  58.                 null /*packageAbiOverride*/, null /*grantedPermissions*/,
  59.                 null /*certificates*/);
  60.         params.setTraceMethod("installAsUser").setTraceCookie(System.identityHashCode(params));
  61.         msg.obj = params;
  62.  
  63.         Trace.asyncTraceBegin(TRACE_TAG_PACKAGE_MANAGER, "installAsUser",
  64.                 System.identityHashCode(msg.obj));
  65.         Trace.asyncTraceBegin(TRACE_TAG_PACKAGE_MANAGER, "queueInstall",
  66.                 System.identityHashCode(msg.obj));
  67.  
  68.         mHandler.sendMessage(msg);//发送消息到PackageHandler中
  69.     }

首先是一些安装权限检查，之后会创建一个 InstallParams 实例，它里面封装了此次安装 APK 的各项参数。接着会发送INIT_COPY 消息到 Handler 进行处理。

这些类型的作用就是封装一次应用安装过程的一些基本信息，我们只要注意它们的使用场景即可。INIT_COPY 消息会触发 APK 文件的拷贝动作，它会由 PMS::PackageHandler 接收，而 PackageHandler 在 PkMS 初始化时会被创建。PackageHandler 主要负责这些 APK 安装消息的接收处理，我们先看 INIT_COPY 消息的处理过程：

  1.             case INIT_COPY: {
  2.                     HandlerParams params = (HandlerParams) msg.obj;//获取Apk安装参数
  3.                     int idx = mPendingInstalls.size();//mPendingInstalls保存所有的需要安装的APk的安装信息
  4.                     if (DEBUG_INSTALL) Slog.i(TAG, "init_copy idx=" + idx + ": " + params);
  5.                     // If a bind was already initiated we dont really
  6.                     // need to do anything. The pending install
  7.                     // will be processed later on.
  8.                     if (!mBound) {
  9.                        // 如果没有绑定DefaultContainerService服务;服务连接成功后,会置为true
  10.                         Trace.asyncTraceBegin(TRACE_TAG_PACKAGE_MANAGER, "bindingMCS",
  11.                                 System.identityHashCode(mHandler));
  12.                         // If this is the only one pending we might
  13.                         // have to bind to the service again.
  14.                         if (!connectToService()) {
  15.                             // 异步过程.去绑定DefaultContainerService服务,绑定失败,需要报告错误信息;绑定成功后,会发送MCS_BOUND消息
  16.                             Slog.e(TAG, "Failed to bind to media container service");
  17.                             params.serviceError();
  18.                             Trace.asyncTraceEnd(TRACE_TAG_PACKAGE_MANAGER, "bindingMCS",
  19.                                     System.identityHashCode(mHandler));
  20.                             if (params.traceMethod != null) {
  21.                                 Trace.asyncTraceEnd(TRACE_TAG_PACKAGE_MANAGER, params.traceMethod,
  22.                                         params.traceCookie);
  23.                             }
  24.                             return;
  25.                         } else {
  26.                             // 绑定服务成功后,将当前的安装参数请求保存到mPendingInstalls
  27.                             // Once we bind to the service, the first
  28.                             // pending request will be processed.
  29.                             mPendingInstalls.add(idx, params);
  30.                         }
  31.                     } else {
  32.                         mPendingInstalls.add(idx, params);
  33.                         // 服务已经绑定,也会将安装信息保存到mPendingInstalls中
  34.                         // Already bound to the service. Just make
  35.                         // sure we trigger off processing the first request.
  36.                         if (idx == 0) {//如果mPendingInstalls中只有一项内容,则立即发送MCS_BOUND消息
  37.                             mHandler.sendEmptyMessage(MCS_BOUND);
  38.                         }
  39.                     }
  40.                     break;
  41.                 }

mPendingInstalls 是 PackageHandler 的一个成员，它保存所有的 APK 安装的 InstallParams 对象。mBound 标识当前有没有绑定 DefaultContainerService 服务，之后的安装流程会调用它的一些方法。绑定 DCS 服务的处理由 PackageHandler::connectToService() 函数提供：

  1.     static final ComponentName DEFAULT_CONTAINER_COMPONENT = new ComponentName(
  2.             DEFAULT_CONTAINER_PACKAGE,
  3.             "com.android.defcontainer.DefaultContainerService");
  4.  
  5.     final private DefaultContainerConnection mDefContainerConn =
  6.             new DefaultContainerConnection();
  7.     class DefaultContainerConnection implements ServiceConnection {
  8.         public void onServiceConnected(ComponentName name, IBinder service) {
  9.             if (DEBUG_SD_INSTALL) Log.i(TAG, "onServiceConnected");
  10.             IMediaContainerService imcs =
  11.                 IMediaContainerService.Stub.asInterface(service);
  12.             mHandler.sendMessage(mHandler.obtainMessage(MCS_BOUND, imcs));
  13.         }
  14.  
  15.         public void onServiceDisconnected(ComponentName name) {
  16.             if (DEBUG_SD_INSTALL) Log.i(TAG, "onServiceDisconnected");
  17.         }
  18.     }
  19.  
  20.         private boolean connectToService() {
  21.             if (DEBUG_SD_INSTALL) Log.i(TAG, "Trying to bind to" +
  22.                     " DefaultContainerService");
  23.             Intent service = new Intent().setComponent(DEFAULT_CONTAINER_COMPONENT);
  24.             Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
  25.             if (mContext.bindServiceAsUser(service, mDefContainerConn,
  26.                     Context.BIND_AUTO_CREATE, UserHandle.SYSTEM)) {
  27.                 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
  28.                 mBound = true;
  29.                 return true;
  30.             }
  31.             Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
  32.             return false;
  33.         }

如果服务绑定成功，mBound 会置为 true，并会发送 MCS_BOUND 消息，并附带 DCS 服务的 Binder 实例发送给PackageHandler。接着看 MCS_BOUND 消息的处理：

  1.             case MCS_BOUND: {
  2.                     if (DEBUG_INSTALL) Slog.i(TAG, "mcs_bound");
  3.                     if (msg.obj != null) {
  4.                         mContainerService = (IMediaContainerService) msg.obj;//DefaultContainerService服务的代理
  5.                         Trace.asyncTraceEnd(TRACE_TAG_PACKAGE_MANAGER, "bindingMCS",
  6.                                 System.identityHashCode(mHandler));
  7.                     }
  8.                     if (mContainerService == null) {
  9.                         if (!mBound) {
  10.                             // 如果服务没有连接成功,则需要报告错误
  11.                             // Something seriously wrong since we are not bound and we are not
  12.                             // waiting for connection. Bail out.
  13.                             Slog.e(TAG, "Cannot bind to media container service");
  14.                             for (HandlerParams params : mPendingInstalls) {
  15.                                 // Indicate service bind error
  16.                                 params.serviceError();
  17.                                 Trace.asyncTraceEnd(TRACE_TAG_PACKAGE_MANAGER, "queueInstall",
  18.                                         System.identityHashCode(params));
  19.                                 if (params.traceMethod != null) {
  20.                                     Trace.asyncTraceEnd(TRACE_TAG_PACKAGE_MANAGER,
  21.                                             params.traceMethod, params.traceCookie);
  22.                                 }
  23.                                 return;
  24.                             }
  25.                             mPendingInstalls.clear();//情况mPendingInstalls
  26.                         } else {
  27.                             Slog.w(TAG, "Waiting to connect to media container service");
  28.                         }
  29.                     } else if (mPendingInstalls.size() > 0) {//DefaultContainerService服务连接正常
  30.                         HandlerParams params = mPendingInstalls.get(0);//从首部拿出需要执行的安装参数信息
  31.                         if (params != null) {
  32.                             Trace.asyncTraceEnd(TRACE_TAG_PACKAGE_MANAGER, "queueInstall",
  33.                                     System.identityHashCode(params));
  34.                             Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "startCopy");
  35.                             if (params.startCopy()) {
  36.                                 // 调用HandlerParrams接口,去执行apk的拷贝工作;此处是调用HandlerParrams::startCopy()
  37.                                 // We are done...  look for more work or to
  38.                                 // go idle.
  39.                                 if (DEBUG_SD_INSTALL) Log.i(TAG,
  40.                                         "Checking for more work or unbind...");
  41.                                 // Delete pending install
  42.                                 if (mPendingInstalls.size() > 0) {
  43.                                     //工作完成,移除mPendingInstalls首部内容,因为我们是从首部开始执行的
  44.                                     mPendingInstalls.remove(0);
  45.                                 }
  46.                                 if (mPendingInstalls.size() == 0) {
  47.                                     //如果mPendingInstalls已经没有内容,说明安装任务已经全部执行完毕,则会延迟10s后断开服务连接
  48.                                     if (mBound) {
  49.                                         if (DEBUG_SD_INSTALL) Log.i(TAG,
  50.                                                 "Posting delayed MCS_UNBIND");
  51.                                         removeMessages(MCS_UNBIND);
  52.                                         Message ubmsg = obtainMessage(MCS_UNBIND);
  53.                                         // Unbind after a little delay, to avoid
  54.                                         // continual thrashing.
  55.                                         sendMessageDelayed(ubmsg, 10000);
  56.                                     }
  57.                                 } else {//否则,会再次发送MCS_BOUND消息,处理下一个安装请求
  58.                                     // There are more pending requests in queue.
  59.                                     // Just post MCS_BOUND message to trigger processing
  60.                                     // of next pending install.
  61.                                     if (DEBUG_SD_INSTALL) Log.i(TAG,
  62.                                             "Posting MCS_BOUND for next work");
  63.                                     mHandler.sendEmptyMessage(MCS_BOUND);//发送消息,处理下一个安装请求
  64.                                 }
  65.                             }
  66.                             Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
  67.                         }
  68.                     } else {
  69.                         // Should never happen ideally.
  70.                         Slog.w(TAG, "Empty queue");
  71.                     }
  72.                     break;
  73.                 }

mContainerService 对象保存了 DefaultContainerService 服务的 Binder 实例，它将被用来调用一些该服务中提供的方法。
如果该实例为空，则表明服务连接异常，则需要对外报告错误，并清空 mPendingInstalls 集合；如果非空，则要处理 APK 的安装请求：

  • 从 mPendingInstalls 首部取出要处理的安装参数对象，并调用 InstallParams::startCopy() 函数，开始进行 APK 的拷贝工作。
  • 如果拷贝工作完成，则会移除 mPendingInstalls 首部的对象。
  • 如果此时 mPendingInstalls 队列为空，表明所有的请求已经处理完了；则会通过发送 MCS_UNBIND 消息，延迟10s去断开与DCS 服务的连接。
  • 如果此时 mPendingInstalls 队列不为空，表明当前还有安装请求需要处理，则会再次发送 MCS_BOUND 消息，进行新一轮的安装处理流程。

因为传入的安装参数对象是 InstallParams，我们直接看它父类的 HandlerParams::startCopy() 函数：

  1.         final boolean startCopy() {
  2.             boolean res;
  3.             try {
  4.                 if (DEBUG_INSTALL) Slog.i(TAG, "startCopy " + mUser + ": " + this);
  5.  
  6.                 if (++mRetries > MAX_RETRIES) {//会尝试安装4次,如果4次都没有安装成功,则会退出
  7.                     Slog.w(TAG, "Failed to invoke remote methods on default container service. Giving up");
  8.                     mHandler.sendEmptyMessage(MCS_GIVE_UP);//尝试4次后,都没有安装成功,则发送MCS_GIVE_UP消息放弃这次安装请求
  9.                     handleServiceError();
  10.                     return false;
  11.                 } else {
  12.                     handleStartCopy();
  13.                     res = true;
  14.                 }
  15.             } catch (RemoteException e) {
  16.                 if (DEBUG_INSTALL) Slog.i(TAG, "Posting install MCS_RECONNECT");
  17.                 mHandler.sendEmptyMessage(MCS_RECONNECT);//安装出错,则发送消息MCS_RECONNECT消息重新连接
  18.                 res = false;
  19.             }
  20.             handleReturnCode();
  21.             return res;
  22.         }

HandlerParams::startCopy() 为 HandlerParams 的子类所共有。首先一次 APK 的安装操作总共会尝试四次，如果四次都安装失败，则会发送 MCS_GIVE_UP 消息，放弃这次安装请求，并调用子类实现的 handleServiceError() 处理错误，然后直接返回；
否则，调用子类实现的 handleStartCopy() 函数进程 copy 流程。handleStartCopy() 处理成功后，还会调用子类实现的handleReturnCode() 处理最后的结果。我们看 InstallParams::handleStartCopy() 的实现：

  1. public void handleStartCopy() throws RemoteException {
  2.             int ret = PackageManager.INSTALL_SUCCEEDED;
  3.  
  4.             // If we're already staged, we've firmly committed to an install location
  5.             if (origin.staged) {
  6.                 if (origin.file != null) {
  7.                     installFlags |= PackageManager.INSTALL_INTERNAL;
  8.                     installFlags &= ~PackageManager.INSTALL_EXTERNAL;
  9.                 } else if (origin.cid != null) {
  10.                     installFlags |= PackageManager.INSTALL_EXTERNAL;
  11.                     installFlags &= ~PackageManager.INSTALL_INTERNAL;
  12.                 } else {
  13.                     throw new IllegalStateException("Invalid stage location");
  14.                 }
  15.             }
  16.  
  17.             final boolean onSd = (installFlags & PackageManager.INSTALL_EXTERNAL) != 0;
  18.             final boolean onInt = (installFlags & PackageManager.INSTALL_INTERNAL) != 0;
  19.             final boolean ephemeral = (installFlags & PackageManager.INSTALL_EPHEMERAL) != 0;
  20.             PackageInfoLite pkgLite = null;
  21.  
  22.             if (onInt && onSd) {//如果既有安装在内部的标志,又有安装SD卡上的标志,则设置错误返回 
  23.                 // Check if both bits are set.
  24.                 Slog.w(TAG, "Conflicting flags specified for installing on both internal and external");
  25.                 ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
  26.             } else if (onSd && ephemeral) {//此处与上述类似
  27.                 Slog.w(TAG,  "Conflicting flags specified for installing ephemeral on external");
  28.                 ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
  29.             } else {
  30.                 pkgLite = mContainerService.getMinimalPackageInfo(origin.resolvedPath, installFlags,
  31.                         packageAbiOverride);//获取安装包包含有应用信息的PacageInfoLite对象
  32.  
  33.                 if (DEBUG_EPHEMERAL && ephemeral) {
  34.                     Slog.v(TAG, "pkgLite for install: " + pkgLite);
  35.                 }
  36.  
  37.                 /*
  38.                  * If we have too little free space, try to free cache
  39.                  * before giving up.
  40.                  */
  41.                  //如果安装的位置空间不够,会先尝试清除cache空间
  42.                 if (!origin.staged && pkgLite.recommendedInstallLocation
  43.                         == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
  44.                     // TODO: focus freeing disk space on the target device
  45.                     final StorageManager storage = StorageManager.from(mContext);
  46.                     final long lowThreshold = storage.getStorageLowBytes(
  47.                             Environment.getDataDirectory());
  48.  
  49.                     final long sizeBytes = mContainerService.calculateInstalledSize(
  50.                             origin.resolvedPath, isForwardLocked(), packageAbiOverride);
  51.  
  52.                     try {
  53.                         mInstaller.freeCache(null, sizeBytes + lowThreshold);
  54.                         pkgLite = mContainerService.getMinimalPackageInfo(origin.resolvedPath,
  55.                                 installFlags, packageAbiOverride);
  56.                     } catch (InstallerException e) {
  57.                         Slog.w(TAG, "Failed to free cache", e);
  58.                     }
  59.  
  60.                     /*
  61.                      * The cache free must have deleted the file we
  62.                      * downloaded to install.
  63.                      *
  64.                      * TODO: fix the "freeCache" call to not delete
  65.                      *       the file we care about.
  66.                      */
  67.                     if (pkgLite.recommendedInstallLocation
  68.                             == PackageHelper.RECOMMEND_FAILED_INVALID_URI) {
  69.                         pkgLite.recommendedInstallLocation
  70.                             = PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE;
  71.                     }
  72.                 }
  73.             }
  74.  
  75.             if (ret == PackageManager.INSTALL_SUCCEEDED) {//如果该标志位依然是INSTALL_SUCCEEDED,则说明前面的校验都通过
  76.                 int loc = pkgLite.recommendedInstallLocation;
  77.                 if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_LOCATION) {
  78.                     ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
  79.                 } else if (loc == PackageHelper.RECOMMEND_FAILED_ALREADY_EXISTS) {
  80.                     ret = PackageManager.INSTALL_FAILED_ALREADY_EXISTS;
  81.                 } else if (loc == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
  82.                     ret = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
  83.                 } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_APK) {
  84.                     ret = PackageManager.INSTALL_FAILED_INVALID_APK;
  85.                 } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_URI) {
  86.                     ret = PackageManager.INSTALL_FAILED_INVALID_URI;
  87.                 } else if (loc == PackageHelper.RECOMMEND_MEDIA_UNAVAILABLE) {
  88.                     ret = PackageManager.INSTALL_FAILED_MEDIA_UNAVAILABLE;
  89.                 } else {
  90.                     // Override with defaults if needed.
  91.                     loc = installLocationPolicy(pkgLite);
  92.                     if (loc == PackageHelper.RECOMMEND_FAILED_VERSION_DOWNGRADE) {
  93.                         ret = PackageManager.INSTALL_FAILED_VERSION_DOWNGRADE;
  94.                     } else if (!onSd && !onInt) {
  95.                         // Override install location with flags
  96.                         if (loc == PackageHelper.RECOMMEND_INSTALL_EXTERNAL) {
  97.                             // Set the flag to install on external media.
  98.                             installFlags |= PackageManager.INSTALL_EXTERNAL;
  99.                             installFlags &= ~PackageManager.INSTALL_INTERNAL;
  100.                         } else if (loc == PackageHelper.RECOMMEND_INSTALL_EPHEMERAL) {
  101.                             if (DEBUG_EPHEMERAL) {
  102.                                 Slog.v(TAG, "...setting INSTALL_EPHEMERAL install flag");
  103.                             }
  104.                             installFlags |= PackageManager.INSTALL_EPHEMERAL;
  105.                             installFlags &= ~(PackageManager.INSTALL_EXTERNAL
  106.                                     |PackageManager.INSTALL_INTERNAL);
  107.                         } else {
  108.                             // Make sure the flag for installing on external
  109.                             // media is unset
  110.                             installFlags |= PackageManager.INSTALL_INTERNAL;
  111.                             installFlags &= ~PackageManager.INSTALL_EXTERNAL;
  112.                         }
  113.                     }
  114.                 }
  115.             }
  116.  
  117.             final InstallArgs args = createInstallArgs(this);//函数中会有分支处理,这里考虑FileInstallArgs实例创建情况,并会保存一份到InstallParams::mArgs
  118.             mArgs = args;
  119.  
  120.             if (ret == PackageManager.INSTALL_SUCCEEDED) {//如果该标志位依然是INSTALL_SUCCEEDED,则说明前面的校验都通过
  121.                 // TODO: http://b/22976637
  122.                 // Apps installed for "all" users use the device owner to verify the app
  123.                 UserHandle verifierUser = getUser();
  124.                 if (verifierUser == UserHandle.ALL) {
  125.                     verifierUser = UserHandle.SYSTEM;
  126.                 }
  127.  
  128.                 /*
  129.                  * Determine if we have any installed package verifiers. If we
  130.                  * do, then we'll defer to them to verify the packages.
  131.                  */
  132.                 final int requiredUid = mRequiredVerifierPackage == null ? -1
  133.                         : getPackageUid(mRequiredVerifierPackage, MATCH_DEBUG_TRIAGED_MISSING,
  134.                                 verifierUser.getIdentifier());
  135. 				//if部分是一段执行应用校验的代码,如果需要校验,则通过向系统中所有带有校验功能的组件发送Intent.ACTION_PACKAGE_NEEDS_VERIFICATION广播来完成
  136.                 if (!origin.existing && requiredUid != -1
  137.                         && isVerificationEnabled(verifierUser.getIdentifier(), installFlags)) {
  138.                     final Intent verification = new Intent(
  139.                             Intent.ACTION_PACKAGE_NEEDS_VERIFICATION);
  140.                     verification.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
  141.                     verification.setDataAndType(Uri.fromFile(new File(origin.resolvedPath)),
  142.                             PACKAGE_MIME_TYPE);
  143.                     verification.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
  144.  
  145.                     // Query all live verifiers based on current user state
  146.                     final List<ResolveInfo> receivers = queryIntentReceiversInternal(verification,
  147.                             PACKAGE_MIME_TYPE, 0, verifierUser.getIdentifier());
  148.  
  149.                     if (DEBUG_VERIFY) {
  150.                         Slog.d(TAG, "Found " + receivers.size() + " verifiers for intent "
  151.                                 + verification.toString() + " with " + pkgLite.verifiers.length
  152.                                 + " optional verifiers");
  153.                     }
  154.  
  155.                     final int verificationId = mPendingVerificationToken++;
  156.  
  157.                     verification.putExtra(PackageManager.EXTRA_VERIFICATION_ID, verificationId);
  158.  
  159.                     verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALLER_PACKAGE,
  160.                             installerPackageName);
  161.  
  162.                     verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALL_FLAGS,
  163.                             installFlags);
  164.  
  165.                     verification.putExtra(PackageManager.EXTRA_VERIFICATION_PACKAGE_NAME,
  166.                             pkgLite.packageName);
  167.  
  168.                     verification.putExtra(PackageManager.EXTRA_VERIFICATION_VERSION_CODE,
  169.                             pkgLite.versionCode);
  170.  
  171.                     if (verificationInfo != null) {
  172.                         if (verificationInfo.originatingUri != null) {
  173.                             verification.putExtra(Intent.EXTRA_ORIGINATING_URI,
  174.                                     verificationInfo.originatingUri);
  175.                         }
  176.                         if (verificationInfo.referrer != null) {
  177.                             verification.putExtra(Intent.EXTRA_REFERRER,
  178.                                     verificationInfo.referrer);
  179.                         }
  180.                         if (verificationInfo.originatingUid >= 0) {
  181.                             verification.putExtra(Intent.EXTRA_ORIGINATING_UID,
  182.                                     verificationInfo.originatingUid);
  183.                         }
  184.                         if (verificationInfo.installerUid >= 0) {
  185.                             verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALLER_UID,
  186.                                     verificationInfo.installerUid);
  187.                         }
  188.                     }
  189.  
  190.                     final PackageVerificationState verificationState = new PackageVerificationState(
  191.                             requiredUid, args);
  192.  
  193.                     mPendingVerification.append(verificationId, verificationState);
  194.  
  195.                     final List<ComponentName> sufficientVerifiers = matchVerifiers(pkgLite,
  196.                             receivers, verificationState);
  197.  
  198.                     /*
  199.                      * If any sufficient verifiers were listed in the package
  200.                      * manifest, attempt to ask them.
  201.                      */
  202.                     if (sufficientVerifiers != null) {
  203.                         final int N = sufficientVerifiers.size();
  204.                         if (N == 0) {
  205.                             Slog.i(TAG, "Additional verifiers required, but none installed.");
  206.                             ret = PackageManager.INSTALL_FAILED_VERIFICATION_FAILURE;
  207.                         } else {
  208.                             for (int i = 0; i < N; i++) {
  209.                                 final ComponentName verifierComponent = sufficientVerifiers.get(i);
  210.  
  211.                                 final Intent sufficientIntent = new Intent(verification);
  212.                                 sufficientIntent.setComponent(verifierComponent);
  213.                                 mContext.sendBroadcastAsUser(sufficientIntent, verifierUser);
  214.                             }
  215.                         }
  216.                     }
  217.  
  218.                     final ComponentName requiredVerifierComponent = matchComponentForVerifier(
  219.                             mRequiredVerifierPackage, receivers);
  220.                     if (ret == PackageManager.INSTALL_SUCCEEDED
  221.                             && mRequiredVerifierPackage != null) {
  222.                         Trace.asyncTraceBegin(
  223.                                 TRACE_TAG_PACKAGE_MANAGER, "verification", verificationId);
  224.                         /*
  225.                          * Send the intent to the required verification agent,
  226.                          * but only start the verification timeout after the
  227.                          * target BroadcastReceivers have run.
  228.                          */
  229.                         verification.setComponent(requiredVerifierComponent);
  230.                         mContext.sendOrderedBroadcastAsUser(verification, verifierUser,
  231.                                 android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
  232.                                 new BroadcastReceiver() {
  233.                                     @Override
  234.                                     public void onReceive(Context context, Intent intent) {
  235.                                         final Message msg = mHandler
  236.                                                 .obtainMessage(CHECK_PENDING_VERIFICATION);
  237.                                         msg.arg1 = verificationId;
  238.                                         mHandler.sendMessageDelayed(msg, getVerificationTimeout());
  239.                                     }
  240.                                 }, null, 0, null, null);
  241.  
  242.                         /*
  243.                          * We don't want the copy to proceed until verification
  244.                          * succeeds, so null out this field.
  245.                          */
  246.                         mArgs = null;
  247.                     }
  248.                 } else {//不需要校验,则调用FileInstallArgs::copyApk()继续后续的处理
  249.                     /*
  250.                      * No package verification is enabled, so immediately start
  251.                      * the remote call to initiate copy using temporary file.
  252.                      */
  253.                     ret = args.copyApk(mContainerService, true);
  254.                 }
  255.             }
  256.  
  257.             mRet = ret;
  258.         }

这里总结下这段代码处理：

  • 首先会进行一些安装标志的判断。
  • 调用 DCS::getMinimalPackageInfo() 方法获取该 APK 安装需要的大小及其他信息，信息会封装到 PackageInfoLite 对象中。
  • 如果检测到当前的目录下的大小不足以安装应用，还回去进行 cache 的清理工作。
  • 随后会以当前的 InstallParams 实例，创建 FileInstallArgs 对象，并保存一份到 InstallParams 对象的 mArgs 字段中。
  • 后续是一段组件校验工作。
  • 最后 FileInstallArgs::copyApk() 函数，进行下一步处理。

接着看 FileInstallArgs::copyApk() 函数：

  1.         private int doCopyApk(IMediaContainerService imcs, boolean temp) throws RemoteException {
  2.             if (origin.staged) {
  3.                 if (DEBUG_INSTALL) Slog.d(TAG, origin.file + " already staged; skipping copy");
  4.                 codeFile = origin.file;
  5.                 resourceFile = origin.file;
  6.                 return PackageManager.INSTALL_SUCCEEDED;
  7.             }
  8.  
  9.             try {
  10.                 final boolean isEphemeral = (installFlags & PackageManager.INSTALL_EPHEMERAL) != 0;
  11.                 final File tempDir =
  12.                         mInstallerService.allocateStageDirLegacy(volumeUuid, isEphemeral);//通过PackageInstallService在/data/app/下生成临时文件
  13.                 codeFile = tempDir;
  14.                 resourceFile = tempDir;
  15.             } catch (IOException e) {
  16.                 Slog.w(TAG, "Failed to create copy file: " + e);
  17.                 return PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
  18.             }
  19.  
  20. 			
  21. 			//为临时文件目录创建ParcelFileDescriptor描述符,它能在Binder间传递
  22.             final IParcelFileDescriptorFactory target = new IParcelFileDescriptorFactory.Stub() {
  23.                 @Override
  24.                 public ParcelFileDescriptor open(String name, int mode) throws RemoteException {
  25.                     if (!FileUtils.isValidExtFilename(name)) {
  26.                         throw new IllegalArgumentException("Invalid filename: " + name);
  27.                     }
  28.                     try {
  29.                         final File file = new File(codeFile, name);
  30.                         final FileDescriptor fd = Os.open(file.getAbsolutePath(),
  31.                                 O_RDWR | O_CREAT, 0644);
  32.                         Os.chmod(file.getAbsolutePath(), 0644);
  33.                         return new ParcelFileDescriptor(fd);
  34.                     } catch (ErrnoException e) {
  35.                         throw new RemoteException("Failed to open: " + e.getMessage());
  36.                     }
  37.                 }
  38.             };
  39.  
  40.             int ret = PackageManager.INSTALL_SUCCEEDED;
  41.  
  42. 			//使用DefaultContainerService::copyPackage()方法执行apk文件的复制
  43.             ret = imcs.copyPackage(origin.file.getAbsolutePath(), target);
  44.             if (ret != PackageManager.INSTALL_SUCCEEDED) {
  45.                 Slog.e(TAG, "Failed to copy package");
  46.                 return ret;
  47.             }
  48.  
  49. 			//安装应用中存在的native动态库,主要是从Apk打包文件中将它们提取出来放置
  50.             final File libraryRoot = new File(codeFile, LIB_DIR_NAME);
  51.             NativeLibraryHelper.Handle handle = null;
  52.             try {
  53.                 handle = NativeLibraryHelper.Handle.create(codeFile);
  54.                 ret = NativeLibraryHelper.copyNativeBinariesWithOverride(handle, libraryRoot,
  55.                         abiOverride);
  56.             } catch (IOException e) {
  57.                 Slog.e(TAG, "Copying native libraries failed", e);
  58.                 ret = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
  59.             } finally {
  60.                 IoUtils.closeQuietly(handle);
  61.             }
  62.  
  63.             return ret;
  64.         }

这里的处理有如下几个：

  • 通过 PackageInstallService 为要安装的 APK 在 /data/app/ 下生成一个零时文件 tempDir，它的命名并不以 .apk 结尾。
  • 为该 tempDir 创建 IParcelFileDescriptorFactory 文件描述符，它可以在进程间传递。
  • 调用 DefaultContainerService::copyPackage() 方法执行 APK 临时文件的复制。
  • 最后再将 APK 中包含的一些库文件提取出来，放置到对应的 lib/ 目录下。
  1.     @Deprecated
  2.     public File allocateStageDirLegacy(String volumeUuid, boolean isEphemeral) throws IOException {
  3.         synchronized (mSessions) {
  4.             try {
  5.                 final int sessionId = allocateSessionIdLocked();
  6.                 mLegacySessions.put(sessionId, true);
  7.                 final File stageDir = buildStageDir(volumeUuid, sessionId, isEphemeral);
  8.                 prepareStageDir(stageDir);
  9.                 return stageDir;
  10.             } catch (IllegalStateException e) {
  11.                 throw new IOException(e);
  12.             }
  13.         }
  14.     }
  15.  
  16.     private File buildStageDir(String volumeUuid, int sessionId, boolean isEphemeral) {
  17.         final File stagingDir = buildStagingDir(volumeUuid, isEphemeral);
  18.         return new File(stagingDir, "vmdl" + sessionId + ".tmp");
  19.     }

临时文件的名称格式大致是：'vmdl-随机数.tmp' 的形式。如果一切过程都正常，至此，APK 安装的第一部分的工作：APK 文件的拷贝，就结束了。根据前面的流程，最后会调用 InstallParams::handleReturnCode() 执行返回结果的处理：

  1.         @Override
  2.         void handleReturnCode() {
  3.             // If mArgs is null, then MCS couldn't be reached. When it
  4.             // reconnects, it will try again to install. At that point, this
  5.             // will succeed.
  6.             if (mArgs != null) {
  7.                 processPendingInstall(mArgs, mRet);
  8.             }
  9.         }

因为 InstallParams::mArgs 我们之前赋值过，所以肯定不为空，继续调用 processPendingInstall() 函数：

  1.     private void processPendingInstall(final InstallArgs args, final int currentStatus) {
  2.         // Queue up an async operation since the package installation may take a little while.
  3.         mHandler.post(new Runnable() {
  4.             public void run() {
  5.                 mHandler.removeCallbacks(this);//消息移除,防止此处被重复调用
  6.                  // Result object to be returned
  7.                 PackageInstalledInfo res = new PackageInstalledInfo();
  8.                 res.setReturnCode(currentStatus);
  9.                 res.uid = -1;
  10.                 res.pkg = null;
  11.                 res.removedInfo = null;
  12.                 if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {//如果之前的处理顺利完成
  13.                     args.doPreInstall(res.returnCode);
  14.                     synchronized (mInstallLock) {
  15.                         installPackageTracedLI(args, res);//则需要去解析、装载应用
  16.                     }
  17.                     args.doPostInstall(res.returnCode, res.uid);
  18.                 }
  19.  
  20.                 // A restore should be performed at this point if (a) the install
  21.                 // succeeded, (b) the operation is not an update, and (c) the new
  22.                 // package has not opted out of backup participation.
  23.                 //后面一段都在执行备份操作
  24.                 final boolean update = res.removedInfo != null
  25.                         && res.removedInfo.removedPackage != null;
  26.                 final int flags = (res.pkg == null) ? 0 : res.pkg.applicationInfo.flags;
  27.                 boolean doRestore = !update
  28.                         && ((flags & ApplicationInfo.FLAG_ALLOW_BACKUP) != 0);
  29.  
  30.                 // Set up the post-install work request bookkeeping.  This will be used
  31.                 // and cleaned up by the post-install event handling regardless of whether
  32.                 // there's a restore pass performed.  Token values are >= 1.
  33.                 int token;
  34.                 if (mNextInstallToken < 0) mNextInstallToken = 1;
  35.                 token = mNextInstallToken++;
  36.  
  37.                 PostInstallData data = new PostInstallData(args, res);
  38.                 mRunningInstalls.put(token, data);
  39.                 if (DEBUG_INSTALL) Log.v(TAG, "+ starting restore round-trip " + token);
  40.  
  41.                 if (res.returnCode == PackageManager.INSTALL_SUCCEEDED && doRestore) {
  42.                     // Pass responsibility to the Backup Manager.  It will perform a
  43.                     // restore if appropriate, then pass responsibility back to the
  44.                     // Package Manager to run the post-install observer callbacks
  45.                     // and broadcasts.
  46.                     IBackupManager bm = IBackupManager.Stub.asInterface(
  47.                             ServiceManager.getService(Context.BACKUP_SERVICE));
  48.                     if (bm != null) {
  49.                         if (DEBUG_INSTALL) Log.v(TAG, "token " + token
  50.                                 + " to BM for possible restore");
  51.                         Trace.asyncTraceBegin(TRACE_TAG_PACKAGE_MANAGER, "restore", token);
  52.                         try {
  53.                             // TODO: http://b/22388012
  54.                             if (bm.isBackupServiceActive(UserHandle.USER_SYSTEM)) {
  55.                                 bm.restoreAtInstall(res.pkg.applicationInfo.packageName, token);
  56.                             } else {
  57.                                 doRestore = false;
  58.                             }
  59.                         } catch (RemoteException e) {
  60.                             // can't happen; the backup manager is local
  61.                         } catch (Exception e) {
  62.                             Slog.e(TAG, "Exception trying to enqueue restore", e);
  63.                             doRestore = false;
  64.                         }
  65.                     } else {
  66.                         Slog.e(TAG, "Backup Manager not found!");
  67.                         doRestore = false;
  68.                     }
  69.                 }
  70.  
  71.                 if (!doRestore) {//直接去处理安装请求
  72.                     // No restore possible, or the Backup Manager was mysteriously not
  73.                     // available -- just fire the post-install work request directly.
  74.                     if (DEBUG_INSTALL) Log.v(TAG, "No restore - queue post-install for " + token);
  75.  
  76.                     Trace.asyncTraceBegin(TRACE_TAG_PACKAGE_MANAGER, "postInstall", token);
  77.  
  78.                     Message msg = mHandler.obtainMessage(POST_INSTALL, token, 0);//此处发送POST_INSTALL消息,继续处理流程
  79.                     mHandler.sendMessage(msg);
  80.                 }
  81.             }
  82.         });
  83.     }

函数内会调用 FileInstallArgs 的 doPreInstall()/doPostInstall() 函数进行一些清理工作。其中 PMS::installPackageTracedLI() 函数的主要功能就是将当前安装的 APK 加入到它的管理体系中，以便之后统一管理；特殊的，该函数内部会调用 FileInstallArgs::doReanme() 函数将之前的 APK 备份文件重命名。具体的实现是扫描 APK 的过程，这部分之前已经有介绍过。

略去之后的备份工作后，最后会发送 POST_INSTALL 消息，依旧是 PackageHandler 处理：

  1.             case POST_INSTALL: {//应用安装的收尾处理:主要动作是发送广播,通知系统中其他应用,开始某些处理工作:如果Launcher添加应用图标等
  2.                     if (DEBUG_INSTALL) Log.v(TAG, "Handling post-install for " + msg.arg1);
  3.  
  4.                     PostInstallData data = mRunningInstalls.get(msg.arg1);
  5.                     final boolean didRestore = (msg.arg2 != 0);
  6.                     mRunningInstalls.delete(msg.arg1);
  7.  
  8.                     if (data != null) {
  9.                         InstallArgs args = data.args;
  10.                         PackageInstalledInfo parentRes = data.res;
  11.  
  12.                         final boolean grantPermissions = (args.installFlags
  13.                                 & PackageManager.INSTALL_GRANT_RUNTIME_PERMISSIONS) != 0;
  14.                         final boolean killApp = (args.installFlags
  15.                                 & PackageManager.INSTALL_DONT_KILL_APP) == 0;
  16.                         final String[] grantedPermissions = args.installGrantPermissions;
  17.  
  18.                         // Handle the parent package
  19.                         handlePackagePostInstall(parentRes, grantPermissions, killApp,
  20.                                 grantedPermissions, didRestore, args.installerPackageName,
  21.                                 args.observer);//各种广播的发送处理
  22.  
  23.                         // Handle the child packages
  24.                         final int childCount = (parentRes.addedChildPackages != null)
  25.                                 ? parentRes.addedChildPackages.size() : 0;
  26.                         for (int i = 0; i < childCount; i++) {
  27.                             PackageInstalledInfo childRes = parentRes.addedChildPackages.valueAt(i);
  28.                             handlePackagePostInstall(childRes, grantPermissions, killApp,
  29.                                     grantedPermissions, false, args.installerPackageName,
  30.                                     args.observer);
  31.                         }
  32.  
  33.                         // Log tracing if needed
  34.                         if (args.traceMethod != null) {
  35.                             Trace.asyncTraceEnd(TRACE_TAG_PACKAGE_MANAGER, args.traceMethod,
  36.                                     args.traceCookie);
  37.                         }
  38.                     } else {
  39.                         Slog.e(TAG, "Bogus post-install token " + msg.arg1);
  40.                     }
  41.  
  42.                     Trace.asyncTraceEnd(TRACE_TAG_PACKAGE_MANAGER, "postInstall", msg.arg1);
  43.                 } break;

由于需要安装的 APK 文件已经拷贝到了系统中，并且 PKMS 也已经对它进行了统一管理，到此 APK 的安装工作就基本完成了。
但是，此时系统其它组件并不知道此时有新的 APK 安装进了系统中，所以这里需要发送一些广播给感兴趣的接收者，通知它们当前有新的 APK 安装完成了。这一部分最明显的就是 Launcher 了，我们安装 APK 后，Launcher 上要添加图标，就是根据这部分内容来的。发送广播的主要函数是 handlePackagePostInstall()，它的实现如下：

    1.         private void handlePackagePostInstall(PackageInstalledInfo res, boolean grantPermissions,
    2.             boolean killApp, String[] grantedPermissions,
    3.             boolean launchedForRestore, String installerPackage,
    4.             IPackageInstallObserver2 installObserver) {
    5.         if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
    6.             // Send the removed broadcasts
    7.             if (res.removedInfo != null) {
    8.                 res.removedInfo.sendPackageRemovedBroadcasts(killApp);
    9.             }
    10.  
    11.             // Now that we successfully installed the package, grant runtime
    12.             // permissions if requested before broadcasting the install.
    13.             if (grantPermissions && res.pkg.applicationInfo.targetSdkVersion
    14.                     >= Build.VERSION_CODES.M) {
    15.                 grantRequestedRuntimePermissions(res.pkg, res.newUsers, grantedPermissions);
    16.             }
    17.  
    18.             final boolean update = res.removedInfo != null
    19.                     && res.removedInfo.removedPackage != null;
    20.  
    21.             // If this is the first time we have child packages for a disabled privileged
    22.             // app that had no children, we grant requested runtime permissions to the new
    23.             // children if the parent on the system image had them already granted.
    24.             if (res.pkg.parentPackage != null) {
    25.                 synchronized (mPackages) {
    26.                     grantRuntimePermissionsGrantedToDisabledPrivSysPackageParentLPw(res.pkg);
    27.                 }
    28.             }
    29.  
    30.             synchronized (mPackages) {
    31.                 mEphemeralApplicationRegistry.onPackageInstalledLPw(res.pkg);
    32.             }
    33.  
    34.             final String packageName = res.pkg.applicationInfo.packageName;
    35.             Bundle extras = new Bundle(1);
    36.             extras.putInt(Intent.EXTRA_UID, res.uid);
    37.  
    38.             int[] firstUsers = EMPTY_INT_ARRAY;
    39.             int[] updateUsers = EMPTY_INT_ARRAY;
    40.             if (res.origUsers == null || res.origUsers.length == 0) {
    41.                 firstUsers = res.newUsers;
    42.             } else {
    43.                 for (int newUser : res.newUsers) {
    44.                     boolean isNew = true;
    45.                     for (int origUser : res.origUsers) {
    46.                         if (origUser == newUser) {
    47.                             isNew = false;
    48.                             break;
    49.                         }
    50.                     }
    51.                     if (isNew) {
    52.                         firstUsers = ArrayUtils.appendInt(firstUsers, newUser);
    53.                     } else {
    54.                         updateUsers = ArrayUtils.appendInt(updateUsers, newUser);
    55.                     }
    56.                 }
    57.             }
    58.  
    59.             // Send installed broadcasts if the install/update is not ephemeral
    60.             if (!isEphemeral(res.pkg)) {
    61.                 mProcessLoggingHandler.invalidateProcessLoggingBaseApkHash(res.pkg.baseCodePath);
    62.  
    63.                 // Send added for users that see the package for the first time
    64.                 sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED, packageName,
    65.                         extras, 0 /*flags*/, null /*targetPackage*/,
    66.                         null /*finishedReceiver*/, firstUsers);//首先要发送Intent.ACTION_PACKAGE_ADDED广播,表明系统中有新的apk被安装了
    67.  
    68.                 // Send added for users that don't see the package for the first time
    69.                 if (update) {
    70.                     extras.putBoolean(Intent.EXTRA_REPLACING, true);
    71.                 }
    72.                 sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED, packageName,
    73.                         extras, 0 /*flags*/, null /*targetPackage*/,
    74.                         null /*finishedReceiver*/, updateUsers);
    75.  
    76.                 // Send replaced for users that don't see the package for the first time
    77.                 if (update) {//如果当前安装是升级,则还需要发送更多的广播:Intent.ACTION_PACKAGE_REPLACED/Intent.ACTION_MY_PACKAGE_REPLACED
    78.                     sendPackageBroadcast(Intent.ACTION_PACKAGE_REPLACED,
    79.                             packageName, extras, 0 /*flags*/,
    80.                             null /*targetPackage*/, null /*finishedReceiver*/,
    81.                             updateUsers);
    82.                     sendPackageBroadcast(Intent.ACTION_MY_PACKAGE_REPLACED,
    83.                             null /*package*/, null /*extras*/, 0 /*flags*/,
    84.                             packageName /*targetPackage*/,
    85.                             null /*finishedReceiver*/, updateUsers);
    86.                 } else if (launchedForRestore && !isSystemApp(res.pkg)) {
    87.                     // First-install and we did a restore, so we're responsible for the
    88.                     // first-launch broadcast.
    89.                     if (DEBUG_BACKUP) {
    90.                         Slog.i(TAG, "Post-restore of " + packageName
    91.                                 + " sending FIRST_LAUNCH in " + Arrays.toString(firstUsers));
    92.                     }
    93.                     sendFirstLaunchBroadcast(packageName, installerPackage, firstUsers);
    94.                 }
    95.  
    96.                 // Send broadcast package appeared if forward locked/external for all users
    97.                 // treat asec-hosted packages like removable media on upgrade
    98.                 if (res.pkg.isForwardLocked() || isExternal(res.pkg)) {//如果安装的是foreword lock应用或是安装在SD卡上的应用,也有相关的广播要发送
    99.                     if (DEBUG_INSTALL) {
    100.                         Slog.i(TAG, "upgrading pkg " + res.pkg
    101.                                 + " is ASEC-hosted -> AVAILABLE");
    102.                     }
    103.                     final int[] uidArray = new int[]{res.pkg.applicationInfo.uid};
    104.                     ArrayList<String> pkgList = new ArrayList<>(1);
    105.                     pkgList.add(packageName);
    106.                     sendResourcesChangedBroadcast(true, true, pkgList, uidArray, null);
    107.                 }
    108.             }
    109.  
    110.             // Work that needs to happen on first install within each user
    111.             if (firstUsers != null && firstUsers.length > 0) {
    112.                 synchronized (mPackages) {
    113.                     for (int userId : firstUsers) {
    114.                         if (packageIsBrowser(packageName, userId)) {
    115.                             mSettings.setDefaultBrowserPackageNameLPw(null, userId);
    116.                         }
    117.  
    118.                         mSettings.applyPendingPermissionGrantsLPw(packageName, userId);
    119.                     }
    120.                 }
    121.             }
    122.  
    123.             EventLog.writeEvent(EventLogTags.UNKNOWN_SOURCES_ENABLED,
    124.                     getUnknownSourcesSettings());
    125.  
    126.             Runtime.getRuntime().gc();
    127.  
    128.             if (res.removedInfo != null && res.removedInfo.args != null) {
    129.                 synchronized (mInstallLock) {
    130.                     res.removedInfo.args.doPostDeleteLI(true);
    131.                 }
    132.             }
    133.         }
    134.  
    135.         if (installObserver != null) {//回调接口调用,反馈最终安装的结果
    136.             try {
    137.                 Bundle extras = extrasForInstallResult(res);
    138.                 installObserver.onPackageInstalled(res.name, res.returnCode,
    139.                         res.returnMsg, extras);
    140.             } catch (RemoteException e) {
    141.                 Slog.i(TAG, "Observer no longer exists.");
    142.             }
    143.         }
    144.     }

主要处理就是发送各种广播，比如：

  • Intent.ACTION_PACKAGE_ADDED：通知系统其它组件，当前有新的apk安装成功了。
  • Launcher；Launcher 再去向 PKMS 查询所有带有主 Activity 的应用信息，更新显示。最后再通过用户注册的 Observer 回调对象将安装结果回调给监听者。

分析到这里，一个 APK 的安装过程就简要地分析完成了。

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/199144
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号