Android应用程序安装过程浅析（4）

本文来自网易云社区

作者：孙有军

scanPackageLI主要调用了scanPackageDirtyLI，如果调用失败则调用removeDataDirsLI来移除安装信息，scanPackageDirtyLI的代码如下：

private PackageParser.Package scanPackageDirtyLI(PackageParser.Package pkg, int parseFlags,
        int scanFlags, long currentTime, UserHandle user) throws PackageManagerException {
    final File scanFile = new File(pkg.codePath);
    ............
    if (pkg.packageName.equals("android")) {
       .............
    }

    ................

    // Initialize package source and resource directories
    File destCodeFile = new File(pkg.applicationInfo.getCodePath());
    File destResourceFile = new File(pkg.applicationInfo.getResourcePath());

    SharedUserSetting suid = null;
    PackageSetting pkgSetting = null;


    // writer
    synchronized (mPackages) {

        // Check if we are renaming from an original package name.
        PackageSetting origPackage = null;
        String realName = null;
        if (pkg.mOriginalPackages != null) {
            // This package may need to be renamed to a previously
            // installed name.  Let's check on that...
            final String renamed = mSettings.mRenamedPackages.get(pkg.mRealPackage);
            if (pkg.mOriginalPackages.contains(renamed)) {
                // This package had originally been installed as the
                // original name, and we have already taken care of
                // transitioning to the new one.  Just update the new
                // one to continue using the old name.
                realName = pkg.mRealPackage;
                if (!pkg.packageName.equals(renamed)) {
                    // Callers into this function may have already taken
                    // care of renaming the package; only do it here if
                    // it is not already done.
                    pkg.setPackageName(renamed);
                }

            } else {
                for (int i=pkg.mOriginalPackages.size()-1; i>=0; i--) {
                    if ((origPackage = mSettings.peekPackageLPr(
                            pkg.mOriginalPackages.get(i))) != null) {
                        // We do have the package already installed under its
                        // original name...  should we use it?
                        if (!verifyPackageUpdateLPr(origPackage, pkg)) {
                            // New package is not compatible with original.
                            origPackage = null;
                            continue;
                        } else if (origPackage.sharedUser != null) {
                            // Make sure uid is compatible between packages.
                            if (!origPackage.sharedUser.name.equals(pkg.mSharedUserId)) {
                                Slog.w(TAG, "Unable to migrate data from " + origPackage.name
                                        + " to " + pkg.packageName + ": old uid "
                                        + origPackage.sharedUser.name
                                        + " differs from " + pkg.mSharedUserId);
                                origPackage = null;
                                continue;
                            }
                        } else {
                            if (DEBUG_UPGRADE) Log.v(TAG, "Renaming new package "
                                    + pkg.packageName + " to old name " + origPackage.name);
                        }
                        break;
                    }
                }
            }
        }

         .........
        // Just create the setting, don't add it yet. For already existing packages
        // the PkgSetting exists already and doesn't have to be created.
        pkgSetting = mSettings.getPackageLPw(pkg, origPackage, realName, suid, destCodeFile,
                destResourceFile, pkg.applicationInfo.nativeLibraryRootDir,
                pkg.applicationInfo.primaryCpuAbi,
                pkg.applicationInfo.secondaryCpuAbi,
                pkg.applicationInfo.flags, pkg.applicationInfo.privateFlags,
                user, false);
       ...............
        if ((parseFlags&PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
            // Check all shared libraries and map to their actual file path.
            // We only do this here for apps not on a system dir, because those
            // are the only ones that can fail an install due to this.  We
            // will take care of the system apps by updating all of their
            // library paths after the scan is done.
            updateSharedLibrariesLPw(pkg, null);
        }
        pkg.applicationInfo.uid = pkgSetting.appId;
        pkg.mExtras = pkgSetting;
        if (shouldCheckUpgradeKeySetLP(pkgSetting, scanFlags)) {
            if (checkUpgradeKeySetLP(pkgSetting, pkg)) {
                // We just determined the app is signed correctly, so bring
                // over the latest parsed certs.
                pkgSetting.signatures.mSignatures = pkg.mSignatures;
            } else {
                if ((parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
                    throw new PackageManagerException(INSTALL_FAILED_UPDATE_INCOMPATIBLE,
                            "Package " + pkg.packageName + " upgrade keys do not match the "
                            + "previously installed version");
                } else {
                    pkgSetting.signatures.mSignatures = pkg.mSignatures;
                    String msg = "System package " + pkg.packageName
                        + " signature changed; retaining data.";
                    reportSettingsProblem(Log.WARN, msg);
                }
            }
        } else {
            try {
                verifySignaturesLP(pkgSetting, pkg);
                // We just determined the app is signed correctly, so bring
                // over the latest parsed certs.
                pkgSetting.signatures.mSignatures = pkg.mSignatures;
            } catch (PackageManagerException e) {

            }
        }
        // Verify that this new package doesn't have any content providers
        // that conflict with existing packages.  Only do this if the
        // package isn't already installed, since we don't want to break
        // things that are installed.
        if ((scanFlags & SCAN_NEW_INSTALL) != 0) {
            final int N = pkg.providers.size();
            int i;
            for (i=0; i<N; i++) {
                PackageParser.Provider p = pkg.providers.get(i);
                if (p.info.authority != null) {
                    String names[] = p.info.authority.split(";");
                    for (int j = 0; j < names.length; j++) {
                        if (mProvidersByAuthority.containsKey(names[j])) {
                            PackageParser.Provider other = mProvidersByAuthority.get(names[j]);
                            final String otherPackageName =
                                    ((other != null && other.getComponentName() != null) ?
                                            other.getComponentName().getPackageName() : "?");
                            throw new PackageManagerException(
                                    INSTALL_FAILED_CONFLICTING_PROVIDER,
                                            "Can't install because provider name " + names[j]
                                            + " (in package " + pkg.applicationInfo.packageName
                                            + ") is already used by " + otherPackageName);
                        }
                    }
                }
            }
        }

        if (pkg.mAdoptPermissions != null) {
            // This package wants to adopt ownership of permissions from
            // another package.
            for (int i = pkg.mAdoptPermissions.size() - 1; i >= 0; i--) {
                final String origName = pkg.mAdoptPermissions.get(i);
                final PackageSetting orig = mSettings.peekPackageLPr(origName);
                if (orig != null) {
                    if (verifyPackageUpdateLPr(orig, pkg)) {
                        Slog.i(TAG, "Adopting permissions from " + origName + " to "
                                + pkg.packageName);
                        mSettings.transferPermissionsLPw(origName, pkg.packageName);
                    }
                }
            }
        }
    }

      ..........

    File dataPath;
    if (mPlatformPackage == pkg) {
        // The system package is special.
        dataPath = new File(Environment.getDataDirectory(), "system");

        pkg.applicationInfo.dataDir = dataPath.getPath();

    } else {
        // This is a normal package, need to make its data directory.
        dataPath = Environment.getDataUserPackageDirectory(pkg.volumeUuid,
                UserHandle.USER_OWNER, pkg.packageName);

        boolean uidError = false;
        if (dataPath.exists()) {
            int currentUid = 0;
            try {
                StructStat stat = Os.stat(dataPath.getPath());
                currentUid = stat.st_uid;
            } catch (ErrnoException e) {
                Slog.e(TAG, "Couldn't stat path " + dataPath.getPath(), e);
            }

            // If we have mismatched owners for the data path, we have a problem.
            if (currentUid != pkg.applicationInfo.uid) {
                boolean recovered = false;
                if (currentUid == 0) {
                    // The directory somehow became owned by root.  Wow.
                    // This is probably because the system was stopped while
                    // installd was in the middle of messing with its libs
                    // directory.  Ask installd to fix that.
                    int ret = mInstaller.fixUid(pkg.volumeUuid, pkgName,
                            pkg.applicationInfo.uid, pkg.applicationInfo.uid);
                    if (ret >= 0) {
                        recovered = true;
                        String msg = "Package " + pkg.packageName
                                + " unexpectedly changed to uid 0; recovered to " +
                                + pkg.applicationInfo.uid;
                        reportSettingsProblem(Log.WARN, msg);
                    }
                }
                if (!recovered && ((parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0
                        || (scanFlags&SCAN_BOOTING) != 0)) {
                    // If this is a system app, we can at least delete its
                    // current data so the application will still work.
                    int ret = removeDataDirsLI(pkg.volumeUuid, pkgName);
                    if (ret >= 0) {
                        // TODO: Kill the processes first
                        // Old data gone!
                        String prefix = (parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0
                                ? "System package " : "Third party package ";
                        String msg = prefix + pkg.packageName
                                + " has changed from uid: "
                                + currentUid + " to "
                                + pkg.applicationInfo.uid + "; old data erased";
                        reportSettingsProblem(Log.WARN, msg);
                        recovered = true;

                        // And now re-install the app.
                        ret = createDataDirsLI(pkg.volumeUuid, pkgName, pkg.applicationInfo.uid,
                                pkg.applicationInfo.seinfo);
                        if (ret == -1) {
                            // Ack should not happen!
                            msg = prefix + pkg.packageName
                                    + " could not have data directory re-created after delete.";
                            reportSettingsProblem(Log.WARN, msg);
                            throw new PackageManagerException(
                                    INSTALL_FAILED_INSUFFICIENT_STORAGE, msg);
                        }
                    }
                    if (!recovered) {
                        mHasSystemUidErrors = true;
                    }
                }
                ..............
            }
            pkg.applicationInfo.dataDir = dataPath.getPath();
            if (mShouldRestoreconData) {
                Slog.i(TAG, "SELinux relabeling of " + pkg.packageName + " issued.");
                mInstaller.restoreconData(pkg.volumeUuid, pkg.packageName,
                        pkg.applicationInfo.seinfo, pkg.applicationInfo.uid);
            }
        } else {
            if (DEBUG_PACKAGE_SCANNING) {
                if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
                    Log.v(TAG, "Want this data dir: " + dataPath);
            }
            //invoke installer to do the actual installation
            int ret = createDataDirsLI(pkg.volumeUuid, pkgName, pkg.applicationInfo.uid,
                    pkg.applicationInfo.seinfo);
            ..................
        }

        pkgSetting.uidError = uidError;
    }

    final String path = scanFile.getPath();
    final String cpuAbiOverride = deriveAbiOverride(pkg.cpuAbiOverride, pkgSetting);

    if ((scanFlags & SCAN_NEW_INSTALL) == 0) {
        derivePackageAbi(pkg, scanFile, cpuAbiOverride, true /* extract libs */);

        // Some system apps still use directory structure for native libraries
        // in which case we might end up not detecting abi solely based on apk
        // structure. Try to detect abi based on directory structure.
        if (isSystemApp(pkg) && !pkg.isUpdatedSystemApp() &&
                pkg.applicationInfo.primaryCpuAbi == null) {
            setBundledAppAbisAndRoots(pkg, pkgSetting);
            setNativeLibraryPaths(pkg);
        }

    } else {

        // Set native library paths again. For moves, the path will be updated based on the
        // ABIs we've determined above. For non-moves, the path will be updated based on the
        // ABIs we determined during compilation, but the path will depend on the final
        // package path (after the rename away from the stage path).
        setNativeLibraryPaths(pkg);
    }

    if (DEBUG_INSTALL) Slog.i(TAG, "Linking native library dir for " + path);
    final int[] userIds = sUserManager.getUserIds();
    synchronized (mInstallLock) {
        // Make sure all user data directories are ready to roll; we're okay
        // if they already exist
        if (!TextUtils.isEmpty(pkg.volumeUuid)) {
            for (int userId : userIds) {
                if (userId != 0) {
                    mInstaller.createUserData(pkg.volumeUuid, pkg.packageName,
                            UserHandle.getUid(userId, pkg.applicationInfo.uid), userId,
                            pkg.applicationInfo.seinfo);
                }
            }
        }

        // Create a native library symlink only if we have native libraries
        // and if the native libraries are 32 bit libraries. We do not provide
        // this symlink for 64 bit libraries.
        if (pkg.applicationInfo.primaryCpuAbi != null &&
                !VMRuntime.is64BitAbi(pkg.applicationInfo.primaryCpuAbi)) {
            final String nativeLibPath = pkg.applicationInfo.nativeLibraryDir;
            for (int userId : userIds) {
                if (mInstaller.linkNativeLibraryDirectory(pkg.volumeUuid, pkg.packageName,
                        nativeLibPath, userId) < 0) {
                    throw new PackageManagerException(INSTALL_FAILED_INTERNAL_ERROR,
                            "Failed linking native library dir (user=" + userId + ")");
                }
            }
        }
    }
    .............
    ArrayList<PackageParser.Package> clientLibPkgs = null;

    // We also need to dexopt any apps that are dependent on this library.  Note that
    // if these fail, we should abort the install since installing the library will
    // result in some apps being broken.
    if (clientLibPkgs != null) {
        if ((scanFlags & SCAN_NO_DEX) == 0) {
            for (int i = 0; i < clientLibPkgs.size(); i++) {
                PackageParser.Package clientPkg = clientLibPkgs.get(i);
                int result = mPackageDexOptimizer.performDexOpt(clientPkg,
                        null /* instruction sets */, forceDex,
                        (scanFlags & SCAN_DEFER_DEX) != 0, false);
                if (result == PackageDexOptimizer.DEX_OPT_FAILED) {
                    throw new PackageManagerException(INSTALL_FAILED_DEXOPT,
                            "scanPackageLI failed to dexopt clientLibPkgs");
                }
            }
        }
    }

    // Request the ActivityManager to kill the process(only for existing packages)
    // so that we do not end up in a confused state while the user is still using the older
    // version of the application while the new one gets installed.
    if ((scanFlags & SCAN_REPLACING) != 0) {
        killApplication(pkg.applicationInfo.packageName,
                    pkg.applicationInfo.uid, "replace pkg");
    }

    // Also need to kill any apps that are dependent on the library.
    if (clientLibPkgs != null) {
        for (int i=0; i<clientLibPkgs.size(); i++) {
            PackageParser.Package clientPkg = clientLibPkgs.get(i);
            killApplication(clientPkg.applicationInfo.packageName,
                    clientPkg.applicationInfo.uid, "update lib");
        }
    }

    // Make sure we're not adding any bogus keyset info
    KeySetManagerService ksms = mSettings.mKeySetManagerService;
    ksms.assertScannedPackageValid(pkg);

网易云免费体验馆，0成本体验20+款云产品！ 

更多网易研发、产品、运营经验分享请访问网易云社区。