adb install 流程分析

在Android系统中，应用的文件是以 .apk为结尾的文件，这个文件是如何被安装到Android系统中的? 那就是利用 adb install 这个命令, 大家可以在命令行内 打入 adb install <.apk文件路径> 进行安装。下面我们来分析它的原理。

首先该命令对应代码在commandline.cpp内，内容如下:

int adb_commandline(int argc, const char **argv) {
....
....
   else if (!strcmp(argv[0], "install")) {
        if (argc < 2) return usage();
        if (_use_legacy_install()) {
            return install_app_legacy(transport_type, serial, argc, argv);
        }
        return install_app(transport_type, serial, argc, argv);
    }

接下来会调用到 install_app函数. 在其内，会执行一个pm脚本，该脚本主要功能就是通过app_process来执行pm.jar 的main函数(有关于app_procee相关信息大家可以去查阅一下), pm.jar的main函数就相当于java进程的入口函数，下面对它进行分析（PM.java）

    public static void main(String[] args) {
        int exitCode = 1;
        try {
            exitCode = new Pm().run(args);
        } catch (Exception e) {
            Log.e(TAG, "Error", e);
            System.err.println("Error: " + e);
            if (e instanceof RemoteException) {
                System.err.println(PM_NOT_RUNNING_ERR);
            }
        }
        System.exit(exitCode);
    }

可以看到,直接new Pm() 然后执行了 run()函数.

public int run(String[] args) throws RemoteException {
        boolean validCommand = false;
        if (args.length < 1) {
            return showUsage();
        }
        mAm = IAccountManager.Stub.asInterface(ServiceManager.getService(Context.ACCOUNT_SERVICE));
        mUm = IUserManager.Stub.asInterface(ServiceManager.getService(Context.USER_SERVICE));
        mPm = IPackageManager.Stub.asInterface(ServiceManager.getService("package"));


        mInstaller = mPm.getPackageInstaller();

        mArgs = args;
        String op = args[0];
        mNextArg = 1;
        ....
        if ("install".equals(op)) {
            return runInstall();
        }

      ....

可以看到，上面获取了一个IPackageManager,它实际是一个PackageManagerService 的binder客户端，通过它调用pkms的方法,接下来处理 install 指令.

    private int runInstall() throws RemoteException {
        final InstallParams params = makeInstallParams();
        final String inPath = nextArg();
        ....
        final int sessionId     =doCreateSession(params.sessionParams,params.installerPacka.    geName, params.userId);
            ....
           if (doCommitSession(sessionId, false 
                    != PackageInstaller.STATUS_SUCCESS) {
                return 1;
            }
            ....

由上面代码可以看到

1. 调用makeInstallParams()获取 InstallParams
2. 调用doCreateSession 并一 InstallParams为参数 来获取sessionId
3. 通过sessionId 调用 doCommitSession

下面我们来看doCommitSession

    private int doCommitSession(int sessionId, boolean logSuccess) throws RemoteException {
        PackageInstaller.Session session = null;
        try {
            session = new PackageInstaller.Session(
                    mInstaller.openSession(sessionId));
            final LocalIntentReceiver receiver = new LocalIntentReceiver();
            session.commit(receiver.getIntentSender());
            ....
            ....

可以看到,通过 session 来创建了一个PackageInstall.Session对象(注意mInstall.openSession()), 然后通过该对象调用 commit方法,我们继续深入。

   public void commit(@NonNull IntentSender statusReceiver) {
            try {
                mSession.commit(statusReceiver);
            } catch (RemoteException e) {
                throw e.rethrowFromSystemServer();
            }
        }

可以看到直接在其内直接调用了 成员变量mSession的commit, 它的类型是IPackageInstallerSession对象，是通过上面的mInstaller.openSession来获取的,相当于PackageInstallerSession binder的客户端,既然客户端调用，那么就必然会调用到服务端相同名字的代码，下面我们来看PackageInstallerSession.commit()

    @Override
    public void commit(IntentSender statusReceiver) {
    ····
        //原子操作，防止并发
        mActiveCount.incrementAndGet();

        final PackageInstallObserverAdapter adapter = new PackageInstallObserverAdapter(mContext,
                statusReceiver, sessionId, mIsInstallerDeviceOwner, userId);
        mHandler.obtainMessage(MSG_COMMIT, adapter.getBinder()).sendToTarget();
    }

可以看到,它创建了一个PackageInstallObserverAdapter,它的作用是监听PKMS的安装结果。 然后通过mHandler发送了一个MSG_COMMIT的消息,该hander是通过传入callback方式来处理的，其callback为mHandlerCallback,

    private final Handler.Callback mHandlerCallback = new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            // Cache package manager data without the lock held
            final PackageInfo pkgInfo = mPm.getPackageInfo(
                    params.appPackageName, PackageManager.GET_SIGNATURES /*flags*/, userId);
            final ApplicationInfo appInfo = mPm.getApplicationInfo(
                    params.appPackageName, 0, userId);

            synchronized (mLock) {
             ....
                try {
                    commitLocked(pkgInfo, appInfo);
                }
                ....
                return true;
            }
        }
    };

上面代码首先获取pkg与application 的信息,然后调用 commitLocked

    private void commitLocked(PackageInfo pkgInfo, ApplicationInfo appInfo)
            throws PackageManagerException {
        ····
         mPm.installStage(mPackageName, stageDir, stageCid, localObserver, params,
                installerPackageName, installerUid, user, mCertificates);
               }

在上面方法中，我们直接到了最后一行,也就是通过PKMS的 binder客户端来调用了 installStage,最终会到PKMS内的installStage。

    void installStage(String packageName, File stagedDir, String stagedCid,
            IPackageInstallObserver2 observer, PackageInstaller.SessionParams sessionParams,
            String installerPackageName, int installerUid, UserHandle user,
            Certificate[][] certificates) {
            ····
                    final Message msg = mHandler.obtainMessage(INIT_COPY);//
        final InstallParams params = new InstallParams(origin, null, observer,
                sessionParams.installFlags, installerPackageName, sessionParams.volumeUuid,
                verificationInfo, user, sessionParams.abiOverride,
                sessionParams.grantedRuntimePermissions, certificates);//
            ····
             mHandler.sendMessage(msg);

可以看到上面代码首先获取了一个 INIT_COPY消息，然后创建了一个InstallParams, 接着发送消息。

 public void handleMessage(Message msg) {
            try {
                doHandleMessage(msg);
            } finally {
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            }
        }


  void doHandleMessage(Message msg) {
            switch (msg.what) {
                case INIT_COPY: {
                ....
                if (!mBound) {
                       if (!connectToService()) {
                            params.serviceError();
                             ....
                        } else {
                       mPendingInstalls.add(idx, params);
                        }
                }else {
                        mPendingInstalls.add(idx, params);
                        if (idx == 0) {   mHandler.sendEmptyMessage(MCS_BOUND);
                        }
                    }

可以看到在doHandleMessage 县调用了connectToService(),其内主要是开启一个服务(DefalutContainerService)，它的主要作用就是安装apk。所以，安装apk是由系统提供的服务来完成的。最后会接着发送一个MCS_BOUND的消息。

  case MCS_BOUND: {
  ....
  if (params.startCopy()) {
  ....
  }
  ....
  }

在其内，最重要的一句就是 startCopy这句代码，下面我们来看

        final boolean startCopy() {
            boolean res;
            try {
                 // max_retries =4, 最大可重试安装4次,超过则错误
                if (++mRetries > MAX_RETRIES) {
                    ....
                    mHandler.sendEmptyMessage(MCS_GIVE_UP);
                    handleServiceError();
                    return false;
                } else {
                    handleStartCopy();
                    res = true;
                }
            } catch (RemoteException e) {

                mHandler.sendEmptyMessage(MCS_RECONNECT);
                res = false;
            }
            handleReturnCode();
            return res;
        }

可以看到，上面判断了安装失败次数，系统默认允许最大4次安装失败。
接着依次调用了。handleStartCopy 与 handleReturnCode(). 这两个方法都是abstract的，所以我们应该去找它的子类来查看。由前面代码可知,HandlerParams实际类型是 InstallerParams/

  public void handleStartCopy() throws RemoteException {
            final boolean onSd = (installFlags & PackageManager.INSTALL_EXTERNAL) != 0;
            final boolean onInt = (installFlags & PackageManager.INSTALL_INTERNAL) != 0;
            final boolean ephemeral = (installFlags & PackageManager.INSTALL_EPHEMERAL) != 0;
          if (onInt && onSd) {
                .....
            } else if (onSd && ephemeral) {
                .....
            } else {
            //1.
            pkgLite = mContainerService.getMinimalPackageInfo(origin.resolvedPath, installFlags, packageAbiOverride);
            .....
}
        .....
          loc = installLocationPolicy(pkgLite);
        .....
          final InstallArgs args = createInstallArgs(this);
        ....
        ret = args.copyApk(mContainerService, true);
}

以上省去了大量代码，只留了我们分析流程的代码,以上代码主要干了以下几件事

1. 调用mContainerService.getMinimalPackageInfo 获取一个用于描述apk结构的类
2. 调用installLocationPolicy 获取推荐安装路径
3. 根据params参数的不同创建不同的args,这里创建的是FileInstallArgs
4. 调用FileInstallArgs 的 copyApk函数 (该函数完成会在data/app 下面多出一个.tmp为结尾的临时文件)

下面看handleReturnCode

        @Override
        void handleReturnCode() {

            if (mArgs != null) {
                processPendingInstall(mArgs, mRet);
            }
        }

    private void processPendingInstall(final InstallArgs args, final int currentStatus) {
        mHandler.post(new Runnable() {
            public void run() {
            ····
                 if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
                    args.doPreInstall(res.returnCode);
                    synchronized (mInstallLock) {
                        installPackageTracedLI(args, res);
                    }
                    args.doPostInstall(res.returnCode, res.uid);
                }
                ····
                Message msg = mHandler.obtainMessage(POST_INSTALL, token, 0);
                    mHandler.sendMessage(msg);

             }
          }

由上面代码可知

1. 调用FileInstallArgs的 doPreInstall
2. 调用 installPackageTracedLI进行安装
3. 调用FileInstallArgs的 doPostInstall
4. 此时已安装完apk，无论成功还是失败都会发送POST_INSTALL消息，该消息携带一个token,通过该token可以取出mRunningInstalls数组中的一个PostInstallData对象

关于安装的代码，其内容由dex优化等内容，由于篇幅较长，所以大家只需要知道该函数是安装的代码，如果有想知道具体细节的，可以自行查阅。在POST_INSTALL中，会通知PM安装完成。

到这里安装的流程就分析完了，其中还有很多细节没有分析，这里就留给大家了。