library/src/androidx/multidex/MultiDexExtractor.java - platform/frameworks/multidex - Gitiles

 /*
  * 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 androidx.multidex;

 import android.content.Context;
 import android.content.SharedPreferences;
 import android.os.Build;
 import android.util.Log;
 import java.io.BufferedOutputStream;
 import java.io.Closeable;
 import java.io.File;
 import java.io.FileFilter;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.RandomAccessFile;
 import java.nio.channels.FileChannel;
 import java.nio.channels.FileLock;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 import java.util.zip.ZipOutputStream;

 /**
  * Exposes application secondary dex files as files in the application data
  * directory.
  * {@link MultiDexExtractor} is taking the file lock in the dex dir on creation and release it
  * during close.
  */
 final class MultiDexExtractor implements Closeable {

     /**
      * Zip file containing one secondary dex file.
      */
     private static class ExtractedDex extends File {
         public long crc = NO_VALUE;

         public ExtractedDex(File dexDir, String fileName) {
             super(dexDir, fileName);
         }
     }

     private static final String TAG = MultiDex.TAG;

     /**
      * We look for additional dex files named {@code classes2.dex},
      * {@code classes3.dex}, etc.
      */
     private static final String DEX_PREFIX = "classes";
     static final String DEX_SUFFIX = ".dex";

     private static final String EXTRACTED_NAME_EXT = ".classes";
     static final String EXTRACTED_SUFFIX = ".zip";
     private static final int MAX_EXTRACT_ATTEMPTS = 3;

     private static final String PREFS_FILE = "multidex.version";
     private static final String KEY_TIME_STAMP = "timestamp";
     private static final String KEY_CRC = "crc";
     private static final String KEY_DEX_NUMBER = "dex.number";
     private static final String KEY_DEX_CRC = "dex.crc.";
     private static final String KEY_DEX_TIME = "dex.time.";

     /**
      * Size of reading buffers.
      */
     private static final int BUFFER_SIZE = 0x4000;
     /* Keep value away from 0 because it is a too probable time stamp value */
     private static final long NO_VALUE = -1L;

     private static final String LOCK_FILENAME = "MultiDex.lock";
     private final File sourceApk;
     private final long sourceCrc;
     private final File dexDir;
     private final RandomAccessFile lockRaf;
     private final FileChannel lockChannel;
     private final FileLock cacheLock;

     MultiDexExtractor(File sourceApk, File dexDir) throws IOException {
         Log.i(TAG, "MultiDexExtractor(" + sourceApk.getPath() + ", " + dexDir.getPath() + ")");
         this.sourceApk = sourceApk;
         this.dexDir = dexDir;
         sourceCrc = getZipCrc(sourceApk);
         File lockFile = new File(dexDir, LOCK_FILENAME);
         lockRaf = new RandomAccessFile(lockFile, "rw");
         try {
             lockChannel = lockRaf.getChannel();
             try {
                 Log.i(TAG, "Blocking on lock " + lockFile.getPath());
                 cacheLock = lockChannel.lock();
             } catch (IOException | RuntimeException | Error e) {
                 closeQuietly(lockChannel);
                 throw e;
             }
             Log.i(TAG, lockFile.getPath() + " locked");
         } catch (IOException | RuntimeException | Error e) {
             closeQuietly(lockRaf);
             throw e;
         }
     }

     /**
      * Extracts application secondary dexes into files in the application data
      * directory.
      *
      * @return a list of files that were created. The list may be empty if there
      *         are no secondary dex files. Never return null.
      * @throws IOException if encounters a problem while reading or writing
      *         secondary dex files
      */
     List<? extends File> load(Context context, String prefsKeyPrefix, boolean forceReload)
             throws IOException {
         Log.i(TAG, "MultiDexExtractor.load(" + sourceApk.getPath() + ", " + forceReload + ", " +
                 prefsKeyPrefix + ")");

         if (!cacheLock.isValid()) {
             throw new IllegalStateException("MultiDexExtractor was closed");
         }

         List<ExtractedDex> files;
         if (!forceReload && !isModified(context, sourceApk, sourceCrc, prefsKeyPrefix)) {
             try {
                 files = loadExistingExtractions(context, prefsKeyPrefix);
             } catch (IOException ioe) {
                 Log.w(TAG, "Failed to reload existing extracted secondary dex files,"
                         + " falling back to fresh extraction", ioe);
                 files = performExtractions();
                 putStoredApkInfo(context, prefsKeyPrefix, getTimeStamp(sourceApk), sourceCrc,
                         files);
             }
         } else {
             if (forceReload) {
                 Log.i(TAG, "Forced extraction must be performed.");
             } else {
                 Log.i(TAG, "Detected that extraction must be performed.");
             }
             files = performExtractions();
             putStoredApkInfo(context, prefsKeyPrefix, getTimeStamp(sourceApk), sourceCrc,
                     files);
         }

         Log.i(TAG, "load found " + files.size() + " secondary dex files");
         return files;
     }

     @Override
     public void close() throws IOException {
         cacheLock.release();
         lockChannel.close();
         lockRaf.close();
     }

     /**
      * Load previously extracted secondary dex files. Should be called only while owning the lock on
      * {@link #LOCK_FILENAME}.
      */
     private List<ExtractedDex> loadExistingExtractions(
             Context context,
             String prefsKeyPrefix)
             throws IOException {
         Log.i(TAG, "loading existing secondary dex files");

         final String extractedFilePrefix = sourceApk.getName() + EXTRACTED_NAME_EXT;
         SharedPreferences multiDexPreferences = getMultiDexPreferences(context);
         int totalDexNumber = multiDexPreferences.getInt(prefsKeyPrefix + KEY_DEX_NUMBER, 1);
         final List<ExtractedDex> files = new ArrayList<ExtractedDex>(totalDexNumber - 1);

         for (int secondaryNumber = 2; secondaryNumber <= totalDexNumber; secondaryNumber++) {
             String fileName = extractedFilePrefix + secondaryNumber + EXTRACTED_SUFFIX;
             ExtractedDex extractedFile = new ExtractedDex(dexDir, fileName);
             if (extractedFile.isFile()) {
                 extractedFile.crc = getZipCrc(extractedFile);
                 long expectedCrc = multiDexPreferences.getLong(
                         prefsKeyPrefix + KEY_DEX_CRC + secondaryNumber, NO_VALUE);
                 long expectedModTime = multiDexPreferences.getLong(
                         prefsKeyPrefix + KEY_DEX_TIME + secondaryNumber, NO_VALUE);
                 long lastModified = extractedFile.lastModified();
                 if ((expectedModTime != lastModified)
                         || (expectedCrc != extractedFile.crc)) {
                     throw new IOException("Invalid extracted dex: " + extractedFile +
                             " (key \"" + prefsKeyPrefix + "\"), expected modification time: "
                             + expectedModTime + ", modification time: "
                             + lastModified + ", expected crc: "
                             + expectedCrc + ", file crc: " + extractedFile.crc);
                 }
                 files.add(extractedFile);
             } else {
                 throw new IOException("Missing extracted secondary dex file '" +
                         extractedFile.getPath() + "'");
             }
         }

         return files;
     }


     /**
      * Compare current archive and crc with values stored in {@link SharedPreferences}. Should be
      * called only while owning the lock on {@link #LOCK_FILENAME}.
      */
     private static boolean isModified(Context context, File archive, long currentCrc,
             String prefsKeyPrefix) {
         SharedPreferences prefs = getMultiDexPreferences(context);
         return (prefs.getLong(prefsKeyPrefix + KEY_TIME_STAMP, NO_VALUE) != getTimeStamp(archive))
                 || (prefs.getLong(prefsKeyPrefix + KEY_CRC, NO_VALUE) != currentCrc);
     }

     private static long getTimeStamp(File archive) {
         long timeStamp = archive.lastModified();
         if (timeStamp == NO_VALUE) {
             // never return NO_VALUE
             timeStamp--;
         }
         return timeStamp;
     }


     private static long getZipCrc(File archive) throws IOException {
         long computedValue = ZipUtil.getZipCrc(archive);
         if (computedValue == NO_VALUE) {
             // never return NO_VALUE
             computedValue--;
         }
         return computedValue;
     }

     private List<ExtractedDex> performExtractions() throws IOException {

         final String extractedFilePrefix = sourceApk.getName() + EXTRACTED_NAME_EXT;

         // It is safe to fully clear the dex dir because we own the file lock so no other process is
         // extracting or running optimizing dexopt. It may cause crash of already running
         // applications if for whatever reason we end up extracting again over a valid extraction.
         clearDexDir();

         List<ExtractedDex> files = new ArrayList<ExtractedDex>();

         final ZipFile apk = new ZipFile(sourceApk);
         try {

             int secondaryNumber = 2;

             ZipEntry dexFile = apk.getEntry(DEX_PREFIX + secondaryNumber + DEX_SUFFIX);
             while (dexFile != null) {
                 String fileName = extractedFilePrefix + secondaryNumber + EXTRACTED_SUFFIX;
                 ExtractedDex extractedFile = new ExtractedDex(dexDir, fileName);
                 files.add(extractedFile);

                 Log.i(TAG, "Extraction is needed for file " + extractedFile);
                 int numAttempts = 0;
                 boolean isExtractionSuccessful = false;
                 while (numAttempts < MAX_EXTRACT_ATTEMPTS && !isExtractionSuccessful) {
                     numAttempts++;

                     // Create a zip file (extractedFile) containing only the secondary dex file
                     // (dexFile) from the apk.
                     extract(apk, dexFile, extractedFile, extractedFilePrefix);

                     // Read zip crc of extracted dex
                     try {
                         extractedFile.crc = getZipCrc(extractedFile);
                         isExtractionSuccessful = true;
                     } catch (IOException e) {
                         isExtractionSuccessful = false;
                         Log.w(TAG, "Failed to read crc from " + extractedFile.getAbsolutePath(), e);
                     }

                     // Log size and crc of the extracted zip file
                     Log.i(TAG, "Extraction " + (isExtractionSuccessful ? "succeeded" : "failed")
                             + " '" + extractedFile.getAbsolutePath() + "': length "
                             + extractedFile.length() + " - crc: " + extractedFile.crc);
                     if (!isExtractionSuccessful) {
                         // Delete the extracted file
                         extractedFile.delete();
                         if (extractedFile.exists()) {
                             Log.w(TAG, "Failed to delete corrupted secondary dex '" +
                                     extractedFile.getPath() + "'");
                         }
                     }
                 }
                 if (!isExtractionSuccessful) {
                     throw new IOException("Could not create zip file " +
                             extractedFile.getAbsolutePath() + " for secondary dex (" +
                             secondaryNumber + ")");
                 }
                 secondaryNumber++;
                 dexFile = apk.getEntry(DEX_PREFIX + secondaryNumber + DEX_SUFFIX);
             }
         } finally {
             try {
                 apk.close();
             } catch (IOException e) {
                 Log.w(TAG, "Failed to close resource", e);
             }
         }

         return files;
     }

     /**
      * Save {@link SharedPreferences}. Should be called only while owning the lock on
      * {@link #LOCK_FILENAME}.
      */
     private static void putStoredApkInfo(Context context, String keyPrefix, long timeStamp,
             long crc, List<ExtractedDex> extractedDexes) {
         SharedPreferences prefs = getMultiDexPreferences(context);
         SharedPreferences.Editor edit = prefs.edit();
         edit.putLong(keyPrefix + KEY_TIME_STAMP, timeStamp);
         edit.putLong(keyPrefix + KEY_CRC, crc);
         edit.putInt(keyPrefix + KEY_DEX_NUMBER, extractedDexes.size() + 1);

         int extractedDexId = 2;
         for (ExtractedDex dex : extractedDexes) {
             edit.putLong(keyPrefix + KEY_DEX_CRC + extractedDexId, dex.crc);
             edit.putLong(keyPrefix + KEY_DEX_TIME + extractedDexId, dex.lastModified());
             extractedDexId++;
         }
         /* Use commit() and not apply() as advised by the doc because we need synchronous writing of
          * the editor content and apply is doing an "asynchronous commit to disk".
          */
         edit.commit();
     }

     /**
      * Get the MuliDex {@link SharedPreferences} for the current application. Should be called only
      * while owning the lock on {@link #LOCK_FILENAME}.
      */
     private static SharedPreferences getMultiDexPreferences(Context context) {
         return context.getSharedPreferences(PREFS_FILE,
                 Build.VERSION.SDK_INT < 11 /* Build.VERSION_CODES.HONEYCOMB */
                         ? Context.MODE_PRIVATE
                         : Context.MODE_PRIVATE | 0x0004 /* Context.MODE_MULTI_PROCESS */);
     }

     /**
      * Clear the dex dir from all files but the lock.
      */
     private void clearDexDir() {
         File[] files = dexDir.listFiles(new FileFilter() {
             @Override
             public boolean accept(File pathname) {
                 return !pathname.getName().equals(LOCK_FILENAME);
             }
         });
         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());
             }
         }
     }

     private static void extract(ZipFile apk, ZipEntry dexFile, File extractTo,
             String extractedFilePrefix) throws IOException, FileNotFoundException {

         InputStream in = apk.getInputStream(dexFile);
         ZipOutputStream out = null;
         // Temp files must not start with extractedFilePrefix to get cleaned up in prepareDexDir()
         File tmp = File.createTempFile("tmp-" + extractedFilePrefix, EXTRACTED_SUFFIX,
                 extractTo.getParentFile());
         Log.i(TAG, "Extracting " + tmp.getPath());
         try {
             out = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(tmp)));
             try {
                 ZipEntry classesDex = new ZipEntry("classes.dex");
                 // keep zip entry time since it is the criteria used by Dalvik
                 classesDex.setTime(dexFile.getTime());
                 out.putNextEntry(classesDex);

                 byte[] buffer = new byte[BUFFER_SIZE];
                 int length = in.read(buffer);
                 while (length != -1) {
                     out.write(buffer, 0, length);
                     length = in.read(buffer);
                 }
                 out.closeEntry();
             } finally {
                 out.close();
             }
             if (!tmp.setReadOnly()) {
                 throw new IOException("Failed to mark readonly \"" + tmp.getAbsolutePath() +
                         "\" (tmp of \"" + extractTo.getAbsolutePath() + "\")");
             }
             Log.i(TAG, "Renaming to " + extractTo.getPath());
             if (!tmp.renameTo(extractTo)) {
                 throw new IOException("Failed to rename \"" + tmp.getAbsolutePath() +
                         "\" to \"" + extractTo.getAbsolutePath() + "\"");
             }
         } finally {
             closeQuietly(in);
             tmp.delete(); // return status ignored
         }
     }

     /**
      * Closes the given {@code Closeable}. Suppresses any IO exceptions.
      */
     private static void closeQuietly(Closeable closeable) {
         try {
             closeable.close();
         } catch (IOException e) {
             Log.w(TAG, "Failed to close resource", e);
         }
     }
 }
	/*
	* 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 androidx.multidex;

	import android.content.Context;
	import android.content.SharedPreferences;
	import android.os.Build;
	import android.util.Log;
	import java.io.BufferedOutputStream;
	import java.io.Closeable;
	import java.io.File;
	import java.io.FileFilter;
	import java.io.FileNotFoundException;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.RandomAccessFile;
	import java.nio.channels.FileChannel;
	import java.nio.channels.FileLock;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.zip.ZipEntry;
	import java.util.zip.ZipFile;
	import java.util.zip.ZipOutputStream;

	/**
	* Exposes application secondary dex files as files in the application data
	* directory.
	* {@link MultiDexExtractor} is taking the file lock in the dex dir on creation and release it
	* during close.
	*/
	final class MultiDexExtractor implements Closeable {

	/**
	* Zip file containing one secondary dex file.
	*/
	private static class ExtractedDex extends File {
	public long crc = NO_VALUE;

	public ExtractedDex(File dexDir, String fileName) {
	super(dexDir, fileName);
	}
	}

	private static final String TAG = MultiDex.TAG;

	/**
	* We look for additional dex files named {@code classes2.dex},
	* {@code classes3.dex}, etc.
	*/
	private static final String DEX_PREFIX = "classes";
	static final String DEX_SUFFIX = ".dex";

	private static final String EXTRACTED_NAME_EXT = ".classes";
	static final String EXTRACTED_SUFFIX = ".zip";
	private static final int MAX_EXTRACT_ATTEMPTS = 3;

	private static final String PREFS_FILE = "multidex.version";
	private static final String KEY_TIME_STAMP = "timestamp";
	private static final String KEY_CRC = "crc";
	private static final String KEY_DEX_NUMBER = "dex.number";
	private static final String KEY_DEX_CRC = "dex.crc.";
	private static final String KEY_DEX_TIME = "dex.time.";

	/**
	* Size of reading buffers.
	*/
	private static final int BUFFER_SIZE = 0x4000;
	/* Keep value away from 0 because it is a too probable time stamp value */
	private static final long NO_VALUE = -1L;

	private static final String LOCK_FILENAME = "MultiDex.lock";
	private final File sourceApk;
	private final long sourceCrc;
	private final File dexDir;
	private final RandomAccessFile lockRaf;
	private final FileChannel lockChannel;
	private final FileLock cacheLock;

	MultiDexExtractor(File sourceApk, File dexDir) throws IOException {
	Log.i(TAG, "MultiDexExtractor(" + sourceApk.getPath() + ", " + dexDir.getPath() + ")");
	this.sourceApk = sourceApk;
	this.dexDir = dexDir;
	sourceCrc = getZipCrc(sourceApk);
	File lockFile = new File(dexDir, LOCK_FILENAME);
	lockRaf = new RandomAccessFile(lockFile, "rw");
	try {
	lockChannel = lockRaf.getChannel();
	try {
	Log.i(TAG, "Blocking on lock " + lockFile.getPath());
	cacheLock = lockChannel.lock();
	} catch (IOException \| RuntimeException \| Error e) {
	closeQuietly(lockChannel);
	throw e;
	}
	Log.i(TAG, lockFile.getPath() + " locked");
	} catch (IOException \| RuntimeException \| Error e) {
	closeQuietly(lockRaf);
	throw e;
	}
	}

	/**
	* Extracts application secondary dexes into files in the application data
	* directory.
	*
	* @return a list of files that were created. The list may be empty if there
	* are no secondary dex files. Never return null.
	* @throws IOException if encounters a problem while reading or writing
	* secondary dex files
	*/
	List<? extends File> load(Context context, String prefsKeyPrefix, boolean forceReload)
	throws IOException {
	Log.i(TAG, "MultiDexExtractor.load(" + sourceApk.getPath() + ", " + forceReload + ", " +
	prefsKeyPrefix + ")");

	if (!cacheLock.isValid()) {
	throw new IllegalStateException("MultiDexExtractor was closed");
	}

	List<ExtractedDex> files;
	if (!forceReload && !isModified(context, sourceApk, sourceCrc, prefsKeyPrefix)) {
	try {
	files = loadExistingExtractions(context, prefsKeyPrefix);
	} catch (IOException ioe) {
	Log.w(TAG, "Failed to reload existing extracted secondary dex files,"
	+ " falling back to fresh extraction", ioe);
	files = performExtractions();
	putStoredApkInfo(context, prefsKeyPrefix, getTimeStamp(sourceApk), sourceCrc,
	files);
	}
	} else {
	if (forceReload) {
	Log.i(TAG, "Forced extraction must be performed.");
	} else {
	Log.i(TAG, "Detected that extraction must be performed.");
	}
	files = performExtractions();
	putStoredApkInfo(context, prefsKeyPrefix, getTimeStamp(sourceApk), sourceCrc,
	files);
	}

	Log.i(TAG, "load found " + files.size() + " secondary dex files");
	return files;
	}

	@Override
	public void close() throws IOException {
	cacheLock.release();
	lockChannel.close();
	lockRaf.close();
	}

	/**
	* Load previously extracted secondary dex files. Should be called only while owning the lock on
	* {@link #LOCK_FILENAME}.
	*/
	private List<ExtractedDex> loadExistingExtractions(
	Context context,
	String prefsKeyPrefix)
	throws IOException {
	Log.i(TAG, "loading existing secondary dex files");

	final String extractedFilePrefix = sourceApk.getName() + EXTRACTED_NAME_EXT;
	SharedPreferences multiDexPreferences = getMultiDexPreferences(context);
	int totalDexNumber = multiDexPreferences.getInt(prefsKeyPrefix + KEY_DEX_NUMBER, 1);
	final List<ExtractedDex> files = new ArrayList<ExtractedDex>(totalDexNumber - 1);

	for (int secondaryNumber = 2; secondaryNumber <= totalDexNumber; secondaryNumber++) {
	String fileName = extractedFilePrefix + secondaryNumber + EXTRACTED_SUFFIX;
	ExtractedDex extractedFile = new ExtractedDex(dexDir, fileName);
	if (extractedFile.isFile()) {
	extractedFile.crc = getZipCrc(extractedFile);
	long expectedCrc = multiDexPreferences.getLong(
	prefsKeyPrefix + KEY_DEX_CRC + secondaryNumber, NO_VALUE);
	long expectedModTime = multiDexPreferences.getLong(
	prefsKeyPrefix + KEY_DEX_TIME + secondaryNumber, NO_VALUE);
	long lastModified = extractedFile.lastModified();
	if ((expectedModTime != lastModified)
	\|\| (expectedCrc != extractedFile.crc)) {
	throw new IOException("Invalid extracted dex: " + extractedFile +
	" (key \"" + prefsKeyPrefix + "\"), expected modification time: "
	+ expectedModTime + ", modification time: "
	+ lastModified + ", expected crc: "
	+ expectedCrc + ", file crc: " + extractedFile.crc);
	}
	files.add(extractedFile);
	} else {
	throw new IOException("Missing extracted secondary dex file '" +
	extractedFile.getPath() + "'");
	}
	}

	return files;
	}


	/**
	* Compare current archive and crc with values stored in {@link SharedPreferences}. Should be
	* called only while owning the lock on {@link #LOCK_FILENAME}.
	*/
	private static boolean isModified(Context context, File archive, long currentCrc,
	String prefsKeyPrefix) {
	SharedPreferences prefs = getMultiDexPreferences(context);
	return (prefs.getLong(prefsKeyPrefix + KEY_TIME_STAMP, NO_VALUE) != getTimeStamp(archive))
	\|\| (prefs.getLong(prefsKeyPrefix + KEY_CRC, NO_VALUE) != currentCrc);
	}

	private static long getTimeStamp(File archive) {
	long timeStamp = archive.lastModified();
	if (timeStamp == NO_VALUE) {
	// never return NO_VALUE
	timeStamp--;
	}
	return timeStamp;
	}


	private static long getZipCrc(File archive) throws IOException {
	long computedValue = ZipUtil.getZipCrc(archive);
	if (computedValue == NO_VALUE) {
	// never return NO_VALUE
	computedValue--;
	}
	return computedValue;
	}

	private List<ExtractedDex> performExtractions() throws IOException {

	final String extractedFilePrefix = sourceApk.getName() + EXTRACTED_NAME_EXT;

	// It is safe to fully clear the dex dir because we own the file lock so no other process is
	// extracting or running optimizing dexopt. It may cause crash of already running
	// applications if for whatever reason we end up extracting again over a valid extraction.
	clearDexDir();

	List<ExtractedDex> files = new ArrayList<ExtractedDex>();

	final ZipFile apk = new ZipFile(sourceApk);
	try {

	int secondaryNumber = 2;

	ZipEntry dexFile = apk.getEntry(DEX_PREFIX + secondaryNumber + DEX_SUFFIX);
	while (dexFile != null) {
	String fileName = extractedFilePrefix + secondaryNumber + EXTRACTED_SUFFIX;
	ExtractedDex extractedFile = new ExtractedDex(dexDir, fileName);
	files.add(extractedFile);

	Log.i(TAG, "Extraction is needed for file " + extractedFile);
	int numAttempts = 0;
	boolean isExtractionSuccessful = false;
	while (numAttempts < MAX_EXTRACT_ATTEMPTS && !isExtractionSuccessful) {
	numAttempts++;

	// Create a zip file (extractedFile) containing only the secondary dex file
	// (dexFile) from the apk.
	extract(apk, dexFile, extractedFile, extractedFilePrefix);

	// Read zip crc of extracted dex
	try {
	extractedFile.crc = getZipCrc(extractedFile);
	isExtractionSuccessful = true;
	} catch (IOException e) {
	isExtractionSuccessful = false;
	Log.w(TAG, "Failed to read crc from " + extractedFile.getAbsolutePath(), e);
	}

	// Log size and crc of the extracted zip file
	Log.i(TAG, "Extraction " + (isExtractionSuccessful ? "succeeded" : "failed")
	+ " '" + extractedFile.getAbsolutePath() + "': length "
	+ extractedFile.length() + " - crc: " + extractedFile.crc);
	if (!isExtractionSuccessful) {
	// Delete the extracted file
	extractedFile.delete();
	if (extractedFile.exists()) {
	Log.w(TAG, "Failed to delete corrupted secondary dex '" +
	extractedFile.getPath() + "'");
	}
	}
	}
	if (!isExtractionSuccessful) {
	throw new IOException("Could not create zip file " +
	extractedFile.getAbsolutePath() + " for secondary dex (" +
	secondaryNumber + ")");
	}
	secondaryNumber++;
	dexFile = apk.getEntry(DEX_PREFIX + secondaryNumber + DEX_SUFFIX);
	}
	} finally {
	try {
	apk.close();
	} catch (IOException e) {
	Log.w(TAG, "Failed to close resource", e);
	}
	}

	return files;
	}

	/**
	* Save {@link SharedPreferences}. Should be called only while owning the lock on
	* {@link #LOCK_FILENAME}.
	*/
	private static void putStoredApkInfo(Context context, String keyPrefix, long timeStamp,
	long crc, List<ExtractedDex> extractedDexes) {
	SharedPreferences prefs = getMultiDexPreferences(context);
	SharedPreferences.Editor edit = prefs.edit();
	edit.putLong(keyPrefix + KEY_TIME_STAMP, timeStamp);
	edit.putLong(keyPrefix + KEY_CRC, crc);
	edit.putInt(keyPrefix + KEY_DEX_NUMBER, extractedDexes.size() + 1);

	int extractedDexId = 2;
	for (ExtractedDex dex : extractedDexes) {
	edit.putLong(keyPrefix + KEY_DEX_CRC + extractedDexId, dex.crc);
	edit.putLong(keyPrefix + KEY_DEX_TIME + extractedDexId, dex.lastModified());
	extractedDexId++;
	}
	/* Use commit() and not apply() as advised by the doc because we need synchronous writing of
	* the editor content and apply is doing an "asynchronous commit to disk".
	*/
	edit.commit();
	}

	/**
	* Get the MuliDex {@link SharedPreferences} for the current application. Should be called only
	* while owning the lock on {@link #LOCK_FILENAME}.
	*/
	private static SharedPreferences getMultiDexPreferences(Context context) {
	return context.getSharedPreferences(PREFS_FILE,
	Build.VERSION.SDK_INT < 11 /* Build.VERSION_CODES.HONEYCOMB */
	? Context.MODE_PRIVATE
	: Context.MODE_PRIVATE \| 0x0004 /* Context.MODE_MULTI_PROCESS */);
	}

	/**
	* Clear the dex dir from all files but the lock.
	*/
	private void clearDexDir() {
	File[] files = dexDir.listFiles(new FileFilter() {
	@Override
	public boolean accept(File pathname) {
	return !pathname.getName().equals(LOCK_FILENAME);
	}
	});
	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());
	}
	}
	}

	private static void extract(ZipFile apk, ZipEntry dexFile, File extractTo,
	String extractedFilePrefix) throws IOException, FileNotFoundException {

	InputStream in = apk.getInputStream(dexFile);
	ZipOutputStream out = null;
	// Temp files must not start with extractedFilePrefix to get cleaned up in prepareDexDir()
	File tmp = File.createTempFile("tmp-" + extractedFilePrefix, EXTRACTED_SUFFIX,
	extractTo.getParentFile());
	Log.i(TAG, "Extracting " + tmp.getPath());
	try {
	out = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(tmp)));
	try {
	ZipEntry classesDex = new ZipEntry("classes.dex");
	// keep zip entry time since it is the criteria used by Dalvik
	classesDex.setTime(dexFile.getTime());
	out.putNextEntry(classesDex);

	byte[] buffer = new byte[BUFFER_SIZE];
	int length = in.read(buffer);
	while (length != -1) {
	out.write(buffer, 0, length);
	length = in.read(buffer);
	}
	out.closeEntry();
	} finally {
	out.close();
	}
	if (!tmp.setReadOnly()) {
	throw new IOException("Failed to mark readonly \"" + tmp.getAbsolutePath() +
	"\" (tmp of \"" + extractTo.getAbsolutePath() + "\")");
	}
	Log.i(TAG, "Renaming to " + extractTo.getPath());
	if (!tmp.renameTo(extractTo)) {
	throw new IOException("Failed to rename \"" + tmp.getAbsolutePath() +
	"\" to \"" + extractTo.getAbsolutePath() + "\"");
	}
	} finally {
	closeQuietly(in);
	tmp.delete(); // return status ignored
	}
	}

	/**
	* Closes the given {@code Closeable}. Suppresses any IO exceptions.
	*/
	private static void closeQuietly(Closeable closeable) {
	try {
	closeable.close();
	} catch (IOException e) {
	Log.w(TAG, "Failed to close resource", e);
	}
	}
	}