@appzung/react-native-code-push 5.7.1

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

@@ -0,0 +1,190 @@
+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();
+        }
+    }
+
+    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 = entry.getName();
+                File file = new File(destinationFolder, 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/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/build.gradle

@@ -0,0 +1,20 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        jcenter()
+    }
+    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 {
+    repositories {
+        mavenLocal()
+        jcenter()
+    }
+}

package/android/codepush.gradle

@@ -0,0 +1,113 @@
+// Adapted from https://raw.githubusercontent.com/facebook/react-native/d16ff3bd8b92fa84a9007bf5ebedd8153e4c089d/react.gradle
+
+import java.nio.file.Paths;
+
+def config = project.hasProperty("react") ? project.react : [];
+def bundleAssetName = config.bundleAssetName ?: "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
+    }
+}
+
+gradle.projectsEvaluated {
+    android.buildTypes.each {
+        // 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
+        it.resValue 'string', "CODE_PUSH_APK_BUILD_TIME", String.format("\"%d\"", System.currentTimeMillis())
+    }
+    
+    android.applicationVariants.all { variant ->
+        def nodeModulesPath;
+        if (config.root) {
+            nodeModulesPath = Paths.get(config.root, "/node_modules");
+        } else if (project.hasProperty('nodeModulesPath')) {
+            nodeModulesPath = project.nodeModulesPath
+        } else {
+            nodeModulesPath = "../../node_modules";
+        }
+
+        def targetName = variant.name.capitalize()
+        def targetPath = variant.dirName
+
+        def jsBundleDir;
+        def resourcesDir;
+        def jsBundleFile;
+
+        // Additional node commandline arguments
+        def nodeExecutableAndArgs = config.nodeExecutableAndArgs ?: ["node"]
+        def extraPackagerArgs = config.extraPackagerArgs ?: []
+
+        // Make this task run right after the bundle task
+        def generateBundledResourcesHash;
+
+        if (variant.hasProperty("bundleJsAndAssets")) {
+            def reactBundleTask = variant.bundleJsAndAssets
+            jsBundleDir = reactBundleTask.generatedAssetsFolders[0].absolutePath
+            resourcesDir = reactBundleTask.generatedResFolders[0].absolutePath
+            jsBundleFile = file("$jsBundleDir/$bundleAssetName")
+
+            generateBundledResourcesHash = tasks.create(
+                    name: "generateBundledResourcesHash${targetName}",
+                    type: Exec) {
+                commandLine (*nodeExecutableAndArgs, "${nodeModulesPath}/react-native-code-push/scripts/generateBundledResourcesHash.js", resourcesDir, jsBundleFile, jsBundleDir)
+
+                enabled config."bundleIn${targetName}" ||
+                config."bundleIn${variant.buildType.name.capitalize()}" ?:
+                targetName.toLowerCase().contains("release")
+            }   
+        } else {
+            def jsBundleDirConfigName = "jsBundleDir${targetName}"
+            jsBundleDir = elvisFile(config."$jsBundleDirConfigName") ?:
+                    file("$buildDir/intermediates/assets/${targetPath}")
+
+            def resourcesDirConfigName = "resourcesDir${targetName}"
+            resourcesDir = elvisFile(config."${resourcesDirConfigName}") ?:
+                    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}/react-native-code-push/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}/react-native-code-push/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("bundle${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

package/android/gradle.properties

@@ -0,0 +1,20 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx10248m -XX:MaxPermSize=256m
+# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+
+android.useDeprecatedNdk=true