<?xml version="1.0" encoding="utf-8"?>  
<project name="b" basedir="E:\libs\all" default="makeSuperJar">  
<target name="makeSuperJar"  description="description">  
    <jar destfile="all.jar">  
    	<zipfileset src="http://www.mamicode.com/Android_Location_V1.1.2.jar"/>   
        <zipfileset src="http://www.mamicode.com/Android_Map_2.1.4.jar"/>          
        <zipfileset src="http://www.mamicode.com/Android_Services_2.1.4.jar"/>
        <zipfileset src="http://www.mamicode.com/commons-net-3.3.jar"/>
        <zipfileset src="http://www.mamicode.com/gson-2.2.1.jar"/>
    </jar>  
</target>  
</project>

 1 public class MyApplication extends Application{
 2     
 3     @Override
 4     protected void attachBaseContext(Context base) {
 5         // TODO Auto-generated method stub
 6         super.attachBaseContext(base);
 7         MultiDex.install(this);
 8         
 9     }
10 }

/*
 * Copyright (C) 2013 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.support.multidex;

import android.app.Application;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.Build;
import android.util.Log;

import dalvik.system.DexFile;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.ZipFile;

/**
 * Monkey patches {@link Context#getClassLoader() the application context class
 * loader} in order to load classes from more than one dex file. The primary
 * {@code classes.dex} must contain the classes necessary for calling this
 * class methods. Secondary dex files named classes2.dex, classes3.dex... found
 * in the application apk will be added to the classloader after first call to
 * {@link #install(Context)}.
 *
 * <p/>
 * This library provides compatibility for platforms with API level 4 through 20. This library does
 * nothing on newer versions of the platform which provide built-in support for secondary dex files.
 */
public final class MultiDex {

    static final String TAG = "MultiDex";

    private static final String OLD_SECONDARY_FOLDER_NAME = "secondary-dexes";

    private static final String SECONDARY_FOLDER_NAME = "code_cache" + File.separator +
        "secondary-dexes";

    private static final int MAX_SUPPORTED_SDK_VERSION = 20;

    private static final int MIN_SDK_VERSION = 4;

    private static final int VM_WITH_MULTIDEX_VERSION_MAJOR = 2;

    private static final int VM_WITH_MULTIDEX_VERSION_MINOR = 1;

    private static final Set<String> installedApk = new HashSet<String>();

    private static final boolean IS_VM_MULTIDEX_CAPABLE =
            isVMMultidexCapable(System.getProperty("java.vm.version"));

    private MultiDex() {}

    /**
     * Patches the application context class loader by appending extra dex files
     * loaded from the application apk. This method should be called in the
     * attachBaseContext of your {@link Application}, see
     * {@link MultiDexApplication} for more explanation and an example.
     *
     * @param context application context.
     * @throws RuntimeException if an error occurred preventing the classloader
     *         extension.
     */
    public static void install(Context context) {
        Log.i(TAG, "install");
        if (IS_VM_MULTIDEX_CAPABLE) {
            Log.i(TAG, "VM has multidex support, MultiDex support library is disabled.");
            return;
        }

        if (Build.VERSION.SDK_INT < MIN_SDK_VERSION) {
            throw new RuntimeException("Multi dex installation failed. SDK " + Build.VERSION.SDK_INT
                    + " is unsupported. Min SDK version is " + MIN_SDK_VERSION + ".");
        }

        try {
            ApplicationInfo applicationInfo = getApplicationInfo(context);
            if (applicationInfo == null) {
                // Looks like running on a test Context, so just return without patching.
                return;
            }

            synchronized (installedApk) {
                String apkPath = applicationInfo.sourceDir;
                if (installedApk.contains(apkPath)) {
                    return;
                }
                installedApk.add(apkPath);

                if (Build.VERSION.SDK_INT > MAX_SUPPORTED_SDK_VERSION) {
                    Log.w(TAG, "MultiDex is not guaranteed to work in SDK version "
                            + Build.VERSION.SDK_INT + ": SDK version higher than "
                            + MAX_SUPPORTED_SDK_VERSION + " should be backed by "
                            + "runtime with built-in multidex capabilty but it‘s not the "
                            + "case here: java.vm.version=\""
                            + System.getProperty("java.vm.version") + "\"");
                }

                /* The patched class loader is expected to be a descendant of
                 * dalvik.system.BaseDexClassLoader. We modify its
                 * dalvik.system.DexPathList pathList field to append additional DEX
                 * file entries.
                 */
                ClassLoader loader;
                try {
                    loader = context.getClassLoader();
                } catch (RuntimeException e) {
                    /* Ignore those exceptions so that we don‘t break tests relying on Context like
                     * a android.test.mock.MockContext or a android.content.ContextWrapper with a
                     * null base Context.
                     */
                    Log.w(TAG, "Failure while trying to obtain Context class loader. " +
                            "Must be running in test mode. Skip patching.", e);
                    return;
                }
                if (loader == null) {
                    // Note, the context class loader is null when running Robolectric tests.
                    Log.e(TAG,
                            "Context class loader is null. Must be running in test mode. "
                            + "Skip patching.");
                    return;
                }

                try {
                  clearOldDexDir(context);
                } catch (Throwable t) {
                  Log.w(TAG, "Something went wrong when trying to clear old MultiDex extraction, "
                      + "continuing without cleaning.", t);
                }

                File dexDir = new File(applicationInfo.dataDir, SECONDARY_FOLDER_NAME);
                List<File> files = MultiDexExtractor.load(context, applicationInfo, dexDir, false);
                if (checkValidZipFiles(files)) {
                    installSecondaryDexes(loader, dexDir, files);
                } else {
                    Log.w(TAG, "Files were not valid zip files.  Forcing a reload.");
                    // Try again, but this time force a reload of the zip file.
                    files = MultiDexExtractor.load(context, applicationInfo, dexDir, true);

                    if (checkValidZipFiles(files)) {
                        installSecondaryDexes(loader, dexDir, files);
                    } else {
                        // Second time didn‘t work, give up
                        throw new RuntimeException("Zip files were not valid.");
                    }
                }
            }

        } catch (Exception e) {
            Log.e(TAG, "Multidex installation failure", e);
            throw new RuntimeException("Multi dex installation failed (" + e.getMessage() + ").");
        }
        Log.i(TAG, "install done");
    }

    private static ApplicationInfo getApplicationInfo(Context context)
            throws NameNotFoundException {
        PackageManager pm;
        String packageName;
        try {
            pm = context.getPackageManager();
            packageName = context.getPackageName();
        } catch (RuntimeException e) {
            /* Ignore those exceptions so that we don‘t break tests relying on Context like
             * a android.test.mock.MockContext or a android.content.ContextWrapper with a null
             * base Context.
             */
            Log.w(TAG, "Failure while trying to obtain ApplicationInfo from Context. " +
                    "Must be running in test mode. Skip patching.", e);
            return null;
        }
        if (pm == null || packageName == null) {
            // This is most likely a mock context, so just return without patching.
            return null;
        }
        ApplicationInfo applicationInfo =
                pm.getApplicationInfo(packageName, PackageManager.GET_META_DATA);
        return applicationInfo;
    }

    /**
     * Identifies if the current VM has a native support for multidex, meaning there is no need for
     * additional installation by this library.
     * @return true if the VM handles multidex
     */
    /* package visible for test */
    static boolean isVMMultidexCapable(String versionString) {
        boolean isMultidexCapable = false;
        if (versionString != null) {
            Matcher matcher = Pattern.compile("(\\d+)\\.(\\d+)(\\.\\d+)?").matcher(versionString);
            if (matcher.matches()) {
                try {
                    int major = Integer.parseInt(matcher.group(1));
                    int minor = Integer.parseInt(matcher.group(2));
                    isMultidexCapable = (major > VM_WITH_MULTIDEX_VERSION_MAJOR)
                            || ((major == VM_WITH_MULTIDEX_VERSION_MAJOR)
                                    && (minor >= VM_WITH_MULTIDEX_VERSION_MINOR));
                } catch (NumberFormatException e) {
                    // let isMultidexCapable be false
                }
            }
        }
        Log.i(TAG, "VM with version " + versionString +
                (isMultidexCapable ?
                        " has multidex support" :
                        " does not have multidex support"));
        return isMultidexCapable;
    }

    private static void installSecondaryDexes(ClassLoader loader, File dexDir, List<File> files)
            throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException,
            InvocationTargetException, NoSuchMethodException, IOException {
        if (!files.isEmpty()) {
            if (Build.VERSION.SDK_INT >= 19) {
                V19.install(loader, files, dexDir);
            } else if (Build.VERSION.SDK_INT >= 14) {
                V14.install(loader, files, dexDir);
            } else {
                V4.install(loader, files);
            }
        }
    }

    /**
     * Returns whether all files in the list are valid zip files.  If {@code files} is empty, then
     * returns true.
     */
    private static boolean checkValidZipFiles(List<File> files) {
        for (File file : files) {
            if (!MultiDexExtractor.verifyZipFile(file)) {
                return false;
            }
        }
        return true;
    }

    /**
     * Locates a given field anywhere in the class inheritance hierarchy.
     *
     * @param instance an object to search the field into.
     * @param name field name
     * @return a field object
     * @throws NoSuchFieldException if the field cannot be located
     */
    private static Field findField(Object instance, String name) throws NoSuchFieldException {
        for (Class<?> clazz = instance.getClass(); clazz != null; clazz = clazz.getSuperclass()) {
            try {
                Field field = clazz.getDeclaredField(name);


                if (!field.isAccessible()) {
                    field.setAccessible(true);
                }

                return field;
            } catch (NoSuchFieldException e) {
                // ignore and search next
            }
        }

        throw new NoSuchFieldException("Field " + name + " not found in " + instance.getClass());
    }

    /**
     * Locates a given method anywhere in the class inheritance hierarchy.
     *
     * @param instance an object to search the method into.
     * @param name method name
     * @param parameterTypes method parameter types
     * @return a method object
     * @throws NoSuchMethodException if the method cannot be located
     */
    private static Method findMethod(Object instance, String name, Class<?>... parameterTypes)
            throws NoSuchMethodException {
        for (Class<?> clazz = instance.getClass(); clazz != null; clazz = clazz.getSuperclass()) {
            try {
                Method method = clazz.getDeclaredMethod(name, parameterTypes);


                if (!method.isAccessible()) {
                    method.setAccessible(true);
                }

                return method;
            } catch (NoSuchMethodException e) {
                // ignore and search next
            }
        }

        throw new NoSuchMethodException("Method " + name + " with parameters " +
                Arrays.asList(parameterTypes) + " not found in " + instance.getClass());
    }

    /**
     * Replace the value of a field containing a non null array, by a new array containing the
     * elements of the original array plus the elements of extraElements.
     * @param instance the instance whose field is to be modified.
     * @param fieldName the field to modify.
     * @param extraElements elements to append at the end of the array.
     */
    private static void expandFieldArray(Object instance, String fieldName,
            Object[] extraElements) throws NoSuchFieldException, IllegalArgumentException,
            IllegalAccessException {
        Field jlrField = findField(instance, fieldName);
        Object[] original = (Object[]) jlrField.get(instance);
        Object[] combined = (Object[]) Array.newInstance(
                original.getClass().getComponentType(), original.length + extraElements.length);
        System.arraycopy(original, 0, combined, 0, original.length);
        System.arraycopy(extraElements, 0, combined, original.length, extraElements.length);
        jlrField.set(instance, combined);
    }

    private static void clearOldDexDir(Context context) throws Exception {
        File dexDir = new File(context.getFilesDir(), OLD_SECONDARY_FOLDER_NAME);
        if (dexDir.isDirectory()) {
            Log.i(TAG, "Clearing old secondary dex dir (" + dexDir.getPath() + ").");
            File[] files = dexDir.listFiles();
            if (files == null) {
                Log.w(TAG, "Failed to list secondary dex dir content (" + dexDir.getPath() + ").");
                return;
            }
            for (File oldFile : files) {
                Log.i(TAG, "Trying to delete old file " + oldFile.getPath() + " of size "
                        + oldFile.length());
                if (!oldFile.delete()) {
                    Log.w(TAG, "Failed to delete old file " + oldFile.getPath());
                } else {
                    Log.i(TAG, "Deleted old file " + oldFile.getPath());
                }
            }
            if (!dexDir.delete()) {
                Log.w(TAG, "Failed to delete secondary dex dir " + dexDir.getPath());
            } else {
                Log.i(TAG, "Deleted old secondary dex dir " + dexDir.getPath());
            }
        }
    }

    /**
     * Installer for platform versions 19.
     */
    private static final class V19 {

        private static void install(ClassLoader loader, List<File> additionalClassPathEntries,
                File optimizedDirectory)
                        throws IllegalArgumentException, IllegalAccessException,
                        NoSuchFieldException, InvocationTargetException, NoSuchMethodException {
            /* The patched class loader is expected to be a descendant of
             * dalvik.system.BaseDexClassLoader. We modify its
             * dalvik.system.DexPathList pathList field to append additional DEX
             * file entries.
             */
            Field pathListField = findField(loader, "pathList");
            Object dexPathList = pathListField.get(loader);
            ArrayList<IOException> suppressedExceptions = new ArrayList<IOException>();
            expandFieldArray(dexPathList, "dexElements", makeDexElements(dexPathList,
                    new ArrayList<File>(additionalClassPathEntries), optimizedDirectory,
                    suppressedExceptions));
            if (suppressedExceptions.size() > 0) {
                for (IOException e : suppressedExceptions) {
                    Log.w(TAG, "Exception in makeDexElement", e);
                }
                Field suppressedExceptionsField =
                        findField(loader, "dexElementsSuppressedExceptions");
                IOException[] dexElementsSuppressedExceptions =
                        (IOException[]) suppressedExceptionsField.get(loader);

                if (dexElementsSuppressedExceptions == null) {
                    dexElementsSuppressedExceptions =
                            suppressedExceptions.toArray(
                                    new IOException[suppressedExceptions.size()]);
                } else {
                    IOException[] combined =
                            new IOException[suppressedExceptions.size() +
                                            dexElementsSuppressedExceptions.length];
                    suppressedExceptions.toArray(combined);
                    System.arraycopy(dexElementsSuppressedExceptions, 0, combined,
                            suppressedExceptions.size(), dexElementsSuppressedExceptions.length);
                    dexElementsSuppressedExceptions = combined;
                }

                suppressedExceptionsField.set(loader, dexElementsSuppressedExceptions);
            }
        }

        /**
         * A wrapper around
         * {@code private static final dalvik.system.DexPathList#makeDexElements}.
         */
        private static Object[] makeDexElements(
                Object dexPathList, ArrayList<File> files, File optimizedDirectory,
                ArrayList<IOException> suppressedExceptions)
                        throws IllegalAccessException, InvocationTargetException,
                        NoSuchMethodException {
            Method makeDexElements =
                    findMethod(dexPathList, "makeDexElements", ArrayList.class, File.class,
                            ArrayList.class);

            return (Object[]) makeDexElements.invoke(dexPathList, files, optimizedDirectory,
                    suppressedExceptions);
        }
    }

    /**
     * Installer for platform versions 14, 15, 16, 17 and 18.
     */
    private static final class V14 {

        private static void install(ClassLoader loader, List<File> additionalClassPathEntries,
                File optimizedDirectory)
                        throws IllegalArgumentException, IllegalAccessException,
                        NoSuchFieldException, InvocationTargetException, NoSuchMethodException {
            /* The patched class loader is expected to be a descendant of
             * dalvik.system.BaseDexClassLoader. We modify its
             * dalvik.system.DexPathList pathList field to append additional DEX
             * file entries.
             */
            Field pathListField = findField(loader, "pathList");
            Object dexPathList = pathListField.get(loader);
            expandFieldArray(dexPathList, "dexElements", makeDexElements(dexPathList,
                    new ArrayList<File>(additionalClassPathEntries), optimizedDirectory));
        }

        /**
         * A wrapper around
         * {@code private static final dalvik.system.DexPathList#makeDexElements}.
         */
        private static Object[] makeDexElements(
                Object dexPathList, ArrayList<File> files, File optimizedDirectory)
                        throws IllegalAccessException, InvocationTargetException,
                        NoSuchMethodException {
            Method makeDexElements =
                    findMethod(dexPathList, "makeDexElements", ArrayList.class, File.class);

            return (Object[]) makeDexElements.invoke(dexPathList, files, optimizedDirectory);
        }
    }

    /**
     * Installer for platform versions 4 to 13.
     */
    private static final class V4 {
        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);
        }
    }

}

 1 /*
 2  * Copyright (C) 2014 The Android Open Source Project
 3  *
 4  * Licensed under the Apache License, Version 2.0 (the "License");
 5  * you may not use this file except in compliance with the License.
 6  * You may obtain a copy of the License at
 7  *
 8  *      http://www.apache.org/licenses/LICENSE-2.0
 9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.support.multidex;
18 
19 import android.app.Application;
20 import android.content.Context;
21 
22 /**
23  * Minimal MultiDex capable application. To use the legacy multidex library there is 3 possibility:
24  * <ul>
25  * <li>Declare this class as the application in your AndroidManifest.xml.</li>
26  * <li>Have your {@link Application} extends this class.</li>
27  * <li>Have your {@link Application} override attachBaseContext starting with<br>
28  * <code>
29   protected void attachBaseContext(Context base) {<br>
30     super.attachBaseContext(base);<br>
31     MultiDex.install(this);
32     </code></li>
33  *   <ul>
34  */
35 public class MultiDexApplication extends Application {
36   @Override
37   protected void attachBaseContext(Context base) {
38     super.attachBaseContext(base);
39     MultiDex.install(this);
40   }
41 }

  1 /*
  2  * Copyright (C) 2013 The Android Open Source Project
  3  *
  4  * Licensed under the Apache License, Version 2.0 (the "License");
  5  * you may not use this file except in compliance with the License.
  6  * You may obtain a copy of the License at
  7  *
  8  *      http://www.apache.org/licenses/LICENSE-2.0
  9  *
 10  * Unless required by applicable law or agreed to in writing, software
 11  * distributed under the License is distributed on an "AS IS" BASIS,
 12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  * See the License for the specific language governing permissions and
 14  * limitations under the License.
 15  */
 16 
 17 package android.support.multidex;
 18 
 19 import android.content.Context;
 20 import android.content.SharedPreferences;
 21 import android.content.pm.ApplicationInfo;
 22 import android.os.Build;
 23 import android.util.Log;
 24 
 25 import java.io.BufferedOutputStream;
 26 import java.io.Closeable;
 27 import java.io.File;
 28 import java.io.FileFilter;
 29 import java.io.FileNotFoundException;
 30 import java.io.FileOutputStream;
 31 import java.io.IOException;
 32 import java.io.InputStream;
 33 import java.lang.reflect.InvocationTargetException;
 34 import java.lang.reflect.Method;
 35 import java.util.ArrayList;
 36 import java.util.List;
 37 import java.util.zip.ZipEntry;
 38 import java.util.zip.ZipException;
 39 import java.util.zip.ZipFile;
 40 import java.util.zip.ZipOutputStream;
 41 
 42 /**
 43  * Exposes application secondary dex files as files in the application data
 44  * directory.
 45  */
 46 final class MultiDexExtractor {
 47 
 48     private static final String TAG = MultiDex.TAG;
 49 
 50     /**
 51      * We look for additional dex files named {@code classes2.dex},
 52      * {@code classes3.dex}, etc.
 53      */
 54     private static final String DEX_PREFIX = "classes";
 55     private static final String DEX_SUFFIX = ".dex";
 56 
 57     private static final String EXTRACTED_NAME_EXT = ".classes";
 58     private static final String EXTRACTED_SUFFIX = ".zip";
 59     private static final int MAX_EXTRACT_ATTEMPTS = 3;
 60 
 61     private static final String PREFS_FILE = "multidex.version";
 62     private static final String KEY_TIME_STAMP = "timestamp";
 63     private static final String KEY_CRC = "crc";
 64     private static final String KEY_DEX_NUMBER = "dex.number";
 65 
 66     /**
 67      * Size of reading buffers.
 68      */
 69     private static final int BUFFER_SIZE = 0x4000;
 70     /* Keep value away from 0 because it is a too probable time stamp value */
 71     private static final long NO_VALUE = http://www.mamicode.com/-1L;
 72 
 73     /**
 74      * Extracts application secondary dexes into files in the application data
 75      * directory.
 76      *
 77      * @return a list of files that were created. The list may be empty if there
 78      *         are no secondary dex files.
 79      * @throws IOException if encounters a problem while reading or writing
 80      *         secondary dex files
 81      */
 82     static List<File> load(Context context, ApplicationInfo applicationInfo, File dexDir,
 83             boolean forceReload) throws IOException {
 84         Log.i(TAG, "MultiDexExtractor.load(" + applicationInfo.sourceDir + ", " + forceReload + ")");
 85         final File sourceApk = new File(applicationInfo.sourceDir);
 86 
 87         long currentCrc = getZipCrc(sourceApk);
 88 
 89         List<File> files;
 90         if (!forceReload && !isModified(context, sourceApk, currentCrc)) {
 91             try {
 92                 files = loadExistingExtractions(context, sourceApk, dexDir);
 93             } catch (IOException ioe) {
 94                 Log.w(TAG, "Failed to reload existing extracted secondary dex files,"
 95                         + " falling back to fresh extraction", ioe);
 96                 files = performExtractions(sourceApk, dexDir);
 97                 putStoredApkInfo(context, getTimeStamp(sourceApk), currentCrc, files.size() + 1);
 98 
 99             }
100         } else {
101             Log.i(TAG, "Detected that extraction must be performed.");
102             files = performExtractions(sourceApk, dexDir);
103             putStoredApkInfo(context, getTimeStamp(sourceApk), currentCrc, files.size() + 1);
104         }
105 
106         Log.i(TAG, "load found " + files.size() + " secondary dex files");
107         return files;
108     }
109 
110     private static List<File> loadExistingExtractions(Context context, File sourceApk, File dexDir)
111             throws IOException {
112         Log.i(TAG, "loading existing secondary dex files");
113 
114         final String extractedFilePrefix = sourceApk.getName() + EXTRACTED_NAME_EXT;
115         int totalDexNumber = getMultiDexPreferences(context).getInt(KEY_DEX_NUMBER, 1);
116         final List<File> files = new ArrayList<File>(totalDexNumber);
117 
118         for (int secondaryNumber = 2; secondaryNumber <= totalDexNumber; secondaryNumber++) {
119             String fileName = extractedFilePrefix + secondaryNumber + EXTRACTED_SUFFIX;
120             File extractedFile = new File(dexDir, fileName);
121             if (extractedFile.isFile()) {
122                 files.add(extractedFile);
123                 if (!verifyZipFile(extractedFile)) {
124                     Log.i(TAG, "Invalid zip file: " + extractedFile);
125                     throw new IOException("Invalid ZIP file.");
126                 }
127             } else {
128                 throw new IOException("Missing extracted secondary dex file ‘" +
129                         extractedFile.getPath() + "‘");
130             }
131         }
132 
133         return files;
134     }
135 
136     private static boolean isModified(Context context, File archive, long currentCrc) {
137         SharedPreferences prefs = getMultiDexPreferences(context);
138         return (prefs.getLong(KEY_TIME_STAMP, NO_VALUE) != getTimeStamp(archive))
139                 || (prefs.getLong(KEY_CRC, NO_VALUE) != currentCrc);
140     }
141 
142     private static long getTimeStamp(File archive) {
143         long timeStamp = archive.lastModified();
144         if (timeStamp == NO_VALUE) {
145             // never return NO_VALUE
146             timeStamp--;
147         }
148         return timeStamp;
149     }
150 
151 
152     private static long getZipCrc(File archive) throws IOException {
153         long computedValue =http://www.mamicode.com/ ZipUtil.getZipCrc(archive);
154         if (computedValue =http://www.mamicode.com/= NO_VALUE) {
155             // never return NO_VALUE
156             computedValue--;
157         }
158         return computedValue;
159     }
160 
161     private static List<File> performExtractions(File sourceApk, File dexDir)
162             throws IOException {
163 
164         final String extractedFilePrefix = sourceApk.getName() + EXTRACTED_NAME_EXT;
165 
166         // Ensure that whatever deletions happen in prepareDexDir only happen if the zip that
167         // contains a secondary dex file in there is not consistent with the latest apk.  Otherwise,
168         // multi-process race conditions can cause a crash loop where one process deletes the zip
169         // while another had created it.
170         prepareDexDir(dexDir, extractedFilePrefix);
171 
172         List<File> files = new ArrayList<File>();
173 
174         final ZipFile apk = new ZipFile(sourceApk);
175         try {
176 
177             int secondaryNumber = 2;
178 
179             ZipEntry dexFile = apk.getEntry(DEX_PREFIX + secondaryNumber + DEX_SUFFIX);
180             while (dexFile != null) {
181                 String fileName = extractedFilePrefix + secondaryNumber + EXTRACTED_SUFFIX;
182                 File extractedFile = new File(dexDir, fileName);
183                 files.add(extractedFile);
184 
185                 Log.i(TAG, "Extraction is needed for file " + extractedFile);
186                 int numAttempts = 0;
187                 boolean isExtractionSuccessful = false;
188                 while (numAttempts < MAX_EXTRACT_ATTEMPTS && !isExtractionSuccessful) {
189                     numAttempts++;
190 
191                     // Create a zip file (extractedFile) containing only the secondary dex file
192                     // (dexFile) from the apk.
193                     extract(apk, dexFile, extractedFile, extractedFilePrefix);
194 
195                     // Verify that the extracted file is indeed a zip file.
196                     isExtractionSuccessful = verifyZipFile(extractedFile);
197 
198                     // Log the sha1 of the extracted zip file
199                     Log.i(TAG, "Extraction " + (isExtractionSuccessful ? "success" : "failed") +
200                             " - length " + extractedFile.getAbsolutePath() + ": " +
201                             extractedFile.length());
202                     if (!isExtractionSuccessful) {
203                         // Delete the extracted file
204                         extractedFile.delete();
205                         if (extractedFile.exists()) {
206                             Log.w(TAG, "Failed to delete corrupted secondary dex ‘" +
207                                     extractedFile.getPath() + "‘");
208                         }
209                     }
210                 }
211                 if (!isExtractionSuccessful) {
212                     throw new IOException("Could not create zip file " +
213                             extractedFile.getAbsolutePath() + " for secondary dex (" +
214                             secondaryNumber + ")");
215                 }
216                 secondaryNumber++;
217                 dexFile = apk.getEntry(DEX_PREFIX + secondaryNumber + DEX_SUFFIX);
218             }
219         } finally {
220             try {
221                 apk.close();
222             } catch (IOException e) {
223                 Log.w(TAG, "Failed to close resource", e);
224             }
225         }
226 
227         return files;
228     }
229 
230     private static void putStoredApkInfo(Context context, long timeStamp, long crc,
231             int totalDexNumber) {
232         SharedPreferences prefs = getMultiDexPreferences(context);
233         SharedPreferences.Editor edit = prefs.edit();
234         edit.putLong(KEY_TIME_STAMP, timeStamp);
235         edit.putLong(KEY_CRC, crc);
236         /* SharedPreferences.Editor doc says that apply() and commit() "atomically performs the
237          * requested modifications" it should be OK to rely on saving the dex files number (getting
238          * old number value would go along with old crc and time stamp).
239          */
240         edit.putInt(KEY_DEX_NUMBER, totalDexNumber);
241         apply(edit);
242     }
243 
244     private static SharedPreferences getMultiDexPreferences(Context context) {
245         return context.getSharedPreferences(PREFS_FILE,
246                 Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB
247                         ? Context.MODE_PRIVATE
248                         : Context.MODE_PRIVATE | Context.MODE_MULTI_PROCESS);
249     }
250 
251     /**
252      * This removes any files that do not have the correct prefix.
253      */
254     private static void prepareDexDir(File dexDir, final String extractedFilePrefix)
255             throws IOException {
256         dexDir.mkdirs();
257         if (!dexDir.isDirectory()) {
258             throw new IOException("Failed to create dex directory " + dexDir.getPath());
259         }
260 
261         // Clean possible old files
262         FileFilter filter = new FileFilter() {
263 
264             @Override
265             public boolean accept(File pathname) {
266                 return !pathname.getName().startsWith(extractedFilePrefix);
267             }
268         };
269         File[] files = dexDir.listFiles(filter);
270         if (files == null) {
271             Log.w(TAG, "Failed to list secondary dex dir content (" + dexDir.getPath() + ").");
272             return;
273         }
274         for (File oldFile : files) {
275             Log.i(TAG, "Trying to delete old file " + oldFile.getPath() + " of size " +
276                     oldFile.length());
277             if (!oldFile.delete()) {
278                 Log.w(TAG, "Failed to delete old file " + oldFile.getPath());
279             } else {
280                 Log.i(TAG, "Deleted old file " + oldFile.getPath());
281             }
282         }
283     }
284 
285     private static void extract(ZipFile apk, ZipEntry dexFile, File extractTo,
286             String extractedFilePrefix) throws IOException, FileNotFoundException {
287 
288         InputStream in = apk.getInputStream(dexFile);
289         ZipOutputStream out = null;
290         File tmp = File.createTempFile(extractedFilePrefix, EXTRACTED_SUFFIX,
291                 extractTo.getParentFile());
292         Log.i(TAG, "Extracting " + tmp.getPath());
293         try {
294             out = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(tmp)));
295             try {
296                 ZipEntry classesDex = new ZipEntry("classes.dex");
297                 // keep zip entry time since it is the criteria used by Dalvik
298                 classesDex.setTime(dexFile.getTime());
299                 out.putNextEntry(classesDex);
300 
301                 byte[] buffer = new byte[BUFFER_SIZE];
302                 int length = in.read(buffer);
303                 while (length != -1) {
304                     out.write(buffer, 0, length);
305                     length = in.read(buffer);
306                 }
307                 out.closeEntry();
308             } finally {
309                 out.close();
310             }
311             Log.i(TAG, "Renaming to " + extractTo.getPath());
312             if (!tmp.renameTo(extractTo)) {
313                 throw new IOException("Failed to rename \"" + tmp.getAbsolutePath() +
314                         "\" to \"" + extractTo.getAbsolutePath() + "\"");
315             }
316         } finally {
317             closeQuietly(in);
318             tmp.delete(); // return status ignored
319         }
320     }
321 
322     /**
323      * Returns whether the file is a valid zip file.
324      */
325     static boolean verifyZipFile(File file) {
326         try {
327             ZipFile zipFile = new ZipFile(file);
328             try {
329                 zipFile.close();
330                 return true;
331             } catch (IOException e) {
332                 Log.w(TAG, "Failed to close zip file: " + file.getAbsolutePath());
333             }
334         } catch (ZipException ex) {
335             Log.w(TAG, "File " + file.getAbsolutePath() + " is not a valid zip file.", ex);
336         } catch (IOException ex) {
337             Log.w(TAG, "Got an IOException trying to open zip file: " + file.getAbsolutePath(), ex);
338         }
339         return false;
340     }
341 
342     /**
343      * Closes the given {@code Closeable}. Suppresses any IO exceptions.
344      */
345     private static void closeQuietly(Closeable closeable) {
346         try {
347             closeable.close();
348         } catch (IOException e) {
349             Log.w(TAG, "Failed to close resource", e);
350         }
351     }
352 
353     // The following is taken from SharedPreferencesCompat to avoid having a dependency of the
354     // multidex support library on another support library.
355     private static Method sApplyMethod;  // final
356     static {
357         try {
358             Class<?> cls = SharedPreferences.Editor.class;
359             sApplyMethod = cls.getMethod("apply");
360         } catch (NoSuchMethodException unused) {
361             sApplyMethod = null;
362         }
363     }
364 
365     private static void apply(SharedPreferences.Editor editor) {
366         if (sApplyMethod != null) {
367             try {
368                 sApplyMethod.invoke(editor);
369                 return;
370             } catch (InvocationTargetException unused) {
371                 // fall through
372             } catch (IllegalAccessException unused) {
373                 // fall through
374             }
375         }
376         editor.commit();
377     }
378 }

  1 /*
  2  * Licensed to the Apache Software Foundation (ASF) under one or more
  3  * contributor license agreements.  See the NOTICE file distributed with
  4  * this work for additional information regarding copyright ownership.
  5  * The ASF licenses this file to You under the Apache License, Version 2.0
  6  * (the "License"); you may not use this file except in compliance with
  7  * the License.  You may obtain a copy of the License at
  8  *
  9  *     http://www.apache.org/licenses/LICENSE-2.0
 10  *
 11  * Unless required by applicable law or agreed to in writing, software
 12  * distributed under the License is distributed on an "AS IS" BASIS,
 13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14  * See the License for the specific language governing permissions and
 15  * limitations under the License.
 16  */
 17 /* Apache Harmony HEADER because the code in this class comes mostly from ZipFile, ZipEntry and
 18  * ZipConstants from android libcore.
 19  */
 20 
 21 package android.support.multidex;
 22 
 23 import java.io.File;
 24 import java.io.IOException;
 25 import java.io.RandomAccessFile;
 26 import java.util.zip.CRC32;
 27 import java.util.zip.ZipException;
 28 
 29 /**
 30  * Tools to build a quick partial crc of zip files.
 31  */
 32 final class ZipUtil {
 33     static class CentralDirectory {
 34         long offset;
 35         long size;
 36     }
 37 
 38     /* redefine those constant here because of bug 13721174 preventing to compile using the
 39      * constants defined in ZipFile */
 40     private static final int ENDHDR = 22;
 41     private static final int ENDSIG = 0x6054b50;
 42 
 43     /**
 44      * Size of reading buffers.
 45      */
 46     private static final int BUFFER_SIZE = 0x4000;
 47 
 48     /**
 49      * Compute crc32 of the central directory of an apk. The central directory contains
 50      * the crc32 of each entries in the zip so the computed result is considered valid for the whole
 51      * zip file. Does not support zip64 nor multidisk but it should be OK for now since ZipFile does
 52      * not either.
 53      */
 54     static long getZipCrc(File apk) throws IOException {
 55         RandomAccessFile raf = new RandomAccessFile(apk, "r");
 56         try {
 57             CentralDirectory dir = findCentralDirectory(raf);
 58 
 59             return computeCrcOfCentralDir(raf, dir);
 60         } finally {
 61             raf.close();
 62         }
 63     }
 64 
 65     /* Package visible for testing */
 66     static CentralDirectory findCentralDirectory(RandomAccessFile raf) throws IOException,
 67             ZipException {
 68         long scanOffset = raf.length() - ENDHDR;
 69         if (scanOffset < 0) {
 70             throw new ZipException("File too short to be a zip file: " + raf.length());
 71         }
 72 
 73         long stopOffset = scanOffset - 0x10000 /* ".ZIP file comment"‘s max length */;
 74         if (stopOffset < 0) {
 75             stopOffset = 0;
 76         }
 77 
 78         int endSig = Integer.reverseBytes(ENDSIG);
 79         while (true) {
 80             raf.seek(scanOffset);
 81             if (raf.readInt() == endSig) {
 82                 break;
 83             }
 84 
 85             scanOffset--;
 86             if (scanOffset < stopOffset) {
 87                 throw new ZipException("End Of Central Directory signature not found");
 88             }
 89         }
 90         // Read the End Of Central Directory. ENDHDR includes the signature
 91         // bytes,
 92         // which we‘ve already read.
 93 
 94         // Pull out the information we need.
 95         raf.skipBytes(2); // diskNumber
 96         raf.skipBytes(2); // diskWithCentralDir
 97         raf.skipBytes(2); // numEntries
 98         raf.skipBytes(2); // totalNumEntries
 99         CentralDirectory dir = new CentralDirectory();
100         dir.size = Integer.reverseBytes(raf.readInt()) & 0xFFFFFFFFL;
101         dir.offset = Integer.reverseBytes(raf.readInt()) & 0xFFFFFFFFL;
102         return dir;
103     }
104 
105     /* Package visible for testing */
106     static long computeCrcOfCentralDir(RandomAccessFile raf, CentralDirectory dir)
107             throws IOException {
108         CRC32 crc = new CRC32();
109         long stillToRead = dir.size;
110         raf.seek(dir.offset);
111         int length = (int) Math.min(BUFFER_SIZE, stillToRead);
112         byte[] buffer = new byte[BUFFER_SIZE];
113         length = raf.read(buffer, 0, length);
114         while (length != -1) {
115             crc.update(buffer, 0, length);
116             stillToRead -= length;
117             if (stillToRead == 0) {
118                 break;
119             }
120             length = (int) Math.min(BUFFER_SIZE, stillToRead);
121             length = raf.read(buffer, 0, length);
122         }
123         return crc.getValue();
124     }
125 }