chrome/android/webapk/libs/client/src/org/chromium/webapk/lib/client/DexOptimizer.java

// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package org.chromium.webapk.lib.client;

import android.os.Build;
import android.util.Log;

import dalvik.system.DexClassLoader;
import dalvik.system.DexFile;

import org.chromium.base.annotations.SuppressFBWarnings;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * This class provides a method to optimize .dex files.
 * Note: This class is copied (mostly) verbatim from DexOptUtils in GMSCore.
 */
public class DexOptimizer {
    private static final String TAG = "cr_DexOptimzer";

    private static final String DEX_SUFFIX = ".dex";
    private static final String ODEX_SUFFIX = ".odex";

    /**
     * Creates optimized odex file for the specified dex file.
     * @param dexFile Path to a dex file.
     * @return True if the dex file was successfully optimized.
     */
    @SuppressFBWarnings("DP_CREATE_CLASSLOADER_INSIDE_DO_PRIVILEGED")
    public static boolean optimize(File dexFile) {
        if (!dexFile.exists()) {
            Log.e(TAG, "Dex file does not exist! " + dexFile.getAbsolutePath());
            return false;
        }

        try {
            if (!DexFile.isDexOptNeeded(dexFile.getAbsolutePath())) {
                return true;
            }
        } catch (Exception e) {
            Log.e(TAG, "Failed to check optimization status: " + e.toString() + " : "
                            + e.getMessage());
        }

        File odexDir = null;
        try {
            odexDir = ensureOdexDirectory(dexFile);
        } catch (IOException e) {
            Log.e(TAG, "Failed to create odex directory! " + e.getMessage());
            return false;
        }

        File generatedDexDir = odexDir;
        if (generatedDexDir.equals(dexFile.getParentFile())) {
            generatedDexDir = new File(odexDir, "optimized");
            if (!generatedDexDir.exists() && !generatedDexDir.mkdirs()) {
                return false;
            }
        }

        new DexClassLoader(
                dexFile.getAbsolutePath(),
                generatedDexDir.getAbsolutePath(),
                null,
                ClassLoader.getSystemClassLoader());
        File optimizedFile = new File(generatedDexDir, dexFile.getName());
        if (!optimizedFile.exists()) {
            Log.e(TAG, "Failed to create dex.");
            return false;
        }

        File destOdexFile = new File(odexDir, replaceExtension(optimizedFile.getName(), "odex"));
        if (!optimizedFile.renameTo(destOdexFile)) {
            Log.e(TAG, "Failed to rename optimized file.");
            return false;
        }

        if (!destOdexFile.setReadable(true, false)) {
            Log.e(TAG, "Failed to make odex world readable.");
            return false;
        }

        return true;
    }

    /**
     * Guesses the directory that DexClassLoader looks in for the odex file based on the
     * Android OS version and the dex path.
     * @param dexPath
     * @return Guess for the default odex directory.
     */
    private static File odexDirectory(File dexPath) {
        int currentApiVersion = Build.VERSION.SDK_INT;
        try {
            if (currentApiVersion >= Build.VERSION_CODES.M) {
                return new File(
                        dexPath.getParentFile(), "oat/" + VMRuntime.getCurrentInstructionSet());
            } else if (currentApiVersion >= Build.VERSION_CODES.LOLLIPOP) {
                return new File(dexPath.getParentFile(), VMRuntime.getCurrentInstructionSet());
            } else {
                return dexPath.getParentFile();
            }
        } catch (NoSuchMethodException e) {
            return null;
        }
    }

    /**
     * Guesses the directory that DexClassLoader looks in for the odex file based on the
     * Android OS version and the dex path. Creates the directory if it does not exist.
     * @param dexPath
     * @return Guess for the default odex directory.
     */
    private static File ensureOdexDirectory(File dexPath) throws IOException {
        File odexDir = odexDirectory(dexPath);
        if (odexDir == null) {
            throw new IOException("Failed to create odex cache directory. "
                    + "Could not determine odex directory.");
        }
        if (!odexDir.exists()) {
            boolean success = odexDir.mkdirs();
            if (!success) {
                throw new IOException(
                        "Failed to create odex cache directory in data directory.");
            }
            // The full path to the odex must be traversable.
            File root = dexPath.getParentFile();
            File dir = odexDir;
            while (dir != null && !root.equals(dir)) {
                if (!dir.setExecutable(true, false)) {
                    throw new IOException("Failed to make odex directory world traversable: "
                            + dir.getAbsolutePath());
                }
                dir = dir.getParentFile();
            }
        }
        return odexDir;
    }

    /**
     * Replaces a file name's extension.
     *
     * @param name File name to modify.
     * @param extension New extension.
     * @return File name with new extension.
     */
    private static String replaceExtension(String name, String extension) {
        int lastDot = name.lastIndexOf(".");
        StringBuilder sb = new StringBuilder(lastDot + extension.length());
        sb.append(name, 0, lastDot + 1);
        sb.append(extension);
        return sb.toString();
    }

    /**
     * Makes use of a hidden API to retrieve the instruction set name for the currently
     * executing process. This string is used to form the directory name for the generated
     * odex.
     *
     * - This API is not available on pre-L devices, but as the pre-L runtime did not scope odex
     *   files by <isa> on pre-L, this is not a problem.
     *
     * - For devices L+, it's still possible for this API to be missing. In that case
     *   we will fallback to A) interpretation, and failing that B) generate an odex in the
     *   client's file space.
     */
    private static class VMRuntime {
        @SuppressWarnings("unchecked")
        public static String getCurrentInstructionSet() throws NoSuchMethodException {
            Method getCurrentInstructionSetMethod;
            try {
                Class c = Class.forName("dalvik.system.VMRuntime");
                getCurrentInstructionSetMethod = c.getDeclaredMethod("getCurrentInstructionSet");
            } catch (ClassNotFoundException | NoSuchMethodException e) {
                Log.w(TAG, "dalvik.system.VMRuntime#getCurrentInstructionSet is unsupported.", e);
                throw new NoSuchMethodException(
                        "dalvik.system.VMRuntime#getCurrentInstructionSet could not be found.");
            }
            try {
                return (String) getCurrentInstructionSetMethod.invoke(null);
            } catch (IllegalAccessException | InvocationTargetException e) {
                Log.w(TAG, "Failed to call dalvik.system.VMRuntime#getCurrentInstructionSet", e);
                throw new NoSuchMethodException(
                        "dalvik.system.VMRuntime#getCurrentInstructionSet could not be found.");
            }
        }
    }
}