Java DexFile.loadDex方法代码示例

import dalvik.system.DexFile; //导入方法依赖的package包/类
static public DexFile loadDex(Context context, String sourcePathName, String outputPathName,
                              int flags) throws Exception {
    if(Build.VERSION.SDK_INT<=15) {
        return DexFile.loadDex(sourcePathName,outputPathName,flags);
    }else{
        DexFile dexFile = DexFile.loadDex(context.getApplicationInfo().sourceDir,null,0);
        try {
            int cookie = (int)openDexFile.invoke(null,sourcePathName,outputPathName,flags);
            mFileName.set(dexFile,sourcePathName);
            mCookie.set(dexFile,cookie);
        } catch (Exception e) {
            throw  e;
        }
        return dexFile;
    }
}
 

import dalvik.system.DexFile; //导入方法依赖的package包/类
private static void install(ClassLoader loader, List<File> additionalClassPathEntries) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, IOException {
    int extraSize = additionalClassPathEntries.size();
    Field pathField = MultiDex.findField(loader, "path");
    StringBuilder path = new StringBuilder((String) pathField.get(loader));
    String[] extraPaths = new String[extraSize];
    File[] extraFiles = new File[extraSize];
    ZipFile[] extraZips = new ZipFile[extraSize];
    DexFile[] extraDexs = new DexFile[extraSize];
    ListIterator<File> iterator = additionalClassPathEntries.listIterator();
    while (iterator.hasNext()) {
        File additionalEntry = (File) iterator.next();
        String entryPath = additionalEntry.getAbsolutePath();
        path.append(':').append(entryPath);
        int index = iterator.previousIndex();
        extraPaths[index] = entryPath;
        extraFiles[index] = additionalEntry;
        extraZips[index] = new ZipFile(additionalEntry);
        extraDexs[index] = DexFile.loadDex(entryPath, entryPath + ".dex", 0);
    }
    pathField.set(loader, path.toString());
    MultiDex.expandFieldArray(loader, "mPaths", extraPaths);
    MultiDex.expandFieldArray(loader, "mFiles", extraFiles);
    MultiDex.expandFieldArray(loader, "mZips", extraZips);
    MultiDex.expandFieldArray(loader, "mDexs", extraDexs);
}
 

import dalvik.system.DexFile; //导入方法依赖的package包/类
public void loadClasses() throws IOException,
                                 ClassNotFoundException,
                                 IllegalAccessException,
                                 InstantiationException {
    DexFile dexFile = DexFile.loadDex(this.jarpath, File.createTempFile("opt", "dex", this.context.getCacheDir()).getPath(),
            0);


    String className = "";
    for(Enumeration<String> classNames =  dexFile.entries(); classNames.hasMoreElements();
        className = classNames.nextElement()) {

        if(!className.isEmpty()) {

            //Remove partial classes <class>$1..
            if(className.contains("$"))
                className = className.substring(0, className.indexOf("$"));

            this.loadClass(className);
        }
    }
}
 

import dalvik.system.DexFile; //导入方法依赖的package包/类
private static void install(ClassLoader loader, List<File> additionalClassPathEntries) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, IOException {
    int extraSize = additionalClassPathEntries.size();
    Field pathField = MultiDex.findField(loader, "path");
    StringBuilder path = new StringBuilder((String) pathField.get(loader));
    String[] extraPaths = new String[extraSize];
    File[] extraFiles = new File[extraSize];
    ZipFile[] extraZips = new ZipFile[extraSize];
    DexFile[] extraDexs = new DexFile[extraSize];
    ListIterator<File> iterator = additionalClassPathEntries.listIterator();
    while (iterator.hasNext()) {
        File additionalEntry = (File) iterator.next();
        String entryPath = additionalEntry.getAbsolutePath();
        path.append(':').append(entryPath);
        int index = iterator.previousIndex();
        extraPaths[index] = entryPath;
        extraFiles[index] = additionalEntry;
        extraZips[index] = new ZipFile(additionalEntry);
        extraDexs[index] = DexFile.loadDex(entryPath, entryPath + ShareConstants.DEX_SUFFIX, 0);
    }
    pathField.set(loader, path.toString());
    MultiDex.expandFieldArray(loader, "mPaths", extraPaths);
    MultiDex.expandFieldArray(loader, "mFiles", extraFiles);
    MultiDex.expandFieldArray(loader, "mZips", extraZips);
    MultiDex.expandFieldArray(loader, "mDexs", extraDexs);
}
 

import dalvik.system.DexFile; //导入方法依赖的package包/类
public void describeDexContents() {
    if(!initialized) {
        Log.w(TAG, "Dexter not initialized");
        return;
    }

    Log.d(TAG, "Describing dex file " + getDexInternalStoragePath().getPath() + ", " + getDexInternalStoragePath().getAbsolutePath());
    try {
        DexFile dx = DexFile.loadDex(
                getDexInternalStoragePath().getAbsolutePath(),
                File.createTempFile("opt", "dex", mContext.getCacheDir()).getPath(),
                0);

        for(Enumeration<String> classNames = dx.entries(); classNames.hasMoreElements();) {
            String className = classNames.nextElement();
            Log.d(TAG, "class in dex: " + className);
        }
    }
    catch (IOException e) {
        Log.w(TAG, "Error opening " + getDexInternalStoragePath().getAbsolutePath(), e);
    }
}
 

import dalvik.system.DexFile; //导入方法依赖的package包/类
private DexFile dexJar() throws IOException {
    if (!classFile.exists()) {
        classFile.createNewFile();
    }
    final Main.Arguments arguments = new Main.Arguments();
    arguments.fileNames = new String[]{classFile.getPath()};
    arguments.outName = dexFile.getPath();
    arguments.jarOutput = true;
    Main.run(arguments);
    DexFile dex = DexFile.loadDex(dexFile.getPath(), odexOatFile.getPath(), 0);
    dx.add(dex);
    return dex;
}
 

import dalvik.system.DexFile; //导入方法依赖的package包/类
public boolean run() {
    try {
        if (!SharePatchFileUtil.isLegalFile(dexFile)) {
            if (callback != null) {
                callback.onFailed(dexFile, optimizedDir,
                    new IOException("dex file " + dexFile.getAbsolutePath() + " is not exist!"));
                return false;
            }
        }
        if (callback != null) {
            callback.onStart(dexFile, optimizedDir);
        }
        String optimizedPath = SharePatchFileUtil.optimizedPathFor(this.dexFile, this.optimizedDir);
        if (useInterpretMode) {
            interpretDex2Oat(dexFile.getAbsolutePath(), optimizedPath);
        } else {
            DexFile.loadDex(dexFile.getAbsolutePath(), optimizedPath, 0);
        }
        if (callback != null) {
            callback.onSuccess(dexFile, optimizedDir, new File(optimizedPath));
        }
    } catch (final Throwable e) {
        Log.e(TAG, "Failed to optimize dex: " + dexFile.getAbsolutePath(), e);
        if (callback != null) {
            callback.onFailed(dexFile, optimizedDir, e);
            return false;
        }
    }
    return true;
}
 

import dalvik.system.DexFile; //导入方法依赖的package包/类
private static void install(ClassLoader loader,
        List<? extends File> additionalClassPathEntries)
                throws IllegalArgumentException, IllegalAccessException,
                NoSuchFieldException, IOException {
    /* The patched class loader is expected to be a descendant of
     * dalvik.system.DexClassLoader. We modify its
     * fields mPaths, mFiles, mZips and mDexs to append additional DEX
     * file entries.
     */
    int extraSize = additionalClassPathEntries.size();

    Field pathField = findField(loader, "path");

    StringBuilder path = new StringBuilder((String) pathField.get(loader));
    String[] extraPaths = new String[extraSize];
    File[] extraFiles = new File[extraSize];
    ZipFile[] extraZips = new ZipFile[extraSize];
    DexFile[] extraDexs = new DexFile[extraSize];
    for (ListIterator<? extends File> iterator = additionalClassPathEntries.listIterator();
            iterator.hasNext();) {
        File additionalEntry = iterator.next();
        String entryPath = additionalEntry.getAbsolutePath();
        path.append(':').append(entryPath);
        int index = iterator.previousIndex();
        extraPaths[index] = entryPath;
        extraFiles[index] = additionalEntry;
        extraZips[index] = new ZipFile(additionalEntry);
        extraDexs[index] = DexFile.loadDex(entryPath, entryPath + ".dex", 0);
    }

    pathField.set(loader, path.toString());
    expandFieldArray(loader, "mPaths", extraPaths);
    expandFieldArray(loader, "mFiles", extraFiles);
    expandFieldArray(loader, "mZips", extraZips);
    expandFieldArray(loader, "mDexs", extraDexs);
}
 

import dalvik.system.DexFile; //导入方法依赖的package包/类
private static void install(ClassLoader loader, List<File> additionalClassPathEntries,
                            File optimizedDirectory) throws IllegalArgumentException,
        IllegalAccessException, NoSuchFieldException, IOException {
    int extraSize = additionalClassPathEntries.size();
    Field pathField = ShareReflectUtil.findField((Object) loader, "path");
    StringBuilder path = new StringBuilder((String) pathField.get(loader));
    String[] extraPaths = new String[extraSize];
    File[] extraFiles = new File[extraSize];
    ZipFile[] extraZips = new ZipFile[extraSize];
    DexFile[] extraDexs = new DexFile[extraSize];
    ListIterator<File> iterator = additionalClassPathEntries.listIterator();
    while (iterator.hasNext()) {
        File additionalEntry = (File) iterator.next();
        String entryPath = additionalEntry.getAbsolutePath();
        path.append(':').append(entryPath);
        int index = iterator.previousIndex();
        extraPaths[index] = entryPath;
        extraFiles[index] = additionalEntry;
        extraZips[index] = new ZipFile(additionalEntry);
        extraDexs[index] = DexFile.loadDex(entryPath, SharePatchFileUtil.optimizedPathFor
                (additionalEntry, optimizedDirectory), 0);
    }
    pathField.set(loader, path.toString());
    ShareReflectUtil.expandFieldArray(loader, "mPaths", extraPaths);
    ShareReflectUtil.expandFieldArray(loader, "mFiles", extraFiles);
    ShareReflectUtil.expandFieldArray(loader, "mZips", extraZips);
    try {
        ShareReflectUtil.expandFieldArray(loader, "mDexs", extraDexs);
    } catch (Exception e) {
    }
}
 

import dalvik.system.DexFile; //导入方法依赖的package包/类
private static boolean patchDexExtractViaDexDiff(Context context, String
        patchVersionDirectory, String meta, File patchFile, boolean isUpgradePatch) {
    String dir = patchVersionDirectory + "/" + ShareConstants.DEX_PATH + "/";
    if (extractDexDiffInternals(context, dir, meta, patchFile, ShareTinkerInternals.isVmArt()
            ? 4 : 3, isUpgradePatch)) {
        Tinker manager = Tinker.with(context);
        File[] files = new File(dir).listFiles();
        if (files != null) {
            String optimizeDexDirectory = patchVersionDirectory + "/" + ShareConstants
                    .DEX_OPTIMIZE_PATH + "/";
            File file = new File(optimizeDexDirectory);
            if (!file.exists()) {
                file.mkdirs();
            }
            int length = files.length;
            int i = 0;
            while (i < length) {
                File file2 = files[i];
                try {
                    String outputPathName = SharePatchFileUtil.optimizedPathFor(file2, file);
                    long start = System.currentTimeMillis();
                    DexFile.loadDex(file2.getAbsolutePath(), outputPathName, 0);
                    TinkerLog.i(TAG, "success dex optimize file, path: %s, use time: %d",
                            file2.getPath(), Long.valueOf(System.currentTimeMillis() - start));
                    i++;
                } catch (Throwable e) {
                    TinkerLog.e(TAG, "dex optimize or load failed, path:" + file2.getPath(),
                            new Object[0]);
                    SharePatchFileUtil.safeDeleteFile(file2);
                    manager.getPatchReporter().onPatchDexOptFail(patchFile, file2,
                            optimizeDexDirectory, file2.getName(), e, isUpgradePatch);
                    return false;
                }
            }
        }
        return true;
    }
    TinkerLog.w(TAG, "patch recover, extractDiffInternals fail", new Object[0]);
    return false;
}
 

import dalvik.system.DexFile; //导入方法依赖的package包/类
private static void install(ClassLoader loader, List<File> additionalClassPathEntries)
                throws IllegalArgumentException, IllegalAccessException,
                NoSuchFieldException, IOException {
    /* The patched class loader is expected to be a descendant of
     * dalvik.system.DexClassLoader. We modify its
     * fields mPaths, mFiles, mZips and mDexs to append additional DEX
     * file entries.
     */
    int extraSize = additionalClassPathEntries.size();

    Field pathField = findField(loader, "path");

    StringBuilder path = new StringBuilder((String) pathField.get(loader));
    String[] extraPaths = new String[extraSize];
    File[] extraFiles = new File[extraSize];
    ZipFile[] extraZips = new ZipFile[extraSize];
    DexFile[] extraDexs = new DexFile[extraSize];
    for (ListIterator<File> iterator = additionalClassPathEntries.listIterator();
            iterator.hasNext();) {
        File additionalEntry = iterator.next();
        String entryPath = additionalEntry.getAbsolutePath();
        path.append(':').append(entryPath);
        int index = iterator.previousIndex();
        extraPaths[index] = entryPath;
        extraFiles[index] = additionalEntry;
        extraZips[index] = new ZipFile(additionalEntry);
        extraDexs[index] = DexFile.loadDex(entryPath, entryPath + ".dex", 0);
    }

    pathField.set(loader, path.toString());
    expandFieldArray(loader, "mPaths", extraPaths);
    expandFieldArray(loader, "mFiles", extraFiles);
    expandFieldArray(loader, "mZips", extraZips);
    expandFieldArray(loader, "mDexs", extraDexs);
}
 

import dalvik.system.DexFile; //导入方法依赖的package包/类
private static void install(ClassLoader loader, List<File> additionalClassPathEntries)
        throws IllegalArgumentException, IllegalAccessException,
        NoSuchFieldException, IOException {
    /* The patched class loader is expected to be a descendant of
     * dalvik.system.DexClassLoader. We modify its
     * fields mPaths, mFiles, mZips and mDexs to append additional DEX
     * file entries.
     */
    int extraSize = additionalClassPathEntries.size();

    Field pathField = RocooUtils.findField(loader, "path");

    StringBuilder path = new StringBuilder((String) pathField.get(loader));
    String[] extraPaths = new String[extraSize];
    File[] extraFiles = new File[extraSize];
    ZipFile[] extraZips = new ZipFile[extraSize];
    DexFile[] extraDexs = new DexFile[extraSize];
    for (ListIterator<File> iterator = additionalClassPathEntries.listIterator();
         iterator.hasNext(); ) {
        File additionalEntry = iterator.next();
        String entryPath = additionalEntry.getAbsolutePath();
        path.append(':').append(entryPath);
        int index = iterator.previousIndex();
        extraPaths[index] = entryPath;
        extraFiles[index] = additionalEntry;
        extraZips[index] = new ZipFile(additionalEntry);
        extraDexs[index] = DexFile.loadDex(entryPath, entryPath + ".dex", 0);
    }

    pathField.set(loader, path.toString());
    RocooUtils.expandFieldArray(loader, "mPaths", extraPaths);
    RocooUtils.expandFieldArray(loader, "mFiles", extraFiles);
    RocooUtils.expandFieldArray(loader, "mZips", extraZips);
    RocooUtils.expandFieldArray(loader, "mDexs", extraDexs);
}
 

import dalvik.system.DexFile; //导入方法依赖的package包/类
private static void install(ClassLoader loader,
		List<File> additionalClassPathEntries)
		throws IllegalArgumentException, IllegalAccessException,
		NoSuchFieldException, IOException {
	/*
	 * The patched class loader is expected to be a descendant of
	 * dalvik.system.DexClassLoader. We modify its fields mPaths,
	 * mFiles, mZips and mDexs to append additional DEX file entries.
	 */
	int extraSize = additionalClassPathEntries.size();

	Field pathField = findField(loader, "path");

	StringBuilder path = new StringBuilder(
			(String) pathField.get(loader));
	String[] extraPaths = new String[extraSize];
	File[] extraFiles = new File[extraSize];
	ZipFile[] extraZips = new ZipFile[extraSize];
	DexFile[] extraDexs = new DexFile[extraSize];
	for (ListIterator<File> iterator = additionalClassPathEntries
			.listIterator(); iterator.hasNext();) {
		File additionalEntry = iterator.next();
		String entryPath = additionalEntry.getAbsolutePath();
		path.append(':').append(entryPath);
		int index = iterator.previousIndex();
		extraPaths[index] = entryPath;
		extraFiles[index] = additionalEntry;
		extraZips[index] = new ZipFile(additionalEntry);
		extraDexs[index] = DexFile.loadDex(entryPath, entryPath
				+ ".dex", 0);
	}

	pathField.set(loader, path.toString());
	expandFieldArray(loader, "mPaths", extraPaths);
	expandFieldArray(loader, "mFiles", extraFiles);
	expandFieldArray(loader, "mZips", extraZips);
	expandFieldArray(loader, "mDexs", extraDexs);
}
 

import dalvik.system.DexFile; //导入方法依赖的package包/类
private static void install(ClassLoader loader, List<File> additionalClassPathEntries)
        throws IllegalArgumentException, IllegalAccessException,
        NoSuchFieldException, IOException {
    int extraSize = additionalClassPathEntries.size();

    Field pathField = findField(loader, "path");

    StringBuilder path = new StringBuilder((String) pathField.get(loader));
    String[] extraPaths = new String[extraSize];
    File[] extraFiles = new File[extraSize];
    ZipFile[] extraZips = new ZipFile[extraSize];
    DexFile[] extraDexs = new DexFile[extraSize];
    for (ListIterator<File> iterator = additionalClassPathEntries.listIterator();
         iterator.hasNext();) {
        File additionalEntry = iterator.next();
        String entryPath = additionalEntry.getAbsolutePath();
        path.append(':').append(entryPath);
        int index = iterator.previousIndex();
        extraPaths[index] = entryPath;
        extraFiles[index] = additionalEntry;
        extraZips[index] = new ZipFile(additionalEntry);
        extraDexs[index] = DexFile.loadDex(entryPath, entryPath + ".dex", 0);
    }

    pathField.set(loader, path.toString());
    expandFieldArray(loader, "mPaths", extraPaths);
    expandFieldArray(loader, "mFiles", extraFiles);
    expandFieldArray(loader, "mZips", extraZips);
    expandFieldArray(loader, "mDexs", extraDexs);
}
 

import dalvik.system.DexFile; //导入方法依赖的package包/类
private static void install(ClassLoader loader,
        List<? extends File> additionalClassPathEntries)
                throws IllegalArgumentException, IllegalAccessException,
        NoSuchFieldException, IOException {
    /* The patched class loader is expected to be a descendant of
     * dalvik.system.DexClassLoader. We modify its
     * fields mPaths, mFiles, mZips and mDexs to append additional DEX
     * file entries.
     */
    int extraSize = additionalClassPathEntries.size();

    Field pathField = findField(loader, "path");

    StringBuilder path = new StringBuilder((String) pathField.get(loader));
    String[] extraPaths = new String[extraSize];
    File[] extraFiles = new File[extraSize];
    ZipFile[] extraZips = new ZipFile[extraSize];
    DexFile[] extraDexs = new DexFile[extraSize];
    for (ListIterator<? extends File> iterator = additionalClassPathEntries.listIterator();
         iterator.hasNext();) {
        File additionalEntry = iterator.next();
        String entryPath = additionalEntry.getAbsolutePath();
        path.append(':').append(entryPath);
        int index = iterator.previousIndex();
        extraPaths[index] = entryPath;
        extraFiles[index] = additionalEntry;
        extraZips[index] = new ZipFile(additionalEntry);
        extraDexs[index] = DexFile.loadDex(entryPath, entryPath + ".dex", 0);
    }

    pathField.set(loader, path.toString());
    expandFieldArray(loader, "mPaths", extraPaths);
    expandFieldArray(loader, "mFiles", extraFiles);
    expandFieldArray(loader, "mZips", extraZips);
    expandFieldArray(loader, "mDexs", extraDexs);
}