@appzung/react-native-code-push 5.7.1

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

@@ -0,0 +1,395 @@
+package com.microsoft.codepush.react;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.res.Resources;
+
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.devsupport.DevInternalSettings;
+import com.facebook.react.devsupport.interfaces.DevSupportManager;
+import com.facebook.react.uimanager.ViewManager;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+public class CodePush implements ReactPackage {
+
+    private static boolean sIsRunningBinaryVersion = false;
+    private static boolean sNeedToReportRollback = false;
+    private static boolean sTestConfigurationFlag = false;
+    private static String sAppVersion = null;
+
+    private boolean mDidUpdate = false;
+
+    private String mAssetsBundleFileName;
+
+    // Helper classes.
+    private CodePushUpdateManager mUpdateManager;
+    private CodePushTelemetryManager mTelemetryManager;
+    private SettingsManager mSettingsManager;
+
+    // Config properties.
+    private String mDeploymentKey;
+    private static String mServerUrl = "https://codepush.appzung.com/";
+
+    private Context mContext;
+    private final boolean mIsDebugMode;
+
+    private static String mPublicKey;
+
+    private static ReactInstanceHolder mReactInstanceHolder;
+    private static CodePush mCurrentInstance;
+
+    public CodePush(String deploymentKey, Context context) {
+        this(deploymentKey, context, false);
+    }
+
+    public static String getServiceUrl() {
+        return mServerUrl;
+    }
+
+    public CodePush(String deploymentKey, Context context, boolean isDebugMode) {
+        mContext = context.getApplicationContext();
+
+        mUpdateManager = new CodePushUpdateManager(context.getFilesDir().getAbsolutePath());
+        mTelemetryManager = new CodePushTelemetryManager(mContext);
+        mDeploymentKey = deploymentKey;
+        mIsDebugMode = isDebugMode;
+        mSettingsManager = new SettingsManager(mContext);
+
+        if (sAppVersion == null) {
+            try {
+                PackageInfo pInfo = mContext.getPackageManager().getPackageInfo(mContext.getPackageName(), 0);
+                sAppVersion = pInfo.versionName;
+            } catch (PackageManager.NameNotFoundException e) {
+                throw new CodePushUnknownException("Unable to get package info for " + mContext.getPackageName(), e);
+            }
+        }
+
+        mCurrentInstance = this;
+
+        clearDebugCacheIfNeeded(null);
+        initializeUpdateAfterRestart();
+    }
+
+    public CodePush(String deploymentKey, Context context, boolean isDebugMode, String serverUrl) {
+        this(deploymentKey, context, isDebugMode);
+        mServerUrl = serverUrl;
+    }
+
+    public CodePush(String deploymentKey, Context context, boolean isDebugMode, int publicKeyResourceDescriptor) {
+        this(deploymentKey, context, isDebugMode);
+
+        mPublicKey = getPublicKeyByResourceDescriptor(publicKeyResourceDescriptor);
+    }
+
+    public CodePush(String deploymentKey, Context context, boolean isDebugMode, String serverUrl, Integer publicKeyResourceDescriptor) {
+        this(deploymentKey, context, isDebugMode);
+
+        if (publicKeyResourceDescriptor != null) {
+            mPublicKey = getPublicKeyByResourceDescriptor(publicKeyResourceDescriptor);
+        }
+
+        mServerUrl = serverUrl;
+    }
+
+    private String getPublicKeyByResourceDescriptor(int publicKeyResourceDescriptor){
+        String publicKey;
+        try {
+            publicKey = mContext.getString(publicKeyResourceDescriptor);
+        } catch (Resources.NotFoundException e) {
+            throw new CodePushInvalidPublicKeyException(
+                    "Unable to get public key, related resource descriptor " +
+                            publicKeyResourceDescriptor +
+                            " can not be found", e
+            );
+        }
+
+        if (publicKey.isEmpty()) {
+            throw new CodePushInvalidPublicKeyException("Specified public key is empty");
+        }
+        return publicKey;
+    }
+
+    public void clearDebugCacheIfNeeded(ReactInstanceManager instanceManager) {
+        boolean isLiveReloadEnabled = false;
+
+        // Use instanceManager for checking if we use LiveRelaod mode. In this case we should not remove ReactNativeDevBundle.js file
+        // because we get error with trying to get this after reloading. Issue: https://github.com/Microsoft/react-native-code-push/issues/1272
+        if (instanceManager != null) {
+            DevSupportManager devSupportManager = instanceManager.getDevSupportManager();
+            if (devSupportManager != null) {
+                DevInternalSettings devInternalSettings = (DevInternalSettings)devSupportManager.getDevSettings();
+                isLiveReloadEnabled = devInternalSettings.isReloadOnJSChangeEnabled();
+            }
+        }
+
+        if (mIsDebugMode && mSettingsManager.isPendingUpdate(null) && !isLiveReloadEnabled) {
+            // This needs to be kept in sync with https://github.com/facebook/react-native/blob/master/ReactAndroid/src/main/java/com/facebook/react/devsupport/DevSupportManager.java#L78
+            File cachedDevBundle = new File(mContext.getFilesDir(), "ReactNativeDevBundle.js");
+            if (cachedDevBundle.exists()) {
+                cachedDevBundle.delete();
+            }
+        }
+    }
+
+    public boolean didUpdate() {
+        return mDidUpdate;
+    }
+
+    public String getAppVersion() {
+        return sAppVersion;
+    }
+
+    public String getAssetsBundleFileName() {
+        return mAssetsBundleFileName;
+    }
+
+    public String getPublicKey() {
+        return mPublicKey;
+    }
+
+    long getBinaryResourcesModifiedTime() {
+        try {
+            String packageName = this.mContext.getPackageName();
+            int codePushApkBuildTimeId = this.mContext.getResources().getIdentifier(CodePushConstants.CODE_PUSH_APK_BUILD_TIME_KEY, "string", packageName);
+            // replace double quotes needed for correct restoration of long value from strings.xml
+            // https://github.com/Microsoft/cordova-plugin-code-push/issues/264
+            String codePushApkBuildTime = this.mContext.getResources().getString(codePushApkBuildTimeId).replaceAll("\"","");
+            return Long.parseLong(codePushApkBuildTime);
+        } catch (Exception e) {
+            throw new CodePushUnknownException("Error in getting binary resources modified time", e);
+        }
+    }
+
+    public String getPackageFolder() {
+        JSONObject codePushLocalPackage = mUpdateManager.getCurrentPackage();
+        if (codePushLocalPackage == null) {
+            return null;
+        }
+        return mUpdateManager.getPackageFolderPath(codePushLocalPackage.optString("packageHash"));
+    }
+
+    @Deprecated
+    public static String getBundleUrl() {
+        return getJSBundleFile();
+    }
+
+    @Deprecated
+    public static String getBundleUrl(String assetsBundleFileName) {
+        return getJSBundleFile(assetsBundleFileName);
+    }
+
+    public Context getContext() {
+        return mContext;
+    }
+
+    public String getDeploymentKey() {
+        return mDeploymentKey;
+    }
+
+    public static String getJSBundleFile() {
+        return CodePush.getJSBundleFile(CodePushConstants.DEFAULT_JS_BUNDLE_NAME);
+    }
+
+    public static String getJSBundleFile(String assetsBundleFileName) {
+        if (mCurrentInstance == null) {
+            throw new CodePushNotInitializedException("A CodePush instance has not been created yet. Have you added it to your app's list of ReactPackages?");
+        }
+
+        return mCurrentInstance.getJSBundleFileInternal(assetsBundleFileName);
+    }
+
+    public String getJSBundleFileInternal(String assetsBundleFileName) {
+        this.mAssetsBundleFileName = assetsBundleFileName;
+        String binaryJsBundleUrl = CodePushConstants.ASSETS_BUNDLE_PREFIX + assetsBundleFileName;
+
+        String packageFilePath = null;
+        try {
+            packageFilePath = mUpdateManager.getCurrentPackageBundlePath(this.mAssetsBundleFileName);
+        } catch (CodePushMalformedDataException e) {
+            // We need to recover the app in case 'codepush.json' is corrupted
+            CodePushUtils.log(e.getMessage());
+            clearUpdates();
+        }
+
+        if (packageFilePath == null) {
+            // There has not been any downloaded updates.
+            CodePushUtils.logBundleUrl(binaryJsBundleUrl);
+            sIsRunningBinaryVersion = true;
+            return binaryJsBundleUrl;
+        }
+
+        JSONObject packageMetadata = this.mUpdateManager.getCurrentPackage();
+        if (isPackageBundleLatest(packageMetadata)) {
+            CodePushUtils.logBundleUrl(packageFilePath);
+            sIsRunningBinaryVersion = false;
+            return packageFilePath;
+        } else {
+            // The binary version is newer.
+            this.mDidUpdate = false;
+            if (!this.mIsDebugMode || hasBinaryVersionChanged(packageMetadata)) {
+                this.clearUpdates();
+            }
+
+            CodePushUtils.logBundleUrl(binaryJsBundleUrl);
+            sIsRunningBinaryVersion = true;
+            return binaryJsBundleUrl;
+        }
+    }
+
+    public String getServerUrl() {
+        return mServerUrl;
+    }
+
+    void initializeUpdateAfterRestart() {
+        // Reset the state which indicates that
+        // the app was just freshly updated.
+        mDidUpdate = false;
+
+        JSONObject pendingUpdate = mSettingsManager.getPendingUpdate();
+        if (pendingUpdate != null) {
+            JSONObject packageMetadata = this.mUpdateManager.getCurrentPackage();
+            if (packageMetadata == null || !isPackageBundleLatest(packageMetadata) && hasBinaryVersionChanged(packageMetadata)) {
+                CodePushUtils.log("Skipping initializeUpdateAfterRestart(), binary version is newer");
+                return;
+            }
+
+            try {
+                boolean updateIsLoading = pendingUpdate.getBoolean(CodePushConstants.PENDING_UPDATE_IS_LOADING_KEY);
+                if (updateIsLoading) {
+                    // Pending update was initialized, but notifyApplicationReady was not called.
+                    // Therefore, deduce that it is a broken update and rollback.
+                    CodePushUtils.log("Update did not finish loading the last time, rolling back to a previous version.");
+                    sNeedToReportRollback = true;
+                    rollbackPackage();
+                } else {
+                    // There is in fact a new update running for the first
+                    // time, so update the local state to ensure the client knows.
+                    mDidUpdate = true;
+
+                    // Mark that we tried to initialize the new update, so that if it crashes,
+                    // we will know that we need to rollback when the app next starts.
+                    mSettingsManager.savePendingUpdate(pendingUpdate.getString(CodePushConstants.PENDING_UPDATE_HASH_KEY),
+                            /* isLoading */true);
+                }
+            } catch (JSONException e) {
+                // Should not happen.
+                throw new CodePushUnknownException("Unable to read pending update metadata stored in SharedPreferences", e);
+            }
+        }
+    }
+
+    void invalidateCurrentInstance() {
+        mCurrentInstance = null;
+    }
+
+    boolean isDebugMode() {
+        return mIsDebugMode;
+    }
+
+    boolean isRunningBinaryVersion() {
+        return sIsRunningBinaryVersion;
+    }
+
+    private boolean isPackageBundleLatest(JSONObject packageMetadata) {
+        try {
+            Long binaryModifiedDateDuringPackageInstall = null;
+            String binaryModifiedDateDuringPackageInstallString = packageMetadata.optString(CodePushConstants.BINARY_MODIFIED_TIME_KEY, null);
+            if (binaryModifiedDateDuringPackageInstallString != null) {
+                binaryModifiedDateDuringPackageInstall = Long.parseLong(binaryModifiedDateDuringPackageInstallString);
+            }
+            String packageAppVersion = packageMetadata.optString("appVersion", null);
+            long binaryResourcesModifiedTime = this.getBinaryResourcesModifiedTime();
+            return binaryModifiedDateDuringPackageInstall != null &&
+                    binaryModifiedDateDuringPackageInstall == binaryResourcesModifiedTime &&
+                    (isUsingTestConfiguration() || sAppVersion.equals(packageAppVersion));
+        } catch (NumberFormatException e) {
+            throw new CodePushUnknownException("Error in reading binary modified date from package metadata", e);
+        }
+    }
+
+    private boolean hasBinaryVersionChanged(JSONObject packageMetadata) {
+        String packageAppVersion = packageMetadata.optString("appVersion", null);
+        return !sAppVersion.equals(packageAppVersion);
+    }
+
+    boolean needToReportRollback() {
+        return sNeedToReportRollback;
+    }
+
+    public static void overrideAppVersion(String appVersionOverride) {
+        sAppVersion = appVersionOverride;
+    }
+
+    private void rollbackPackage() {
+        JSONObject failedPackage = mUpdateManager.getCurrentPackage();
+        mSettingsManager.saveFailedUpdate(failedPackage);
+        mUpdateManager.rollbackPackage();
+        mSettingsManager.removePendingUpdate();
+    }
+
+    public void setNeedToReportRollback(boolean needToReportRollback) {
+        CodePush.sNeedToReportRollback = needToReportRollback;
+    }
+
+    /* The below 3 methods are used for running tests.*/
+    public static boolean isUsingTestConfiguration() {
+        return sTestConfigurationFlag;
+    }
+
+    public void setDeploymentKey(String deploymentKey) {
+        mDeploymentKey = deploymentKey;
+    }
+
+    public static void setUsingTestConfiguration(boolean shouldUseTestConfiguration) {
+        sTestConfigurationFlag = shouldUseTestConfiguration;
+    }
+
+    public void clearUpdates() {
+        mUpdateManager.clearUpdates();
+        mSettingsManager.removePendingUpdate();
+        mSettingsManager.removeFailedUpdates();
+    }
+
+    public static void setReactInstanceHolder(ReactInstanceHolder reactInstanceHolder) {
+        mReactInstanceHolder = reactInstanceHolder;
+    }
+
+    static ReactInstanceManager getReactInstanceManager() {
+        if (mReactInstanceHolder == null) {
+            return null;
+        }
+        return mReactInstanceHolder.getReactInstanceManager();
+    }
+
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactApplicationContext) {
+        CodePushNativeModule codePushModule = new CodePushNativeModule(reactApplicationContext, this, mUpdateManager, mTelemetryManager, mSettingsManager);
+        CodePushDialog dialogModule = new CodePushDialog(reactApplicationContext);
+
+        List<NativeModule> nativeModules = new ArrayList<>();
+        nativeModules.add(codePushModule);
+        nativeModules.add(dialogModule);
+        return nativeModules;
+    }
+
+    // Deprecated in RN v0.47.
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactApplicationContext) {
+        return new ArrayList<>();
+    }
+}

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

@@ -0,0 +1,37 @@
+package com.microsoft.codepush.react;
+
+import android.content.Context;
+
+public class CodePushBuilder {
+    private String mDeploymentKey;
+    private Context mContext;
+
+    private boolean mIsDebugMode;
+    private String mServerUrl;
+    private Integer mPublicKeyResourceDescriptor;
+
+    public CodePushBuilder(String deploymentKey, Context context) {
+        this.mDeploymentKey = deploymentKey;
+        this.mContext = context;
+        this.mServerUrl = CodePush.getServiceUrl();
+    }
+
+    public CodePushBuilder setIsDebugMode(boolean isDebugMode) {
+        this.mIsDebugMode = isDebugMode;
+        return this;
+    }
+
+    public CodePushBuilder setServerUrl(String serverUrl) {
+        this.mServerUrl = serverUrl;
+        return this;
+    }
+
+    public CodePushBuilder setPublicKeyResourceDescriptor(int publicKeyResourceDescriptor) {
+        this.mPublicKeyResourceDescriptor = publicKeyResourceDescriptor;
+        return this;
+    }
+
+    public CodePush build() {
+        return new CodePush(this.mDeploymentKey, this.mContext, this.mIsDebugMode, this.mServerUrl, this.mPublicKeyResourceDescriptor);
+    }
+}

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

@@ -0,0 +1,34 @@
+package com.microsoft.codepush.react;
+
+public class CodePushConstants {
+    public static final String ASSETS_BUNDLE_PREFIX = "assets://";
+    public static final String BINARY_MODIFIED_TIME_KEY = "binaryModifiedTime";
+    public static final String CODE_PUSH_FOLDER_PREFIX = "CodePush";
+    public static final String CODE_PUSH_HASH_FILE_NAME = "CodePushHash";
+    public static final String CODE_PUSH_OLD_HASH_FILE_NAME = "CodePushHash.json";
+    public static final String CODE_PUSH_PREFERENCES = "CodePush";
+    public static final String CURRENT_PACKAGE_KEY = "currentPackage";
+    public static final String DEFAULT_JS_BUNDLE_NAME = "index.android.bundle";
+    public static final String DIFF_MANIFEST_FILE_NAME = "hotcodepush.json";
+    public static final int DOWNLOAD_BUFFER_SIZE = 1024 * 256;
+    public static final String DOWNLOAD_FILE_NAME = "download.zip";
+    public static final String DOWNLOAD_PROGRESS_EVENT_NAME = "CodePushDownloadProgress";
+    public static final String DOWNLOAD_URL_KEY = "downloadUrl";
+    public static final String FAILED_UPDATES_KEY = "CODE_PUSH_FAILED_UPDATES";
+    public static final String PACKAGE_FILE_NAME = "app.json";
+    public static final String PACKAGE_HASH_KEY = "packageHash";
+    public static final String PENDING_UPDATE_HASH_KEY = "hash";
+    public static final String PENDING_UPDATE_IS_LOADING_KEY = "isLoading";
+    public static final String PENDING_UPDATE_KEY = "CODE_PUSH_PENDING_UPDATE";
+    public static final String PREVIOUS_PACKAGE_KEY = "previousPackage";
+    public static final String REACT_NATIVE_LOG_TAG = "ReactNative";
+    public static final String RELATIVE_BUNDLE_PATH_KEY = "bundlePath";
+    public static final String STATUS_FILE = "codepush.json";
+    public static final String UNZIPPED_FOLDER_NAME = "unzipped";
+    public static final String CODE_PUSH_APK_BUILD_TIME_KEY = "CODE_PUSH_APK_BUILD_TIME";
+    public static final String BUNDLE_JWT_FILE = ".codepushrelease";
+    public static final String LATEST_ROLLBACK_INFO_KEY = "LATEST_ROLLBACK_INFO";
+    public static final String LATEST_ROLLBACK_PACKAGE_HASH_KEY = "packageHash";
+    public static final String LATEST_ROLLBACK_TIME_KEY = "time";
+    public static final String LATEST_ROLLBACK_COUNT_KEY = "count";
+}

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

@@ -0,0 +1,102 @@
+package com.microsoft.codepush.react;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+
+public class CodePushDialog extends ReactContextBaseJavaModule{
+
+    public CodePushDialog(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @ReactMethod
+    public void showDialog(final String title, final String message, final String button1Text,
+                           final String button2Text, final Callback successCallback, Callback errorCallback) {
+        Activity currentActivity = getCurrentActivity();
+        if (currentActivity == null || currentActivity.isFinishing()) {
+            // If getCurrentActivity is null, it could be because the app is backgrounded,
+            // so we show the dialog when the app resumes)
+            getReactApplicationContext().addLifecycleEventListener(new LifecycleEventListener() {
+                @Override
+                public void onHostResume() {
+                    Activity currentActivity = getCurrentActivity();
+                    if (currentActivity != null) {
+                        getReactApplicationContext().removeLifecycleEventListener(this);
+                        showDialogInternal(title, message, button1Text, button2Text, successCallback, currentActivity);
+                    }
+                }
+
+                @Override
+                public void onHostPause() {
+
+                }
+
+                @Override
+                public void onHostDestroy() {
+
+                }
+            });
+        } else {
+            showDialogInternal(title, message, button1Text, button2Text, successCallback, currentActivity);
+        }
+    }
+
+    private void showDialogInternal(String title, String message, String button1Text,
+                                    String button2Text, final Callback successCallback, Activity currentActivity) {
+        AlertDialog.Builder builder = new AlertDialog.Builder(currentActivity);
+
+        builder.setCancelable(false);
+
+        DialogInterface.OnClickListener clickListener = new DialogInterface.OnClickListener() {
+            @Override
+            public void onClick(DialogInterface dialog, int which) {
+                try {
+                    dialog.cancel();
+                    switch (which) {
+                        case DialogInterface.BUTTON_POSITIVE:
+                            successCallback.invoke(0);
+                            break;
+                        case DialogInterface.BUTTON_NEGATIVE:
+                            successCallback.invoke(1);
+                            break;
+                        default:
+                            throw new CodePushUnknownException("Unknown button ID pressed.");
+                    }
+                } catch (Throwable e) {
+                    CodePushUtils.log(e);
+                }
+            }
+        };
+
+        if (title != null) {
+            builder.setTitle(title);
+        }
+
+        if (message != null) {
+            builder.setMessage(message);
+        }
+
+        if (button1Text != null) {
+            builder.setPositiveButton(button1Text, clickListener);
+        }
+
+        if (button2Text != null) {
+            builder.setNegativeButton(button2Text, clickListener);
+        }
+
+        AlertDialog dialog = builder.create();
+        dialog.show();
+    }
+
+    @Override
+    public String getName() {
+        return "CodePushDialog";
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.microsoft.codepush.react;
+
+public enum CodePushInstallMode {
+    IMMEDIATE(0),
+    ON_NEXT_RESTART(1),
+    ON_NEXT_RESUME(2),
+    ON_NEXT_SUSPEND(3);
+
+    private final int value;
+    CodePushInstallMode(int value) {
+        this.value = value;
+    }
+    public int getValue() {
+        return this.value;
+    }
+}

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

@@ -0,0 +1,12 @@
+package com.microsoft.codepush.react;
+
+class CodePushInvalidPublicKeyException extends RuntimeException {
+
+    public CodePushInvalidPublicKeyException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public CodePushInvalidPublicKeyException(String message) {
+        super(message);
+    }
+}

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

@@ -0,0 +1,7 @@
+package com.microsoft.codepush.react;
+
+public class CodePushInvalidUpdateException extends RuntimeException {
+    public CodePushInvalidUpdateException(String message) {
+        super(message);
+    }
+}

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

@@ -0,0 +1,12 @@
+package com.microsoft.codepush.react;
+
+import java.net.MalformedURLException;
+
+public class CodePushMalformedDataException extends RuntimeException {
+    public CodePushMalformedDataException(String path, Throwable cause) {
+        super("Unable to parse contents of " + path + ", the file may be corrupted.", cause);
+    }
+    public CodePushMalformedDataException(String url, MalformedURLException cause) {
+        super("The package has an invalid downloadUrl: " + url, cause);
+    }
+}