Apk安装之——PMS安装apk过程分析

最新推荐文章于 2024-08-15 17:13:00 发布

hujin2017

最新推荐文章于 2024-08-15 17:13:00 发布

阅读量963

点赞数

分类专栏： android 文章标签： PackageManagerService InstallParams DefaultContainerService PackageParser PackageSetting

本文链接：https://blog.csdn.net/hujin2017/article/details/102856890

版权

android 专栏收录该内容

67 篇文章 3 订阅

订阅专栏

上篇文章Apk安装之——点击安装确认页面的确认按钮，到将安装过程交给PMS的过程分析分析到apk安装的流程，交给了PMS，这篇文章继续分析，PMS是如何安装apk包的。首先调用PMS的installStage进行安装。下面看看这个方法：


http://androidxref.com/9.0.0_r3/xref/frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java

void installStage(String packageName, File stagedDir,
        IPackageInstallObserver2 observer, PackageInstaller.SessionParams sessionParams,
        String installerPackageName, int installerUid, UserHandle user,
        PackageParser.SigningDetails signingDetails) {
    ...
    final VerificationInfo verificationInfo = new VerificationInfo(
            sessionParams.originatingUri, sessionParams.referrerUri,
            sessionParams.originatingUid, installerUid);

    final OriginInfo origin = OriginInfo.fromStagedFile(stagedDir);
    //关键代码 msg.what是INIT_COPY的消息
    final Message msg = mHandler.obtainMessage(INIT_COPY);
    final int installReason = fixUpInstallReason(installerPackageName, installerUid,
            sessionParams.installReason);
    final InstallParams params = new InstallParams(origin, null, observer,
            sessionParams.installFlags, installerPackageName, sessionParams.volumeUuid,
            verificationInfo, user, sessionParams.abiOverride,
            sessionParams.grantedRuntimePermissions, signingDetails, installReason);
    params.setTraceMethod("installStage").setTraceCookie(System.identityHashCode(params));
    //注意，这里的params是一个InstallParams类型的对象,赋值给了msg.obj
    msg.obj = params;

    ...
    //关键代码 发送一个msg.what是INIT_COPY的消息
    mHandler.sendMessage(msg);
}

这个方法内部，会发送一个msg.what是INIT_COPY的消息,下面看PackageHandler对这个消息的处理

http://androidxref.com/9.0.0_r3/xref/frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java
class PackageHandler extends Handler {
	...

	private boolean connectToService() {
            if (DEBUG_INSTALL) Log.i(TAG, "Trying to bind to DefaultContainerService");
            Intent service = new Intent().setComponent(DEFAULT_CONTAINER_COMPONENT);
            Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
            if (mContext.bindServiceAsUser(service, mDefContainerConn,
                    Context.BIND_AUTO_CREATE, UserHandle.SYSTEM)) {
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                mBound = true;
                return true;
            }
            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            return false;
        }
	...

	void doHandleMessage(Message msg) {
            switch (msg.what) {
                case INIT_COPY: {
                    HandlerParams params = (HandlerParams) msg.obj;
                    int idx = mPendingInstalls.size();
		    //mBound默认是false
                    if (!mBound) {
                        //关键代码1  发送连接DefaultContainerService的请求，这是system_server进程和com.android.defcontainer进程进行通信，
                        if (!connectToService()) {
                            params.serviceError();
                            ...
			    //如果绑定DefaultContainerService失败，则return
                            return;
                        } else {
                            //关键代码2    如果连接上DefaultContainerService，则将这个安装请求保存到这个mPendingInstalls这个List集合中
                            mPendingInstalls.add(idx, params);
                        }
                    } else {
		        //如果已经绑定了DefaultContainerService，则将这个安装请求保存到这个mPendingInstalls这个List集合中
                        mPendingInstalls.add(idx, params);
                        //如果是第一个安装请求，则发送绑定MCS_BOUND消息,在未给mPendingInstalls添加安装请求前，上面mPendingInstalls.size()的值是0，
			//当添加按章请求后，这是mPendingInstalls.size()的值是1，所以，这里idx==0，就是给第一个安装请求发送MCS_BOUND消息
                        if (idx == 0) {
			    //关键代码3
                            mHandler.sendEmptyMessage(MCS_BOUND);
                        }
                    }
                    break;
		    ...
		
	}
 }


 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");
            final IMediaContainerService imcs = IMediaContainerService.Stub
                    .asInterface(Binder.allowBlocking(service));
            //关键代码 这里发送msg.what为MCS_BOUND的消息是，msg.obj的值是imcs，其实就是DefaultContainerService在system_server的代理对象
            mHandler.sendMessage(mHandler.obtainMessage(MCS_BOUND, imcs));
        }

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

在INIT_COPY这个case中，如果本次安装时，没有其他安装请求，则mBound的值是false，这会执行到关键代码1处，调用connectToService()方法进行绑定DefaultContainerService的连接操作，这是个进程间通信的过程，是system_server进程和com.android.defcontainer进程进行通信。如果连接上DefaultContainerService，则将安装请求添加进mPendingInstalls这个集合中，如果连接失败，则return。如果本次安装时，已经有其他安装请求绑定DefaultContainerService服务了，则将这次安装请求添加进mPendingInstalls，并通过handler发送MCS_BOUND消息。注意发送MCS_BOUND消息时，msg.obj被赋值了，这个值是DefaultContainerService在system_server进程中的代理对象.下面看看handler对MCS_BOUND消息的处理:

http://androidxref.com/9.0.0_r3/xref/frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java
 class PackageHandler extends Handler {
	void doHandleMessage(Message msg) {
            switch (msg.what) {
		...
		case MCS_BOUND: {
                    
                    if (msg.obj != null) {  //关键代码1 如果msg.obj不为null,则给mContainerService赋值
                        mContainerService = (IMediaContainerService) msg.obj;
                        ...
                    }
		    
                    if (mContainerService == null) {  //关键代码2  如果mContainerService为null
		        
                        if (!mBound) {  //关键代码3  如果是连接上DefaultContainerService，mBound的值会true,如果这里的mBound的值为false,则安装过程出错了，
    
                            for (HandlerParams params : mPendingInstalls) {
                                // Indicate service bind error
                                params.serviceError();
                                ...
                            }
			    //安装过程出错，清除这个mPendingInstalls集合
                            mPendingInstalls.clear();
                        } else {
			   
                            Slog.w(TAG, "Waiting to connect to media container service");
                        }
                    } else if (mPendingInstalls.size() > 0) {  //关键代码5 需要安装的请求的个数大于0
                        HandlerParams params = mPendingInstalls.get(0);
                        if (params != null) {
                            ...
                            if (params.startCopy()) {  //关键代码6 开始复制
                                ...
                                if (mPendingInstalls.size() > 0) { //复制成功，则将本次安装请求重mPendingInstalls集合中移除
                                    mPendingInstalls.remove(0);
                                }
                                if (mPendingInstalls.size() == 0) { // 如果安装请求的个数为0
                                    if (mBound) {
                                        //如果需要安装的apk的个数为0，并且是绑定状态，则发送消息和ContainerService解绑
                                        removeMessages(MCS_UNBIND);
                                        Message ubmsg = obtainMessage(MCS_UNBIND);
                                        sendMessageDelayed(ubmsg, 10000);
                                    }
                                } else {
                                    // 接着处理下一个绑定ContainerService的请求
                                    mHandler.sendEmptyMessage(MCS_BOUND);
                                }
                            }
                            ...
                        }
                    } else {
                        // Should never happen ideally.
                        Slog.w(TAG, "Empty queue");
                    }
                    break;
		    ...
                }
	}
 }

handler中处理MCS_BOUND消息的逻辑是，由于发送MCS_BOUND时msg.obj赋值过，导致关键代码1处成立，则执行关键代码5处的逻辑，这是就会执行关键代码6处的逻辑，在发送Init_copy消息时，msg.obj是InstallParams类型的对象，所以，这里mPendingInstalls中取出的就是InstallParams类型的对象，调用InstallParams类的startCopy方法进行复制工作。当复制成功后，会则将本次安装请求重mPendingInstalls集合中移除，如果需要安装的apk的个数为0，并且是绑定状态，则发送消息和ContainerService解绑，如果不为0，则继续处理下一个安装请求。这个方法中，还有另外的一个逻辑，这里也顺便阐述一下,如果关键代码1出的逻辑成立则执行关键代码2处的逻辑，关键代码2中逻辑是，如果当前状态是为绑定，则肯定是出错了，因为connectToServcie方法中如果连接成功，这个mBound这个值就复制为true了这里这个值如果是false，则if(!mBound)这个判断条件成立，这样安装过程肯定出错了，则将mPendingInstalls集合清除。正常情况下，这个mBound的值应该是true,所以不做处理。表示已经连接上了。下面接着分析，InstallParams类的startCopy方法是如何进行复制的：


http://androidxref.com/9.0.0_r3/xref/frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java
final boolean startCopy() {
    boolean res;
    try {
        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 {
	    // 关键代码1
            handleStartCopy();
            res = true;
        }
    } catch (RemoteException e) {
        if (DEBUG_INSTALL) Slog.i(TAG, "Posting install MCS_RECONNECT");
        mHandler.sendEmptyMessage(MCS_RECONNECT);
        res = false;
    }
    //关键代码2
    handleReturnCode();
    return res;
}

InstallParams是继承自HandlerParams的startCopy()这个方法是HandlerParams的方法，这个方法内部，会判断安装重试的次数是否大于4次(MAX_RETRIES是个常量，值是4)，如果大于4次，则发送放弃安装。如果不大于4次，则执行handleStartCopy()方法，下面看看这个方法的具体实现：

http://androidxref.com/9.0.0_r3/xref/frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java

public void handleStartCopy() throws RemoteException {
    int ret = PackageManager.INSTALL_SUCCEEDED;

    // If we're already staged, we've firmly committed to an install location
    //如果是一个新的app,则staged为false
    if (origin.staged) {
        if (origin.file != null) {
            installFlags |= PackageManager.INSTALL_INTERNAL;
            installFlags &= ~PackageManager.INSTALL_EXTERNAL;
        } else {
            throw new IllegalStateException("Invalid stage location");
        }
    }
    // 确定APK的安装位置，onSd表示安装到SD卡上，
    // onInt表示安装到内部存储，即Data分区
    // ephemeral：安装到临时存储（Instant Apps安装）
    final boolean onSd = (installFlags & PackageManager.INSTALL_EXTERNAL) != 0;
    final boolean onInt = (installFlags & PackageManager.INSTALL_INTERNAL) != 0;
    final boolean ephemeral = (installFlags & PackageManager.INSTALL_INSTANT_APP) != 0;
    PackageInfoLite pkgLite = null;

    if (onInt && onSd) {  
        // 不能同时安装到sd卡和内部存储位置
        Slog.w(TAG, "Conflicting flags specified for installing on both internal and external");
        ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
    } else if (onSd && ephemeral) {
        //flags冲突，不能在sd卡安装Instant app
        Slog.w(TAG,  "Conflicting flags specified for installing ephemeral on external");
        ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
    } else {
        //获取apk的轻量信息
        pkgLite = mContainerService.getMinimalPackageInfo(origin.resolvedPath, installFlags,
                packageAbiOverride);
        if (!origin.staged && pkgLite.recommendedInstallLocation
                == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
            ... 
	    //省略这个判断内部的代码，这块的主要逻辑是判断，如果存储空间不足，则需要释放Cache的一些空间
        }
    }

    if (ret == PackageManager.INSTALL_SUCCEEDED) {
        ...
        //省略这个判断内部的代码，这块的主要逻辑是判断安装的位置
    }
    //创建InstallArgs对象，createInstallArgs方法内部返回的是FileInstallArgs类型的对象。FileInstallArgs是InstallArgs的子类
    final InstallArgs args = createInstallArgs(this);
    mArgs = args;

    if (ret == PackageManager.INSTALL_SUCCEEDED) {
        ...
        if (!origin.existing && requiredUid != -1
                && isVerificationEnabled(
                        verifierUser.getIdentifier(), installFlags, installerUid)) {
            ...
           // 此处省略大段APK的检查逻辑。
        } else {
            //调用FileInstallArgs类的copyApk方法
            ret = args.copyApk(mContainerService, true);
        }
    }
    mRet = ret;
}

这个方法内部，根据安装方式，判断安装的位置是否冲突，在判断，安装的位置是否有足够的存储空间，如果没有，释放缓存空间，接着确定安装位置，在接着对apk进行检测，最后创建FileInstallArgs类型的对象，并调用其调用copyApk方法，copyApk方法中直接调用了doCopyApk方法，下面看看这个方法：

http://androidxref.com/9.0.0_r3/xref/frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java

private int doCopyApk(IMediaContainerService imcs, boolean temp) throws RemoteException {
    ...

    try {
        final boolean isEphemeral = (installFlags & PackageManager.INSTALL_INSTANT_APP) != 0;
	//创建临时文件
        final File tempDir =
                mInstallerService.allocateStageDirLegacy(volumeUuid, isEphemeral);
        codeFile = tempDir;
        resourceFile = tempDir;
    } catch (IOException e) {
        Slog.w(TAG, "Failed to create copy file: " + e);
        return PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
    }

    ...

    int ret = PackageManager.INSTALL_SUCCEEDED;
    //调用DefaultContainerService在system_server进程中的代理对象的copyPackage方法，这是进程间通信的过程，
    //跨进程调用DefaultContainerService进程中的copyPackage()函数
    ret = imcs.copyPackage(origin.file.getAbsolutePath(), target);
    if (ret != PackageManager.INSTALL_SUCCEEDED) {
        return ret;
    }
    //复制Native库文件
    final File libraryRoot = new File(codeFile, LIB_DIR_NAME);
    NativeLibraryHelper.Handle handle = null;
    try {
        handle = NativeLibraryHelper.Handle.create(codeFile);
        ret = NativeLibraryHelper.copyNativeBinariesWithOverride(handle, libraryRoot,
                abiOverride);
    } catch (IOException e) {
        Slog.e(TAG, "Copying native libraries failed", e);
        ret = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
    } finally {
        IoUtils.closeQuietly(handle);
    }
    return ret;
}

FileInstallArgs类的copyApk方法中，又会调用doCopyApk方法，在doCopyApk方法中，会创建一个临时路径，这里之所以创建临时目录，命名如/data/app/vmdl29300388.tmp，其中数字部分29300388在每一次安装过程都不同，是安装时的SessionId。由于PMS监控了/data/app目录，如果该目录下有后缀名为.apk的文件生成，便会触发PMS扫描，为了避免这种情况，安装APK时，先用了临时的文件名。并跨进程调用DefaultContainerService的copyPackage方法完成apk的复制工作，然后复制Native库。完成了apk的复制工作后，apk就在data/app目录下，不过此时还是临时文件的，后续还需要重新命名。如果复制过程为出现异常，则返回INSTALL_SUCCEEDED(1)这个整数；否则，会返回对应的错误码。到这里，分析完了PMS $H a n d l e r P a r a m s 类的的 s t a r t C o p y () 中的 h a n d l e S t a r t C o p y 方法的处理逻辑，下面继续看 P M S$ HandlerParams类的的startCopy()方法的后续对复制apk的结果的处理逻辑：

http://androidxref.com/9.0.0_r3/xref/frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java
final boolean startCopy() {
    boolean res;
    try {
        if (DEBUG_INSTALL) Slog.i(TAG, "startCopy " + mUser + ": " + this);

        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 {
	    // 关键代码1
            handleStartCopy();
            res = true;
        }
    } catch (RemoteException e) {
        if (DEBUG_INSTALL) Slog.i(TAG, "Posting install MCS_RECONNECT");
        mHandler.sendEmptyMessage(MCS_RECONNECT);
        res = false;
    }
    //关键代码2
    handleReturnCode();
    return res;
}

在关键代码2处，就是对复制apk后的返回结果的处理，下面看看这个handleReturnCode()方法的具体实现

http://androidxref.com/9.0.0_r3/xref/frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java
 @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() {
            mHandler.removeCallbacks(this);
            PackageInstalledInfo res = new PackageInstalledInfo();
            res.setReturnCode(currentStatus);
            res.uid = -1;
            res.pkg = null;
            res.removedInfo = null;
            if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
	        //安装前的准备工作，检查包状态，确保环境ok，如果环境不ok，那么会清理拷贝的文件
                args.doPreInstall(res.returnCode);
                synchronized (mInstallLock) {
		    //安装apk，调用installPackageTracedLI进行安装
                    installPackageTracedLI(args, res);
                }
		//安装完后的处理
                args.doPostInstall(res.returnCode, res.uid);
            }

            ...

            if (res.returnCode == PackageManager.INSTALL_SUCCEEDED && doRestore) {
    
                IBackupManager bm = IBackupManager.Stub.asInterface(
                        ServiceManager.getService(Context.BACKUP_SERVICE));
                ...
		//这块省略的逻辑，是对apk的备份过程
            }

            ...
        }
    });
}

handleReturnCode方法内部，直接调用了processPendingInstall来处理具体的安装逻辑。processPendingInstall方法中，是将安装过程放在一个线程中的，这个方法内部，主要做了三件事，第一安装前的检查，检查安装环境是否正常，如果不正常，则清理复制的apk文件，如果安装环境正常，则进行进行安装工作，安装完后，处理一些收尾的事情。installPackageTracedLI方法内部直接调用了installPackageLI方法，下面具体看看这个方法的具体实现：

http://androidxref.com/9.0.0_r3/xref/frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java

private void installPackageLI(InstallArgs args, PackageInstalledInfo res) {
        ...
	PackageParser pp = new PackageParser();
	...
        final PackageParser.Package pkg;
        try {
	    //关键代码1
            pkg = pp.parsePackage(tmpPackageFile, parseFlags);
            DexMetadataHelper.validatePackageDexMetadata(pkg);
        } catch (PackageParserException e) {
            res.setError("Failed parse during installPackageLI", e);
            return;
        } finally {
            Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
        }

        ...

        try {
            //收集签名信息
            if (args.signingDetails != PackageParser.SigningDetails.UNKNOWN) {
                pkg.setSigningDetails(args.signingDetails);
            } else {
                PackageParser.collectCertificates(pkg, false /* skipVerify */);
            }
        } catch (PackageParserException e) {
            res.setError("Failed collect during installPackageLI", e);
            return;
        }
	...

        pp = null;
        String oldCodePath = null;
        boolean systemApp = false;
        synchronized (mPackages) {
            // 检查安装包是否存在
            if ((installFlags & PackageManager.INSTALL_REPLACE_EXISTING) != 0) {
                String oldName = mSettings.getRenamedPackageLPr(pkgName);
                if (pkg.mOriginalPackages != null
                        && pkg.mOriginalPackages.contains(oldName)
                        && mPackages.containsKey(oldName)) {
     
                    pkg.setPackageName(oldName);
                    pkgName = pkg.packageName;
		    //替换安装，也就是升级app
                    replace = true;
                } else if (mPackages.containsKey(pkgName)) {  
                    //替换安装，也就是升级app
                    replace = true;
                    if (DEBUG_INSTALL) Slog.d(TAG, "Replace existing pacakge: " + pkgName);
                }
              ...
            }
            //如果Settings中已经记录了待安装的APK信息，需要验证APK的签名
            PackageSetting ps = mSettings.mPackages.get(pkgName);
            if (ps != null) {
                PackageSetting signatureCheckPs = ps;
                ...
		//省略的代码是 验证apk的签名信息
            }

            int N = pkg.permissions.size();
            for (int i = N-1; i >= 0; i--) {
                final PackageParser.Permission perm = pkg.permissions.get(i);
                final BasePermission bp =
                        (BasePermission) mPermissionManager.getPermissionTEMP(perm.info.name);
                ...
		//省略的代码部分处理安装的apk中的权限的逻辑
            }
        }

        if (systemApp) {
            if (onExternal) {
		//系统app不能被sd卡上的app替换，return
                res.setError(INSTALL_FAILED_INVALID_INSTALL_LOCATION,
                        "Cannot install updates to system apps on sdcard");
                return;
            } else if (instantApp) {
		//系统app不能被instant app替换
                res.setError(INSTALL_FAILED_INSTANT_APP_INVALID,
                        "Cannot update a system app with an instant app");
                return;
            }
        }

	...
        
	//将之前的临时文件名重新命名
        if (!args.doRename(res.returnCode, pkg, oldCodePath)) {
            res.setError(INSTALL_FAILED_INSUFFICIENT_STORAGE, "Failed rename");
            return;
        }

        ...

        try (PackageFreezer freezer = freezePackageForInstall(pkgName, installFlags,
                "installPackageLI")) {
            if (replace) {
                if (pkg.applicationInfo.isStaticSharedLibrary()) {
                    PackageParser.Package existingPkg = mPackages.get(pkg.packageName);
                    if (existingPkg != null &&
                            existingPkg.getLongVersionCode() != pkg.getLongVersionCode()) {
                        res.setError(INSTALL_FAILED_DUPLICATE_PACKAGE, "Packages declaring "
                                + "static-shared libs cannot be updated");
                        return;
                    }
                }
		//替换安装，也就是升级app
                replacePackageLIF(pkg, parseFlags, scanFlags, args.user,
                        installerPackageName, res, args.installReason);
            } else {
	        //安装一个新的app
                installNewPackageLIF(pkg, parseFlags, scanFlags | SCAN_DELETE_DATA_ON_FAILURES,
                        args.user, installerPackageName, volumeUuid, res, args.installReason);
            }
        }


        mArtManagerService.prepareAppProfiles(pkg, resolveUserIds(args.user.getIdentifier()));

    
	// 检查是否需要优化app中的dex文件,默认是不给instant app做dex优化的，只有满足下面4个条件，才做dex的优化
        //   1) it is not forward locked.
        //   2) it is not on on an external ASEC container.
        //   3) it is not an instant app or if it is then dexopt is enabled via gservices.
        //   4) it is not debuggable.
        final boolean performDexopt = (res.returnCode == PackageManager.INSTALL_SUCCEEDED)
                && !forwardLocked
                && !pkg.applicationInfo.isExternalAsec()
                && (!instantApp || Global.getInt(mContext.getContentResolver(),
                Global.INSTANT_APP_DEXOPT_ENABLED, 0) != 0)
                && ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) == 0);

        if (performDexopt) {
            DexoptOptions dexoptOptions = new DexoptOptions(pkg.packageName,
                    REASON_INSTALL,
                    DexoptOptions.DEXOPT_BOOT_COMPLETE |
                    DexoptOptions.DEXOPT_INSTALL_WITH_DEX_METADATA_FILE);
            mPackageDexOptimizer.performDexOpt(pkg, pkg.usesLibraryFiles,
                    null /* instructionSets */,
                    getOrCreateCompilerPackageStats(pkg),
                    mDexManager.getPackageUseInfoOrDefault(pkg.packageName),
                    dexoptOptions);
        }

        ...

        synchronized (mPackages) {
            final PackageSetting ps = mSettings.mPackages.get(pkgName);
            if (ps != null) {
	    //更新APK的所属用户
                res.newUsers = ps.queryInstalledUsers(sUserManager.getUserIds(), true);
                ps.setUpdateAvailable(false /*updateAvailable*/);
            }
            ...
        }
}

这个方法内部，处理的逻辑还是很复杂的，下面列出主要的处理流程：
1.通过PackageParser的parsePackage方法对apk进行解析，具体的解析工作，很复杂，主要是解析apk文件中的manifest文件，并将manifest文件中的application标签，activity,service,broadcast，contentprovider,这四大组件，intentfileter等标签解析成对应的数据结构，比如activity标签就解析为Activity类，这里的这个Activity类不是我们平时开发时继承的Activity,这个Activity是继承Component类的，将这些解析的标签对应的数据保存到PackageParser$Package类的各个集合中。这里由于篇幅的原因，省略了这个解析过程的具体分析，但是读者一定要仔细去分析这个过程，如果做插件化开发，这个方法是很重要的，必须要了解。

2.收集apk中的签名信息和验证签名信息，如果是替换安装，则要和原来的apk的签名信息进行对比，主要是为了安全升级app

3.判断需要安装的apk的信息，是否有记录，如果有则是替换安装，如果没有，则是安装一个新的app

4.处理apk中的权限

5.将原来的临时文件重命名

6.如果是替换安装，则走具体的替换安装的逻辑，如果需要替换的是系统APP，则调用Settings$disableSystemPackageLPw来disable旧的APK；如果替换的是非系统APP，则调用deletePackageLI删除旧的APK。不管是更新系统还是非系统apk，都会先清除之前的packages信息，然后通过scanPackageTracedLI去安装apk，安装完后更新permissions和setting，最后通过writeLPr更新packages.xml.如果是一个安装一个新的app,则执行installNewPackageLIF方法,这个方法，后面会进行分析。

7.对满足条件的apk进行dex文件的优化处理

8.晚装完成后，更新apk所属的用户

下面下分析installNewPackageLIF方法：

http://androidxref.com/9.0.0_r3/xref/frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java

private void installNewPackageLIF(PackageParser.Package pkg, final @ParseFlags int parseFlags,
        final @ScanFlags int scanFlags, UserHandle user, String installerPackageName,
        String volumeUuid, PackageInstalledInfo res, int installReason) {
    Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "installNewPackage");

    // Remember this for later, in case we need to rollback this install
    String pkgName = pkg.packageName;


    synchronized(mPackages) {
        final String renamedPackage = mSettings.getRenamedPackageLPr(pkgName);
        if (renamedPackage != null) {
            // A package with the same name is already installed, though
            // it has been renamed to an older name.  The package we
            // are trying to install should be installed as an update to
            // the existing one, but that has not been requested, so bail.
            res.setError(INSTALL_FAILED_ALREADY_EXISTS, "Attempt to re-install " + pkgName
                    + " without first uninstalling package running as "
                    + renamedPackage);
            return;
        }
        if (mPackages.containsKey(pkgName)) {
            // Don't allow installation over an existing package with the same name.
            res.setError(INSTALL_FAILED_ALREADY_EXISTS, "Attempt to re-install " + pkgName
                    + " without first uninstalling.");
            return;
        }
    }

    try {
        //扫描apk
        PackageParser.Package newPackage = scanPackageTracedLI(pkg, parseFlags, scanFlags,
                System.currentTimeMillis(), user);
	//更新Settings中的信息
        updateSettingsLI(newPackage, installerPackageName, null, res, user, installReason);

        if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
	    //如果安装成功，则为新安装的应用准备数据
            prepareAppDataAfterInstallLIF(newPackage);

        } else {
            // 安装失败，则删除apk
            deletePackageLIF(pkgName, UserHandle.ALL, false, null,
                    PackageManager.DELETE_KEEP_DATA, res.removedInfo, true, null);
        }
    } catch (PackageManagerException e) {
        res.setError("Package couldn't be installed in " + pkg.codePath, e);
    }

    Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
}

这个方法内部，通过调用scanPackageLI()函数，这样一来APK的各种信息都会记录在PMS中；描完以后，会调用updateSettingsLI()函数来更新APK的权限，设置安装状态等。如果安装成功，则为新安装的app准备数据，如果安装失败，则将apk删除。
以上便是PMS安装apk的过程，下面对这个过程进行总结：

总结：PMS处理apk的安装过程，是从installStage方法开始的，这个方法内部，会通过handler发送一个msg.what是INIT_COPY的消息，handler内部处理这个消息，发起apk文件的复制，这个工作是在com.android.defcontainer进程中进行的，但是复制apk文件时，会先判断是否绑定了DefaultContainerService这个服务，因为只有绑定了DefaultContainerService这个服务，才能和com.android.defcontainer进程进行通信，如果未绑定DefaultContainerService这个服务，则会发起绑定这个服务的请求，绑定完成后，调用InstallParams类的startCopy方法开始复制，这个方法内部会先判断安装的重试次数是否超过了4次，如果超过了，就放弃安装，如果未超过，就开始安装，安装的过程中，根据安装方式，判断安装的位置是否冲突，在判断，安装的位置是否有足够的存储空间，如果没有，释放缓存空间，接着确定安装位置，在接着对apk进行检测。接着会创建一个临时文件路径，然后在通过进程间通信的方式，在com.android.defcontainer进程中进行apk文件的复制工作。然后复制Native库。完成了apk的复制工作后，apk就在data/app目录下，不过此时还是临时文件的，后续还需要重新命名。如果复制过程为出现异常，则返回INSTALL_SUCCEEDED(1)这个整数；否则，会返回对应的错误码。接着处理返回的复制结果，如果复制正常，则会进入到预安装，预安装这个步骤中，主要是检测包的状态，安装环境，比如sd卡的上的apk安装，如果在安装时，sd卡被拔出了或者sd卡上的文件不存了，所以这里要再次确认下安装的环境，如果安装环境不正常，则会清除复制的apk,如果安装环境正常，则进入实质的安装阶段，这个阶段，会解析apk,并将信息保存到PackageParser$Package类的成员变量中，在接着验证apk的签名信息，处理apk中的权限，接着将临时文件重命名，判断是安装一个新的app还是升级app,然后进行相应的安装和升级，如果安装过程中，安装失败，会删除apk，安装的本质是对apk中文件manifest文件进行解析，并将保存到PackageParser.Package中的信息赋值给Settings这个对象中，完成对Settings对象中对apk信息的更新。在接着是对满足一定条件的apk中的dex文件进行优化，完成安装后，更新apk所属的用户。

参考：
包管理机制分析

Android包管理机制（三）PMS处理APK的安装

应用程序安装流程