Examples with ApkLite android.content.pm.PackageParser.ApkLite used on opensource projects

Example 16 with ApkLite

use of android.content.pm.PackageParser.ApkLite in project android_frameworks_base by DirtyUnicorns.

the class PackageManagerShellCommand method runInstall.

private int runInstall() throws RemoteException {
    final PrintWriter pw = getOutPrintWriter();
    final InstallParams params = makeInstallParams();
    final String inPath = getNextArg();
    boolean installExternal = (params.sessionParams.installFlags & PackageManager.INSTALL_EXTERNAL) != 0;
    if (params.sessionParams.sizeBytes < 0 && inPath != null) {
        File file = new File(inPath);
        if (file.isFile()) {
            if (installExternal) {
                try {
                    ApkLite baseApk = PackageParser.parseApkLite(file, 0);
                    PackageLite pkgLite = new PackageLite(null, baseApk, null, null, null);
                    params.sessionParams.setSize(PackageHelper.calculateInstalledSize(pkgLite, false, params.sessionParams.abiOverride));
                } catch (PackageParserException | IOException e) {
                    pw.println("Error: Failed to parse APK file : " + e);
                    return 1;
                }
            } else {
                params.sessionParams.setSize(file.length());
            }
        }
    }
    final int sessionId = doCreateSession(params.sessionParams, params.installerPackageName, params.userId);
    boolean abandonSession = true;
    try {
        if (inPath == null && params.sessionParams.sizeBytes == 0) {
            pw.println("Error: must either specify a package size or an APK file");
            return 1;
        }
        if (doWriteSplit(sessionId, inPath, params.sessionParams.sizeBytes, "base.apk", false) != PackageInstaller.STATUS_SUCCESS) {
            return 1;
        }
        if (doCommitSession(sessionId, false) != PackageInstaller.STATUS_SUCCESS) {
            return 1;
        }
        abandonSession = false;
        pw.println("Success");
        return 0;
    } finally {
        if (abandonSession) {
            try {
                doAbandonSession(sessionId, false);
            } catch (Exception ignore) {
            }
        }
    }
}

Example 17 with ApkLite

use of android.content.pm.PackageParser.ApkLite in project android_frameworks_base by ResurrectionRemix.

the class PackageInstallerSession method calculateInstalledSize.

/**
     * Calculate the final install footprint size, combining both staged and
     * existing APKs together and including unpacked native code from both.
     */
private long calculateInstalledSize() throws PackageManagerException {
    Preconditions.checkNotNull(mResolvedBaseFile);
    final ApkLite baseApk;
    try {
        baseApk = PackageParser.parseApkLite(mResolvedBaseFile, 0);
    } catch (PackageParserException e) {
        throw PackageManagerException.from(e);
    }
    final List<String> splitPaths = new ArrayList<>();
    for (File file : mResolvedStagedFiles) {
        if (mResolvedBaseFile.equals(file))
            continue;
        splitPaths.add(file.getAbsolutePath());
    }
    for (File file : mResolvedInheritedFiles) {
        if (mResolvedBaseFile.equals(file))
            continue;
        splitPaths.add(file.getAbsolutePath());
    }
    // This is kind of hacky; we're creating a half-parsed package that is
    // straddled between the inherited and staged APKs.
    final PackageLite pkg = new PackageLite(null, baseApk, null, splitPaths.toArray(new String[splitPaths.size()]), null);
    final boolean isForwardLocked = (params.installFlags & PackageManager.INSTALL_FORWARD_LOCK) != 0;
    try {
        return PackageHelper.calculateInstalledSize(pkg, isForwardLocked, params.abiOverride);
    } catch (IOException e) {
        throw new PackageManagerException(INSTALL_FAILED_INVALID_APK, "Failed to calculate install size", e);
    }
}

Example 18 with ApkLite

use of android.content.pm.PackageParser.ApkLite in project android_frameworks_base by crdroidandroid.

the class Pm method runInstall.

/*
     * Keep this around to support existing users of the "pm install" command that may not be
     * able to be updated [or, at least informed the API has changed] such as ddmlib.
     *
     * Moving the implementation of "pm install" to "cmd package install" changes the executing
     * context. Instead of being a stand alone process, "cmd package install" runs in the
     * system_server process. Due to SELinux rules, system_server cannot access many directories;
     * one of which being the package install staging directory [/data/local/tmp].
     *
     * The use of "adb install" or "cmd package install" over "pm install" is highly encouraged.
     */
private int runInstall() throws RemoteException {
    final InstallParams params = makeInstallParams();
    final String inPath = nextArg();
    boolean installExternal = (params.sessionParams.installFlags & PackageManager.INSTALL_EXTERNAL) != 0;
    if (params.sessionParams.sizeBytes < 0 && inPath != null) {
        File file = new File(inPath);
        if (file.isFile()) {
            if (installExternal) {
                try {
                    ApkLite baseApk = PackageParser.parseApkLite(file, 0);
                    PackageLite pkgLite = new PackageLite(null, baseApk, null, null, null);
                    params.sessionParams.setSize(PackageHelper.calculateInstalledSize(pkgLite, false, params.sessionParams.abiOverride));
                } catch (PackageParserException | IOException e) {
                    System.err.println("Error: Failed to parse APK file : " + e);
                    return 1;
                }
            } else {
                params.sessionParams.setSize(file.length());
            }
        }
    }
    final int sessionId = doCreateSession(params.sessionParams, params.installerPackageName, params.userId);
    try {
        if (inPath == null && params.sessionParams.sizeBytes == 0) {
            System.err.println("Error: must either specify a package size or an APK file");
            return 1;
        }
        if (doWriteSession(sessionId, inPath, params.sessionParams.sizeBytes, "base.apk", false) != PackageInstaller.STATUS_SUCCESS) {
            return 1;
        }
        if (doCommitSession(sessionId, false) != PackageInstaller.STATUS_SUCCESS) {
            return 1;
        }
        System.out.println("Success");
        return 0;
    } finally {
        try {
            mInstaller.abandonSession(sessionId);
        } catch (Exception ignore) {
        }
    }
}

Example 19 with ApkLite

use of android.content.pm.PackageParser.ApkLite in project android_frameworks_base by crdroidandroid.

the class PackageInstallerSession method validateInstallLocked.

/**
     * Validate install by confirming that all application packages are have
     * consistent package name, version code, and signing certificates.
     * <p>
     * Clears and populates {@link #mResolvedBaseFile},
     * {@link #mResolvedStagedFiles}, and {@link #mResolvedInheritedFiles}.
     * <p>
     * Renames package files in stage to match split names defined inside.
     * <p>
     * Note that upgrade compatibility is still performed by
     * {@link PackageManagerService}.
     */
private void validateInstallLocked(PackageInfo pkgInfo, ApplicationInfo appInfo) throws PackageManagerException {
    mPackageName = null;
    mVersionCode = -1;
    mSignatures = null;
    mResolvedBaseFile = null;
    mResolvedStagedFiles.clear();
    mResolvedInheritedFiles.clear();
    final File[] removedFiles = mResolvedStageDir.listFiles(sRemovedFilter);
    final List<String> removeSplitList = new ArrayList<>();
    if (!ArrayUtils.isEmpty(removedFiles)) {
        for (File removedFile : removedFiles) {
            final String fileName = removedFile.getName();
            final String splitName = fileName.substring(0, fileName.length() - REMOVE_SPLIT_MARKER_EXTENSION.length());
            removeSplitList.add(splitName);
        }
    }
    final File[] addedFiles = mResolvedStageDir.listFiles(sAddedFilter);
    if (ArrayUtils.isEmpty(addedFiles) && removeSplitList.size() == 0) {
        throw new PackageManagerException(INSTALL_FAILED_INVALID_APK, "No packages staged");
    }
    // Verify that all staged packages are internally consistent
    final ArraySet<String> stagedSplits = new ArraySet<>();
    for (File addedFile : addedFiles) {
        final ApkLite apk;
        try {
            apk = PackageParser.parseApkLite(addedFile, PackageParser.PARSE_COLLECT_CERTIFICATES);
        } catch (PackageParserException e) {
            throw PackageManagerException.from(e);
        }
        if (!stagedSplits.add(apk.splitName)) {
            throw new PackageManagerException(INSTALL_FAILED_INVALID_APK, "Split " + apk.splitName + " was defined multiple times");
        }
        // Use first package to define unknown values
        if (mPackageName == null) {
            mPackageName = apk.packageName;
            mVersionCode = apk.versionCode;
        }
        if (mSignatures == null) {
            mSignatures = apk.signatures;
            mCertificates = apk.certificates;
        }
        assertApkConsistent(String.valueOf(addedFile), apk);
        // Take this opportunity to enforce uniform naming
        final String targetName;
        if (apk.splitName == null) {
            targetName = "base.apk";
        } else {
            targetName = "split_" + apk.splitName + ".apk";
        }
        if (!FileUtils.isValidExtFilename(targetName)) {
            throw new PackageManagerException(INSTALL_FAILED_INVALID_APK, "Invalid filename: " + targetName);
        }
        final File targetFile = new File(mResolvedStageDir, targetName);
        if (!addedFile.equals(targetFile)) {
            addedFile.renameTo(targetFile);
        }
        // Base is coming from session
        if (apk.splitName == null) {
            mResolvedBaseFile = targetFile;
        }
        mResolvedStagedFiles.add(targetFile);
    }
    if (removeSplitList.size() > 0) {
        // validate split names marked for removal
        for (String splitName : removeSplitList) {
            if (!ArrayUtils.contains(pkgInfo.splitNames, splitName)) {
                throw new PackageManagerException(INSTALL_FAILED_INVALID_APK, "Split not found: " + splitName);
            }
        }
        // ensure we've got appropriate package name, version code and signatures
        if (mPackageName == null) {
            mPackageName = pkgInfo.packageName;
            mVersionCode = pkgInfo.versionCode;
        }
        if (mSignatures == null) {
            mSignatures = pkgInfo.signatures;
        }
    }
    if (params.mode == SessionParams.MODE_FULL_INSTALL) {
        // Full installs must include a base package
        if (!stagedSplits.contains(null)) {
            throw new PackageManagerException(INSTALL_FAILED_INVALID_APK, "Full install must include a base package");
        }
    } else {
        // Partial installs must be consistent with existing install
        if (appInfo == null) {
            throw new PackageManagerException(INSTALL_FAILED_INVALID_APK, "Missing existing base package for " + mPackageName);
        }
        final PackageLite existing;
        final ApkLite existingBase;
        try {
            existing = PackageParser.parsePackageLite(new File(appInfo.getCodePath()), 0);
            existingBase = PackageParser.parseApkLite(new File(appInfo.getBaseCodePath()), PackageParser.PARSE_COLLECT_CERTIFICATES);
        } catch (PackageParserException e) {
            throw PackageManagerException.from(e);
        }
        assertApkConsistent("Existing base", existingBase);
        // Inherit base if not overridden
        if (mResolvedBaseFile == null) {
            mResolvedBaseFile = new File(appInfo.getBaseCodePath());
            mResolvedInheritedFiles.add(mResolvedBaseFile);
        }
        // Inherit splits if not overridden
        if (!ArrayUtils.isEmpty(existing.splitNames)) {
            for (int i = 0; i < existing.splitNames.length; i++) {
                final String splitName = existing.splitNames[i];
                final File splitFile = new File(existing.splitCodePaths[i]);
                final boolean splitRemoved = removeSplitList.contains(splitName);
                if (!stagedSplits.contains(splitName) && !splitRemoved) {
                    mResolvedInheritedFiles.add(splitFile);
                }
            }
        }
        // Inherit compiled oat directory.
        final File packageInstallDir = (new File(appInfo.getBaseCodePath())).getParentFile();
        mInheritedFilesBase = packageInstallDir;
        final File oatDir = new File(packageInstallDir, "oat");
        if (oatDir.exists()) {
            final File[] archSubdirs = oatDir.listFiles();
            // instruction set hierarchy and link compiled output.
            if (archSubdirs != null && archSubdirs.length > 0) {
                final String[] instructionSets = InstructionSets.getAllDexCodeInstructionSets();
                for (File archSubDir : archSubdirs) {
                    // Skip any directory that isn't an ISA subdir.
                    if (!ArrayUtils.contains(instructionSets, archSubDir.getName())) {
                        continue;
                    }
                    mResolvedInstructionSets.add(archSubDir.getName());
                    List<File> oatFiles = Arrays.asList(archSubDir.listFiles());
                    if (!oatFiles.isEmpty()) {
                        mResolvedInheritedFiles.addAll(oatFiles);
                    }
                }
            }
        }
    }
}