@revopush/react-native-code-push 0.0.1

package/android/app/src/main/java/com/microsoft/codepush/react/FileUtils.java

@@ -0,0 +1,203 @@
+package com.microsoft.codepush.react;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+public class FileUtils {
+
+    private static final int WRITE_BUFFER_SIZE = 1024 * 8;
+
+    public static void copyDirectoryContents(String sourceDirectoryPath, String destinationDirectoryPath) throws IOException {
+        File sourceDir = new File(sourceDirectoryPath);
+        File destDir = new File(destinationDirectoryPath);
+        if (!destDir.exists()) {
+            destDir.mkdir();
+        }
+
+        for (File sourceFile : sourceDir.listFiles()) {
+            if (sourceFile.isDirectory()) {
+                copyDirectoryContents(
+                        CodePushUtils.appendPathComponent(sourceDirectoryPath, sourceFile.getName()),
+                        CodePushUtils.appendPathComponent(destinationDirectoryPath, sourceFile.getName()));
+            } else {
+                File destFile = new File(destDir, sourceFile.getName());
+                FileInputStream fromFileStream = null;
+                BufferedInputStream fromBufferedStream = null;
+                FileOutputStream destStream = null;
+                byte[] buffer = new byte[WRITE_BUFFER_SIZE];
+                try {
+                    fromFileStream = new FileInputStream(sourceFile);
+                    fromBufferedStream = new BufferedInputStream(fromFileStream);
+                    destStream = new FileOutputStream(destFile);
+                    int bytesRead;
+                    while ((bytesRead = fromBufferedStream.read(buffer)) > 0) {
+                        destStream.write(buffer, 0, bytesRead);
+                    }
+                } finally {
+                    try {
+                        if (fromFileStream != null) fromFileStream.close();
+                        if (fromBufferedStream != null) fromBufferedStream.close();
+                        if (destStream != null) destStream.close();
+                    } catch (IOException e) {
+                        throw new CodePushUnknownException("Error closing IO resources.", e);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void deleteDirectoryAtPath(String directoryPath) {
+        if (directoryPath == null) {
+            CodePushUtils.log("deleteDirectoryAtPath attempted with null directoryPath");
+            return;
+        }
+        File file = new File(directoryPath);
+        if (file.exists()) {
+            deleteFileOrFolderSilently(file);
+        }
+    }
+
+    public static void deleteFileAtPathSilently(String path) {
+        deleteFileOrFolderSilently(new File(path));
+    }
+
+    public static void deleteFileOrFolderSilently(File file) {
+        if (file.isDirectory()) {
+            File[] files = file.listFiles();
+            for (File fileEntry : files) {
+                if (fileEntry.isDirectory()) {
+                    deleteFileOrFolderSilently(fileEntry);
+                } else {
+                    fileEntry.delete();
+                }
+            }
+        }
+
+        if (!file.delete()) {
+            CodePushUtils.log("Error deleting file " + file.getName());
+        }
+    }
+
+    public static boolean fileAtPathExists(String filePath) {
+        return new File(filePath).exists();
+    }
+
+    public static void moveFile(File fileToMove, String newFolderPath, String newFileName) {
+        File newFolder = new File(newFolderPath);
+        if (!newFolder.exists()) {
+            newFolder.mkdirs();
+        }
+
+        File newFilePath = new File(newFolderPath, newFileName);
+        if (!fileToMove.renameTo(newFilePath)) {
+            throw new CodePushUnknownException("Unable to move file from " +
+                    fileToMove.getAbsolutePath() + " to " + newFilePath.getAbsolutePath() + ".");
+        }
+    }
+
+    public static String readFileToString(String filePath) throws IOException {
+        FileInputStream fin = null;
+        BufferedReader reader = null;
+        try {
+            File fl = new File(filePath);
+            fin = new FileInputStream(fl);
+            reader = new BufferedReader(new InputStreamReader(fin));
+            StringBuilder sb = new StringBuilder();
+            String line = null;
+            while ((line = reader.readLine()) != null) {
+                sb.append(line).append("\n");
+            }
+
+            return sb.toString();
+        } finally {
+            if (reader != null) reader.close();
+            if (fin != null) fin.close();
+        }
+    }
+
+    private static String validateFileName(String fileName, File destinationFolder) throws IOException {
+        String destinationFolderCanonicalPath = destinationFolder.getCanonicalPath() + File.separator;
+
+        File file = new File(destinationFolderCanonicalPath, fileName);
+        String canonicalPath = file.getCanonicalPath();
+
+        if (!canonicalPath.startsWith(destinationFolderCanonicalPath)) {
+            throw new IllegalStateException("File is outside extraction target directory.");
+        }
+
+        return canonicalPath;
+    }
+
+    public static void unzipFile(File zipFile, String destination) throws IOException {
+        FileInputStream fileStream = null;
+        BufferedInputStream bufferedStream = null;
+        ZipInputStream zipStream = null;
+        try {
+            fileStream = new FileInputStream(zipFile);
+            bufferedStream = new BufferedInputStream(fileStream);
+            zipStream = new ZipInputStream(bufferedStream);
+            ZipEntry entry;
+
+            File destinationFolder = new File(destination);
+            if (destinationFolder.exists()) {
+                deleteFileOrFolderSilently(destinationFolder);
+            }
+
+            destinationFolder.mkdirs();
+
+            byte[] buffer = new byte[WRITE_BUFFER_SIZE];
+            while ((entry = zipStream.getNextEntry()) != null) {
+                String fileName = validateFileName(entry.getName(), destinationFolder);
+                File file = new File(fileName);
+                if (entry.isDirectory()) {
+                    file.mkdirs();
+                } else {
+                    File parent = file.getParentFile();
+                    if (!parent.exists()) {
+                        parent.mkdirs();
+                    }
+
+                    FileOutputStream fout = new FileOutputStream(file);
+                    try {
+                        int numBytesRead;
+                        while ((numBytesRead = zipStream.read(buffer)) != -1) {
+                            fout.write(buffer, 0, numBytesRead);
+                        }
+                    } finally {
+                        fout.close();
+                    }
+                }
+                long time = entry.getTime();
+                if (time > 0) {
+                    file.setLastModified(time);
+                }
+            }
+        } finally {
+            try {
+                if (zipStream != null) zipStream.close();
+                if (bufferedStream != null) bufferedStream.close();
+                if (fileStream != null) fileStream.close();
+            } catch (IOException e) {
+                throw new CodePushUnknownException("Error closing IO resources.", e);
+            }
+        }
+    }
+
+    public static void writeStringToFile(String content, String filePath) throws IOException {
+        PrintWriter out = null;
+        try {
+            out = new PrintWriter(filePath);
+            out.print(content);
+        } finally {
+            if (out != null) out.close();
+        }
+    }
+}

package/android/app/src/main/java/com/microsoft/codepush/react/ReactHostHolder.java

@@ -0,0 +1,11 @@
+package com.microsoft.codepush.react;
+
+import com.facebook.react.ReactHost;
+import com.facebook.react.runtime.ReactHostDelegate;
+
+/**
+ * Provides access to a {@link ReactHostDelegate}
+ */
+public interface ReactHostHolder {
+    ReactHost getReactHost();
+}

package/android/app/src/main/java/com/microsoft/codepush/react/ReactInstanceHolder.java

@@ -0,0 +1,17 @@
+package com.microsoft.codepush.react;
+
+import com.facebook.react.ReactInstanceManager;
+
+/**
+ * Provides access to a {@link ReactInstanceManager}.
+ *
+ * ReactNativeHost already implements this interface, if you make use of that react-native
+ * component (just add `implements ReactInstanceHolder`).
+ */
+public interface ReactInstanceHolder {
+
+  /**
+   * Get the current {@link ReactInstanceManager} instance. May return null.
+   */
+  ReactInstanceManager getReactInstanceManager();
+}

package/android/app/src/main/java/com/microsoft/codepush/react/SettingsManager.java

@@ -0,0 +1,173 @@
+package com.microsoft.codepush.react;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class SettingsManager {
+
+    private SharedPreferences mSettings;
+
+    public SettingsManager(Context applicationContext) {
+        mSettings = applicationContext.getSharedPreferences(CodePushConstants.CODE_PUSH_PREFERENCES, 0);
+    }
+
+    public JSONArray getFailedUpdates() {
+        String failedUpdatesString = mSettings.getString(CodePushConstants.FAILED_UPDATES_KEY, null);
+        if (failedUpdatesString == null) {
+            return new JSONArray();
+        }
+
+        try {
+            return new JSONArray(failedUpdatesString);
+        } catch (JSONException e) {
+            // Unrecognized data format, clear and replace with expected format.
+            JSONArray emptyArray = new JSONArray();
+            mSettings.edit().putString(CodePushConstants.FAILED_UPDATES_KEY, emptyArray.toString()).commit();
+            return emptyArray;
+        }
+    }
+
+    public JSONObject getPendingUpdate() {
+        String pendingUpdateString = mSettings.getString(CodePushConstants.PENDING_UPDATE_KEY, null);
+        if (pendingUpdateString == null) {
+            return null;
+        }
+
+        try {
+            return new JSONObject(pendingUpdateString);
+        } catch (JSONException e) {
+            // Should not happen.
+            CodePushUtils.log("Unable to parse pending update metadata " + pendingUpdateString +
+                    " stored in SharedPreferences");
+            return null;
+        }
+    }
+
+
+    public boolean isFailedHash(String packageHash) {
+        JSONArray failedUpdates = getFailedUpdates();
+        if (packageHash != null) {
+            for (int i = 0; i < failedUpdates.length(); i++) {
+                try {
+                    JSONObject failedPackage = failedUpdates.getJSONObject(i);
+                    String failedPackageHash = failedPackage.getString(CodePushConstants.PACKAGE_HASH_KEY);
+                    if (packageHash.equals(failedPackageHash)) {
+                        return true;
+                    }
+                } catch (JSONException e) {
+                    throw new CodePushUnknownException("Unable to read failedUpdates data stored in SharedPreferences.", e);
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public boolean isPendingUpdate(String packageHash) {
+        JSONObject pendingUpdate = getPendingUpdate();
+
+        try {
+            return pendingUpdate != null &&
+                    !pendingUpdate.getBoolean(CodePushConstants.PENDING_UPDATE_IS_LOADING_KEY) &&
+                    (packageHash == null || pendingUpdate.getString(CodePushConstants.PENDING_UPDATE_HASH_KEY).equals(packageHash));
+        } catch (JSONException e) {
+            throw new CodePushUnknownException("Unable to read pending update metadata in isPendingUpdate.", e);
+        }
+    }
+
+    public void removeFailedUpdates() {
+        mSettings.edit().remove(CodePushConstants.FAILED_UPDATES_KEY).commit();
+    }
+
+    public void removePendingUpdate() {
+        mSettings.edit().remove(CodePushConstants.PENDING_UPDATE_KEY).commit();
+    }
+
+    public void saveFailedUpdate(JSONObject failedPackage) {
+        try {
+            if (isFailedHash(failedPackage.getString(CodePushConstants.PACKAGE_HASH_KEY))) {
+                // Do not need to add the package if it is already in the failedUpdates.
+                return;
+            }
+        } catch (JSONException e) {
+            throw new CodePushUnknownException("Unable to read package hash from package.", e);
+        }
+
+        String failedUpdatesString = mSettings.getString(CodePushConstants.FAILED_UPDATES_KEY, null);
+        JSONArray failedUpdates;
+        if (failedUpdatesString == null) {
+            failedUpdates = new JSONArray();
+        } else {
+            try {
+                failedUpdates = new JSONArray(failedUpdatesString);
+            } catch (JSONException e) {
+                // Should not happen.
+                throw new CodePushMalformedDataException("Unable to parse failed updates information " +
+                        failedUpdatesString + " stored in SharedPreferences", e);
+            }
+        }
+
+        failedUpdates.put(failedPackage);
+        mSettings.edit().putString(CodePushConstants.FAILED_UPDATES_KEY, failedUpdates.toString()).commit();
+    }
+
+    public JSONObject getLatestRollbackInfo() {
+        String latestRollbackInfoString = mSettings.getString(CodePushConstants.LATEST_ROLLBACK_INFO_KEY, null);
+        if (latestRollbackInfoString == null) {
+            return null;
+        }
+
+        try {
+            return new JSONObject(latestRollbackInfoString);
+        } catch (JSONException e) {
+            // Should not happen.
+            CodePushUtils.log("Unable to parse latest rollback metadata " + latestRollbackInfoString +
+                    " stored in SharedPreferences");
+            return null;
+        }
+    }
+
+    public void setLatestRollbackInfo(String packageHash) {
+        JSONObject latestRollbackInfo = getLatestRollbackInfo();
+        int count = 0;
+
+        if (latestRollbackInfo != null) {
+            try {
+                String latestRollbackPackageHash = latestRollbackInfo.getString(CodePushConstants.LATEST_ROLLBACK_PACKAGE_HASH_KEY);
+                if (latestRollbackPackageHash.equals(packageHash)) {
+                    count = latestRollbackInfo.getInt(CodePushConstants.LATEST_ROLLBACK_COUNT_KEY);
+                }
+            } catch (JSONException e) {
+                CodePushUtils.log("Unable to parse latest rollback info.");
+            }
+        } else {
+            latestRollbackInfo = new JSONObject();
+        }
+
+        try {
+            latestRollbackInfo.put(CodePushConstants.LATEST_ROLLBACK_PACKAGE_HASH_KEY, packageHash);
+            latestRollbackInfo.put(CodePushConstants.LATEST_ROLLBACK_TIME_KEY, System.currentTimeMillis());
+            latestRollbackInfo.put(CodePushConstants.LATEST_ROLLBACK_COUNT_KEY, count + 1);
+            mSettings.edit().putString(CodePushConstants.LATEST_ROLLBACK_INFO_KEY, latestRollbackInfo.toString()).commit();
+        } catch (JSONException e) {
+            throw new CodePushUnknownException("Unable to save latest rollback info.", e);
+        }
+    }
+
+    public void savePendingUpdate(String packageHash, boolean isLoading) {
+        JSONObject pendingUpdate = new JSONObject();
+        try {
+            pendingUpdate.put(CodePushConstants.PENDING_UPDATE_HASH_KEY, packageHash);
+            pendingUpdate.put(CodePushConstants.PENDING_UPDATE_IS_LOADING_KEY, isLoading);
+            mSettings.edit().putString(CodePushConstants.PENDING_UPDATE_KEY, pendingUpdate.toString()).commit();
+        } catch (JSONException e) {
+            // Should not happen.
+            throw new CodePushUnknownException("Unable to save pending update.", e);
+        }
+    }
+
+}

package/android/app/src/main/java/com/microsoft/codepush/react/TLSSocketFactory.java

@@ -0,0 +1,72 @@
+package com.microsoft.codepush.react;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+
+public class TLSSocketFactory extends SSLSocketFactory {
+
+    private SSLSocketFactory delegate;
+
+    public TLSSocketFactory() throws KeyManagementException, NoSuchAlgorithmException {
+        SSLContext context = SSLContext.getInstance("TLS");
+        context.init(null, null, null);
+        delegate = context.getSocketFactory();
+    }
+
+    @Override
+    public String[] getDefaultCipherSuites() {
+        return delegate.getDefaultCipherSuites();
+    }
+
+    @Override
+    public String[] getSupportedCipherSuites() {
+        return delegate.getSupportedCipherSuites();
+    }
+
+    @Override
+    public Socket createSocket() throws IOException {
+        return enableTLSOnSocket(delegate.createSocket());
+    }
+
+    @Override
+    public Socket createSocket(Socket s, String host, int port, boolean autoClose) throws IOException {
+        return enableTLSOnSocket(delegate.createSocket(s, host, port, autoClose));
+    }
+
+    @Override
+    public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
+        return enableTLSOnSocket(delegate.createSocket(host, port));
+    }
+
+    @Override
+    public Socket createSocket(String host, int port, InetAddress localHost, int localPort)
+            throws IOException, UnknownHostException {
+        return enableTLSOnSocket(delegate.createSocket(host, port, localHost, localPort));
+    }
+
+    @Override
+    public Socket createSocket(InetAddress host, int port) throws IOException {
+        return enableTLSOnSocket(delegate.createSocket(host, port));
+    }
+
+    @Override
+    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort)
+            throws IOException {
+        return enableTLSOnSocket(delegate.createSocket(address, port, localAddress, localPort));
+    }
+
+    private Socket enableTLSOnSocket(Socket socket) {
+        if (socket != null && (socket instanceof SSLSocket)) {
+            ((SSLSocket) socket).setEnabledProtocols(new String[] { "TLSv1.1", "TLSv1.2" });
+        }
+        return socket;
+    }
+}

package/android/build.gradle

@@ -0,0 +1,24 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:1.3.0'
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    android {
+        namespace "com.microsoft.codepush.react"
+    }
+    repositories {
+        mavenLocal()
+        mavenCentral()
+    }
+}

package/android/codepush.gradle

@@ -0,0 +1,162 @@
+// Adapted from https://raw.githubusercontent.com/facebook/react-native/d16ff3bd8b92fa84a9007bf5ebedd8153e4c089d/react.gradle
+
+import java.nio.file.Paths;
+
+def config = project.extensions.findByName("react") ?: [:]
+def bundleAssetName = config.bundleAssetName ? config.bundleAssetName.get() : "index.android.bundle"
+
+// because elvis operator
+def elvisFile(thing) {
+    return thing ? file(thing) : null;
+}
+
+void runBefore(String dependentTaskName, Task task) {
+    Task dependentTask = tasks.findByPath(dependentTaskName);
+    if (dependentTask != null) {
+        dependentTask.dependsOn task
+    }
+}
+
+/**
+ * Finds the path of the installed npm package with the given name using Node's
+ * module resolution algorithm, which searches "node_modules" directories up to
+ * the file system root. This handles various cases, including:
+ *
+ *   - Working in the open-source RN repo:
+ *       Gradle: /path/to/react-native/ReactAndroid
+ *       Node module: /path/to/react-native/node_modules/[package]
+ *
+ *   - Installing RN as a dependency of an app and searching for hoisted
+ *     dependencies:
+ *       Gradle: /path/to/app/node_modules/react-native/ReactAndroid
+ *       Node module: /path/to/app/node_modules/[package]
+ *
+ *   - Working in a larger repo (e.g., Facebook) that contains RN:
+ *       Gradle: /path/to/repo/path/to/react-native/ReactAndroid
+ *       Node module: /path/to/repo/node_modules/[package]
+ *
+ * The search begins at the given base directory (a File object). The returned
+ * path is a string.
+ */
+static def findNodeModulePath(baseDir, packageName) {
+    def basePath = baseDir.toPath().normalize()
+    // Node's module resolution algorithm searches up to the root directory,
+    // after which the base path will be null
+    while (basePath) {
+        def candidatePath = Paths.get(basePath.toString(), "node_modules", packageName)
+        if (candidatePath.toFile().exists()) {
+            return candidatePath.toString()
+        }
+        basePath = basePath.getParent()
+    }
+    return null
+}
+
+android.buildTypes.each { buildType ->
+    // to prevent incorrect long value restoration from strings.xml we need to wrap it with double quotes
+    // https://github.com/microsoft/cordova-plugin-code-push/issues/264
+    buildType.resValue 'string', "CODE_PUSH_APK_BUILD_TIME", String.format("\"%d\"", System.currentTimeMillis())
+}
+
+gradle.projectsEvaluated {
+    def debuggableVariants = config.debuggableVariants ? config.debuggableVariants.get() : ['debug']
+
+    android.applicationVariants.all { variant ->
+        // No code push for debuggable variants
+        if (debuggableVariants.contains(variant.name)) {
+            return;
+        }
+
+        def nodeModulesPath;
+        if (project.hasProperty('nodeModulesPath')) {
+            nodeModulesPath = "${project.nodeModulesPath}/@revopush/react-native-code-push"
+        } else {
+            nodeModulesPath = findNodeModulePath(projectDir, "@revopush/react-native-code-push")
+        }
+
+        def targetName = variant.name.capitalize()
+        def targetPath = variant.dirName
+
+        def jsBundleDir;
+        def resourcesDir;
+        def jsBundleFile;
+
+        // Additional node commandline arguments
+        def nodeExecutableAndArgs = config.nodeExecutableAndArgs ? config.nodeExecutableAndArgs.get(): ["node"]
+        def extraPackagerArgs = config.extraPackagerArgs ? config.extraPackagerArgs.get() : []
+
+        // Make this task run right after the bundle task
+        def generateBundledResourcesHash;
+
+        def reactBundleTask = tasks.findByName("createBundle${targetName}JsAndAssets")
+        if (reactBundleTask) {
+            jsBundleDir = reactBundleTask.property('jsBundleDir').asFile.get()
+            resourcesDir = reactBundleTask.property('resourcesDir').asFile.get()
+
+            // mitigates Resource and asset merger: Duplicate resources error
+            project.delete(files("${jsBundleDir}"))
+
+            jsBundleDir.mkdirs()
+            resourcesDir.mkdirs()
+
+            jsBundleFile = file("$jsBundleDir/$bundleAssetName")
+
+            generateBundledResourcesHash = tasks.create(
+                    name: "generateBundledResourcesHash${targetName}",
+                    type: Exec) {
+                commandLine (*nodeExecutableAndArgs, "${nodeModulesPath}/scripts/generateBundledResourcesHash.js", resourcesDir, jsBundleFile, jsBundleDir)
+
+                enabled !debuggableVariants.contains(variant.name) ?: targetName.toLowerCase().contains("release")
+            }
+
+            runBefore("merge${targetName}Resources", generateBundledResourcesHash)
+            runBefore("merge${targetName}Assets", generateBundledResourcesHash)
+        } else {
+            def jsBundleDirConfigName = "jsBundleDir${targetName}"
+            jsBundleDir = elvisFile(config."$jsBundleDirConfigName") ? elvisFile(config."$jsBundleDirConfigName").get():
+                    file("$buildDir/intermediates/assets/${targetPath}")
+
+            def resourcesDirConfigName = "resourcesDir${targetName}"
+            resourcesDir = elvisFile(config."${resourcesDirConfigName}") ? elvisFile(config."${resourcesDirConfigName}").get():
+                    file("$buildDir/intermediates/res/merged/${targetPath}")
+
+            // In case version of 'Android Plugin for Gradle'' is lower than 1.3.0
+            // '$buildDir' has slightly different structure - 'merged' folder
+            // does not exists so '${targetPath}' folder contains directly in 'res' folder.
+            if (!resourcesDir.exists() && file("$buildDir/intermediates/res/${targetPath}").exists()) {
+                resourcesDir = file("$buildDir/intermediates/res/${targetPath}")
+            }
+
+            jsBundleFile = file("$jsBundleDir/$bundleAssetName")
+
+            def resourcesMapTempFileName = "CodePushResourcesMap-" + java.util.UUID.randomUUID().toString().substring(0,8) + ".json"
+
+            generateBundledResourcesHash = tasks.create(
+                    name: "generateBundledResourcesHash${targetName}",
+                    type: Exec) {
+                commandLine (*nodeExecutableAndArgs, "${nodeModulesPath}/scripts/generateBundledResourcesHash.js", resourcesDir, jsBundleFile, jsBundleDir, resourcesMapTempFileName)
+            }
+
+            // Make this task run right before the bundle task
+            def recordFilesBeforeBundleCommand = tasks.create(
+                    name: "recordFilesBeforeBundleCommand${targetName}",
+                    type: Exec) {
+                commandLine (*nodeExecutableAndArgs, "${nodeModulesPath}/scripts/recordFilesBeforeBundleCommand.js", resourcesDir, resourcesMapTempFileName)
+            }
+
+            recordFilesBeforeBundleCommand.dependsOn("merge${targetName}Resources")
+            recordFilesBeforeBundleCommand.dependsOn("merge${targetName}Assets")
+            runBefore("bundle${targetName}JsAndAssets", recordFilesBeforeBundleCommand)
+
+            // We need to generate and record the resources map, but we use it to generate the bundle hash
+            generateBundledResourcesHash.dependsOn("recordFilesBeforeBundleCommand${targetName}")
+        }
+
+        generateBundledResourcesHash.dependsOn("createBundle${targetName}JsAndAssets")
+
+        runBefore("processArmeabi-v7a${targetName}Resources", generateBundledResourcesHash)
+        runBefore("processX86${targetName}Resources", generateBundledResourcesHash)
+        runBefore("processUniversal${targetName}Resources", generateBundledResourcesHash)
+        runBefore("process${targetName}Resources", generateBundledResourcesHash)
+    }
+}

package/android/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.4-all.zip