@srcpush/react-native-code-push 1.0.3-develop.5 → 1.0.3-feat-new-arch.1

package/android/app/src/main/java/com/microsoft/codepush/react/{CodePushNativeModule.java → CodePushNativeModuleImpl.java}

@@ -5,6 +5,7 @@ import android.content.SharedPreferences;
 import android.os.AsyncTask;
 import android.os.Handler;
 import android.os.Looper;
+import android.view.Choreographer;
 import android.view.View;
 
 import androidx.annotation.OptIn;
@@ -14,12 +15,10 @@ import com.facebook.react.ReactHost;
 import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.ReactRootView;
 import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.BaseJavaModule;
 import com.facebook.react.bridge.JSBundleLoader;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.annotations.UnstableReactNativeAPI;
@@ -29,7 +28,6 @@ import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.modules.debug.interfaces.DeveloperSettings;
 import com.facebook.react.runtime.ReactHostDelegate;
 import com.facebook.react.runtime.ReactHostImpl;
-import android.view.Choreographer;
 
 import org.json.JSONArray;
 import org.json.JSONException;
@@ -46,30 +44,35 @@ import java.util.Map;
 import java.util.UUID;
 
 @OptIn(markerClass = UnstableReactNativeAPI.class)
-public class CodePushNativeModule extends BaseJavaModule {
+final class CodePushNativeModuleImpl {
     private String mBinaryContentsHash = null;
     private String mClientUniqueId = null;
     private LifecycleEventListener mLifecycleEventListener = null;
     private int mMinimumBackgroundDuration = 0;
 
-    private CodePush mCodePush;
-    private SettingsManager mSettingsManager;
-    private CodePushTelemetryManager mTelemetryManager;
-    private CodePushUpdateManager mUpdateManager;
-
-    private  boolean _allowed = true;
-    private  boolean _restartInProgress = false;
-    private  ArrayList<Boolean> _restartQueue = new ArrayList<>();
-
-    public CodePushNativeModule(ReactApplicationContext reactContext, CodePush codePush, CodePushUpdateManager codePushUpdateManager, CodePushTelemetryManager codePushTelemetryManager, SettingsManager settingsManager) {
-        super(reactContext);
-
+    private final ReactApplicationContext reactContext;
+    private final CodePush mCodePush;
+    private final SettingsManager mSettingsManager;
+    private final CodePushTelemetryManager mTelemetryManager;
+    private final CodePushUpdateManager mUpdateManager;
+
+    private boolean _allowed = true;
+    private boolean _restartInProgress = false;
+    private final ArrayList<Boolean> _restartQueue = new ArrayList<>();
+
+    CodePushNativeModuleImpl(
+            ReactApplicationContext reactContext,
+            CodePush codePush,
+            CodePushUpdateManager codePushUpdateManager,
+            CodePushTelemetryManager codePushTelemetryManager,
+            SettingsManager settingsManager
+    ) {
+        this.reactContext = reactContext;
         mCodePush = codePush;
         mSettingsManager = settingsManager;
         mTelemetryManager = codePushTelemetryManager;
         mUpdateManager = codePushUpdateManager;
 
-        // Initialize module state while we have a reference to the current context.
         mBinaryContentsHash = CodePushUpdateUtils.getHashForBinaryContents(reactContext, mCodePush.isDebugMode());
 
         SharedPreferences preferences = codePush.getContext().getSharedPreferences(CodePushConstants.CODE_PUSH_PREFERENCES, 0);
@@ -80,8 +83,7 @@ public class CodePushNativeModule extends BaseJavaModule {
         }
     }
 
-    @Override
-    public Map<String, Object> getConstants() {
+    Map<String, Object> getConstants() {
         final Map<String, Object> constants = new HashMap<>();
 
         constants.put("codePushInstallModeImmediate", CodePushInstallMode.IMMEDIATE.getValue());
@@ -96,16 +98,9 @@ public class CodePushNativeModule extends BaseJavaModule {
         return constants;
     }
 
-    @Override
-    public String getName() {
-        return "CodePush";
-    }
-
     private void loadBundleLegacy() {
-        final Activity currentActivity = getReactApplicationContext().getCurrentActivity();
+        final Activity currentActivity = reactContext.getCurrentActivity();
         if (currentActivity == null) {
-            // The currentActivity can be null if it is backgrounded / destroyed, so we simply
-            // no-op to prevent any null pointer exceptions.
             return;
         }
         mCodePush.invalidateCurrentInstance();
@@ -118,13 +113,11 @@ public class CodePushNativeModule extends BaseJavaModule {
         });
     }
 
-    // Use reflection to find and set the appropriate fields on ReactInstanceManager. See #556 for a proposal for a less brittle way
-    // to approach this.
     private void setJSBundle(ReactInstanceManager instanceManager, String latestJSBundleFile) throws IllegalAccessException {
         try {
             JSBundleLoader latestJSBundleLoader;
             if (latestJSBundleFile.toLowerCase().startsWith("assets://")) {
-                latestJSBundleLoader = JSBundleLoader.createAssetLoader(getReactApplicationContext(), latestJSBundleFile, false);
+                latestJSBundleLoader = JSBundleLoader.createAssetLoader(reactContext, latestJSBundleFile, false);
             } else {
                 latestJSBundleLoader = JSBundleLoader.createFileLoader(latestJSBundleFile);
             }
@@ -138,13 +131,11 @@ public class CodePushNativeModule extends BaseJavaModule {
         }
     }
 
-    // Use reflection to find and set the appropriate fields on ReactHostDelegate. See #556 for a proposal for a less brittle way
-    // to approach this.
     private void setJSBundle(ReactHostDelegate reactHostDelegate, String latestJSBundleFile) throws IllegalAccessException {
         try {
             JSBundleLoader latestJSBundleLoader;
             if (latestJSBundleFile.toLowerCase().startsWith("assets://")) {
-                latestJSBundleLoader = JSBundleLoader.createAssetLoader(getReactApplicationContext(), latestJSBundleFile, false);
+                latestJSBundleLoader = JSBundleLoader.createAssetLoader(reactContext, latestJSBundleFile, false);
             } else {
                 latestJSBundleLoader = JSBundleLoader.createFileLoader(latestJSBundleFile);
             }
@@ -161,54 +152,42 @@ public class CodePushNativeModule extends BaseJavaModule {
     private void loadBundle() {
         clearLifecycleEventListener();
 
-        // ReactNative core components are changed on new architecture.
         if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
             try {
                 DevSupportManager devSupportManager = null;
-                    ReactHost reactHost = resolveReactHost();
-                    if (reactHost != null) {
-                        devSupportManager = reactHost.getDevSupportManager();
-                    }
+                ReactHost reactHost = resolveReactHost();
+                if (reactHost != null) {
+                    devSupportManager = reactHost.getDevSupportManager();
+                }
                 boolean isLiveReloadEnabled = isLiveReloadEnabled(devSupportManager);
-
                 mCodePush.clearDebugCacheIfNeeded(isLiveReloadEnabled);
-            } catch(Exception e) {
-                // If we got error in out reflection we should clear debug cache anyway.
+            } catch (Exception e) {
                 mCodePush.clearDebugCacheIfNeeded(false);
             }
 
             try {
-                // #1) Get the ReactHost instance, which is what includes the
-                //     logic to reload the current React context.
                 final ReactHost reactHost = resolveReactHost();
                 if (reactHost == null) {
                     return;
                 }
 
                 String latestJSBundleFile = mCodePush.getJSBundleFileInternal(mCodePush.getAssetsBundleFileName());
+                ReactHostDelegate delegate = getReactHostDelegate((ReactHostImpl) reactHost);
+                if (delegate != null) {
+                    setJSBundle(delegate, latestJSBundleFile);
+                }
 
-                // #2) Update the locally stored JS bundle file path
-                setJSBundle(getReactHostDelegate((ReactHostImpl) reactHost), latestJSBundleFile);
-
-                // #3) Get the context creation method
                 try {
                     reactHost.reload("CodePush triggers reload");
                     mCodePush.initializeUpdateAfterRestart();
                 } catch (Exception e) {
-                    // The recreation method threw an unknown exception
-                    // so just simply fallback to restarting the Activity (if it exists)
                     loadBundleLegacy();
                 }
-
             } catch (Exception e) {
-                // Our reflection logic failed somewhere
-                // so fall back to restarting the Activity (if it exists)
                 CodePushUtils.log("Failed to load the bundle, falling back to restarting the Activity (if it exists). " + e.getMessage());
                 loadBundleLegacy();
             }
-
         } else {
-
             try {
                 DevSupportManager devSupportManager = null;
                 ReactInstanceManager reactInstanceManager = resolveInstanceManager();
@@ -216,53 +195,35 @@ public class CodePushNativeModule extends BaseJavaModule {
                     devSupportManager = reactInstanceManager.getDevSupportManager();
                 }
                 boolean isLiveReloadEnabled = isLiveReloadEnabled(devSupportManager);
-
                 mCodePush.clearDebugCacheIfNeeded(isLiveReloadEnabled);
-            } catch(Exception e) {
-                // If we got error in out reflection we should clear debug cache anyway.
+            } catch (Exception e) {
                 mCodePush.clearDebugCacheIfNeeded(false);
             }
 
             try {
-                // #1) Get the ReactInstanceManager instance, which is what includes the
-                //     logic to reload the current React context.
                 final ReactInstanceManager instanceManager = resolveInstanceManager();
                 if (instanceManager == null) {
                     return;
                 }
 
                 String latestJSBundleFile = mCodePush.getJSBundleFileInternal(mCodePush.getAssetsBundleFileName());
-
-                // #2) Update the locally stored JS bundle file path
                 setJSBundle(instanceManager, latestJSBundleFile);
 
-                // #3) Get the context creation method and fire it on the UI thread (which RN enforces)
                 new Handler(Looper.getMainLooper()).post(new Runnable() {
                     @Override
                     public void run() {
                         try {
-                            // We don't need to resetReactRootViews anymore
-                            // due the issue https://github.com/facebook/react-native/issues/14533
-                            // has been fixed in RN 0.46.0
-                            //resetReactRootViews(instanceManager);
-
                             instanceManager.recreateReactContextInBackground();
                             mCodePush.initializeUpdateAfterRestart();
                         } catch (Exception e) {
-                            // The recreation method threw an unknown exception
-                            // so just simply fallback to restarting the Activity (if it exists)
                             loadBundleLegacy();
                         }
                     }
                 });
-
             } catch (Exception e) {
-                // Our reflection logic failed somewhere
-                // so fall back to restarting the Activity (if it exists)
                 CodePushUtils.log("Failed to load the bundle, falling back to restarting the Activity (if it exists). " + e.getMessage());
                 loadBundleLegacy();
             }
-
         }
     }
 
@@ -284,13 +245,11 @@ public class CodePushNativeModule extends BaseJavaModule {
         return false;
     }
 
-    // This workaround has been implemented in order to fix https://github.com/facebook/react-native/issues/14533
-    // resetReactRootViews allows to call recreateReactContextInBackground without any exceptions
-    // This fix also relates to https://github.com/microsoft/react-native-code-push/issues/878
+    @SuppressWarnings("unused")
     private void resetReactRootViews(ReactInstanceManager instanceManager) throws NoSuchFieldException, IllegalAccessException {
         Field mAttachedRootViewsField = instanceManager.getClass().getDeclaredField("mAttachedRootViews");
         mAttachedRootViewsField.setAccessible(true);
-        List<ReactRootView> mAttachedRootViews = (List<ReactRootView>)mAttachedRootViewsField.get(instanceManager);
+        List<ReactRootView> mAttachedRootViews = (List<ReactRootView>) mAttachedRootViewsField.get(instanceManager);
         for (ReactRootView reactRootView : mAttachedRootViews) {
             reactRootView.removeAllViews();
             reactRootView.setId(View.NO_ID);
@@ -299,29 +258,25 @@ public class CodePushNativeModule extends BaseJavaModule {
     }
 
     private void clearLifecycleEventListener() {
-        // Remove LifecycleEventListener to prevent infinite restart loop
         if (mLifecycleEventListener != null) {
-            getReactApplicationContext().removeLifecycleEventListener(mLifecycleEventListener);
+            reactContext.removeLifecycleEventListener(mLifecycleEventListener);
             mLifecycleEventListener = null;
         }
     }
 
-    // Use reflection to find the ReactInstanceManager. See #556 for a proposal for a less brittle way to approach this.
     private ReactInstanceManager resolveInstanceManager() throws NoSuchFieldException, IllegalAccessException {
         ReactInstanceManager instanceManager = CodePush.getReactInstanceManager();
         if (instanceManager != null) {
             return instanceManager;
         }
 
-        final Activity currentActivity = getReactApplicationContext().getCurrentActivity();
+        final Activity currentActivity = reactContext.getCurrentActivity();
         if (currentActivity == null) {
             return null;
         }
 
         ReactApplication reactApplication = (ReactApplication) currentActivity.getApplication();
-        instanceManager = reactApplication.getReactNativeHost().getReactInstanceManager();
-
-        return instanceManager;
+        return reactApplication.getReactNativeHost().getReactInstanceManager();
     }
 
     private ReactHost resolveReactHost() throws NoSuchFieldException, IllegalAccessException {
@@ -330,7 +285,7 @@ public class CodePushNativeModule extends BaseJavaModule {
             return reactHost;
         }
 
-        final Activity currentActivity = getReactApplicationContext().getCurrentActivity();
+        final Activity currentActivity = reactContext.getCurrentActivity();
         if (currentActivity == null) {
             return null;
         }
@@ -365,8 +320,7 @@ public class CodePushNativeModule extends BaseJavaModule {
         }
     }
 
-    @ReactMethod
-    public void allow(Promise promise) {
+    void allow(Promise promise) {
         CodePushUtils.log("Re-allowing restarts");
         this._allowed = true;
 
@@ -378,37 +332,30 @@ public class CodePushNativeModule extends BaseJavaModule {
         }
 
         promise.resolve(null);
-        return;
     }
 
-    @ReactMethod
-    public void clearPendingRestart(Promise promise) {
+    void clearPendingRestart(Promise promise) {
         this._restartQueue.clear();
         promise.resolve(null);
-        return;
     }
 
-    @ReactMethod
-    public void disallow(Promise promise) {
+    void disallow(Promise promise) {
         CodePushUtils.log("Disallowing restarts");
         this._allowed = false;
         promise.resolve(null);
-        return;
     }
 
-    @ReactMethod
-    public void restartApp(boolean onlyIfUpdateIsPending, Promise promise) {
+    void restartApp(boolean onlyIfUpdateIsPending, Promise promise) {
         try {
             restartAppInternal(onlyIfUpdateIsPending);
             promise.resolve(null);
-        } catch(CodePushUnknownException e) {
+        } catch (CodePushUnknownException e) {
             CodePushUtils.log(e);
             promise.reject(e);
         }
     }
 
-    @ReactMethod
-    public void downloadUpdate(final ReadableMap updatePackage, final boolean notifyProgress, final Promise promise) {
+    void downloadUpdate(final ReadableMap updatePackage, final boolean notifyProgress, final Promise promise) {
         AsyncTask<Void, Void, Void> asyncTask = new AsyncTask<Void, Void, Void>() {
             @Override
             protected Void doInBackground(Void... params) {
@@ -426,7 +373,6 @@ public class CodePushNativeModule extends BaseJavaModule {
                             }
 
                             latestDownloadProgress = downloadProgress;
-                            // If the download is completed, synchronously send the last event.
                             if (latestDownloadProgress.isCompleted()) {
                                 dispatchDownloadProgressEvent();
                                 return;
@@ -437,7 +383,7 @@ public class CodePushNativeModule extends BaseJavaModule {
                             }
 
                             hasScheduledNextFrame = true;
-                            getReactApplicationContext().runOnUiQueueThread(new Runnable() {
+                            reactContext.runOnUiQueueThread(new Runnable() {
                                 @Override
                                 public void run() {
                                     ReactChoreographer.getInstance().postFrameCallback(ReactChoreographer.CallbackType.TIMERS_EVENTS, new Choreographer.FrameCallback() {
@@ -455,7 +401,7 @@ public class CodePushNativeModule extends BaseJavaModule {
                         }
 
                         public void dispatchDownloadProgressEvent() {
-                            getReactApplicationContext()
+                            reactContext
                                     .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                                     .emit(CodePushConstants.DOWNLOAD_PROGRESS_EVENT_NAME, latestDownloadProgress.createWritableMap());
                         }
@@ -479,29 +425,26 @@ public class CodePushNativeModule extends BaseJavaModule {
         asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
     }
 
-    @ReactMethod
-    public void getConfiguration(Promise promise) {
+    void getConfiguration(Promise promise) {
         try {
-            WritableMap configMap =  Arguments.createMap();
+            WritableMap configMap = Arguments.createMap();
             configMap.putString("appVersion", mCodePush.getAppVersion());
             configMap.putString("clientUniqueId", mClientUniqueId);
             configMap.putString("deploymentKey", mCodePush.getDeploymentKey());
             configMap.putString("serverUrl", mCodePush.getServerUrl());
 
-            // The binary hash may be null in debug builds
             if (mBinaryContentsHash != null) {
                 configMap.putString(CodePushConstants.PACKAGE_HASH_KEY, mBinaryContentsHash);
             }
 
             promise.resolve(configMap);
-        } catch(CodePushUnknownException e) {
+        } catch (CodePushUnknownException e) {
             CodePushUtils.log(e);
             promise.reject(e);
         }
     }
 
-    @ReactMethod
-    public void getUpdateMetadata(final int updateState, final Promise promise) {
+    void getUpdateMetadata(final double updateState, final Promise promise) {
         AsyncTask<Void, Void, Void> asyncTask = new AsyncTask<Void, Void, Void>() {
             @Override
             protected Void doInBackground(Void... params) {
@@ -520,43 +463,29 @@ public class CodePushNativeModule extends BaseJavaModule {
                         currentUpdateIsPending = mSettingsManager.isPendingUpdate(currentHash);
                     }
 
-                    if (updateState == CodePushUpdateState.PENDING.getValue() && !currentUpdateIsPending) {
-                        // The caller wanted a pending update
-                        // but there isn't currently one.
+                    int updateStateValue = (int) updateState;
+                    if (updateStateValue == CodePushUpdateState.PENDING.getValue() && !currentUpdateIsPending) {
                         promise.resolve(null);
-                    } else if (updateState == CodePushUpdateState.RUNNING.getValue() && currentUpdateIsPending) {
-                        // The caller wants the running update, but the current
-                        // one is pending, so we need to grab the previous.
+                    } else if (updateStateValue == CodePushUpdateState.RUNNING.getValue() && currentUpdateIsPending) {
                         JSONObject previousPackage = mUpdateManager.getPreviousPackage();
-
                         if (previousPackage == null) {
                             promise.resolve(null);
                             return null;
                         }
-
                         promise.resolve(CodePushUtils.convertJsonObjectToWritable(previousPackage));
                     } else {
-                        // The current package satisfies the request:
-                        // 1) Caller wanted a pending, and there is a pending update
-                        // 2) Caller wanted the running update, and there isn't a pending
-                        // 3) Caller wants the latest update, regardless if it's pending or not
                         if (mCodePush.isRunningBinaryVersion()) {
-                            // This only matters in Debug builds. Since we do not clear "outdated" updates,
-                            // we need to indicate to the JS side that somehow we have a current update on
-                            // disk that is not actually running.
                             CodePushUtils.setJSONValueForKey(currentPackage, "_isDebugOnly", true);
                         }
 
-                        // Enable differentiating pending vs. non-pending updates
                         CodePushUtils.setJSONValueForKey(currentPackage, "isPending", currentUpdateIsPending);
                         promise.resolve(CodePushUtils.convertJsonObjectToWritable(currentPackage));
                     }
                 } catch (CodePushMalformedDataException e) {
-                    // We need to recover the app in case 'codepush.json' is corrupted
                     CodePushUtils.log(e.getMessage());
                     clearUpdates();
                     promise.resolve(null);
-                } catch(CodePushUnknownException e) {
+                } catch (CodePushUnknownException e) {
                     CodePushUtils.log(e);
                     promise.reject(e);
                 }
@@ -568,8 +497,7 @@ public class CodePushNativeModule extends BaseJavaModule {
         asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
     }
 
-    @ReactMethod
-    public void getNewStatusReport(final Promise promise) {
+    void getNewStatusReport(final Promise promise) {
         AsyncTask<Void, Void, Void> asyncTask = new AsyncTask<Void, Void, Void>() {
             @Override
             protected Void doInBackground(Void... params) {
@@ -613,8 +541,8 @@ public class CodePushNativeModule extends BaseJavaModule {
                         }
                     }
 
-                    promise.resolve("");
-                } catch(CodePushUnknownException e) {
+                    promise.resolve(null);
+                } catch (CodePushUnknownException e) {
                     CodePushUtils.log(e);
                     promise.reject(e);
                 }
@@ -625,8 +553,7 @@ public class CodePushNativeModule extends BaseJavaModule {
         asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
     }
 
-    @ReactMethod
-    public void installUpdate(final ReadableMap updatePackage, final int installMode, final int minimumBackgroundDuration, final Promise promise) {
+    void installUpdate(final ReadableMap updatePackage, final double installMode, final double minimumBackgroundDuration, final Promise promise) {
         AsyncTask<Void, Void, Void> asyncTask = new AsyncTask<Void, Void, Void>() {
             @Override
             protected Void doInBackground(Void... params) {
@@ -637,23 +564,17 @@ public class CodePushNativeModule extends BaseJavaModule {
                     if (pendingHash == null) {
                         throw new CodePushUnknownException("Update package to be installed has no hash.");
                     } else {
-                        mSettingsManager.savePendingUpdate(pendingHash, /* isLoading */false);
+                        mSettingsManager.savePendingUpdate(pendingHash, /* isLoading */ false);
                     }
 
-                    if (installMode == CodePushInstallMode.ON_NEXT_RESUME.getValue() ||
-                        // We also add the resume listener if the installMode is IMMEDIATE, because
-                        // if the current activity is backgrounded, we want to reload the bundle when
-                        // it comes back into the foreground.
-                        installMode == CodePushInstallMode.IMMEDIATE.getValue() ||
-                        installMode == CodePushInstallMode.ON_NEXT_SUSPEND.getValue()) {
+                    int installModeValue = (int) installMode;
+                    if (installModeValue == CodePushInstallMode.ON_NEXT_RESUME.getValue()
+                            || installModeValue == CodePushInstallMode.IMMEDIATE.getValue()
+                            || installModeValue == CodePushInstallMode.ON_NEXT_SUSPEND.getValue()) {
 
-                        // Store the minimum duration on the native module as an instance
-                        // variable instead of relying on a closure below, so that any
-                        // subsequent resume-based installs could override it.
-                        CodePushNativeModule.this.mMinimumBackgroundDuration = minimumBackgroundDuration;
+                        CodePushNativeModuleImpl.this.mMinimumBackgroundDuration = (int) minimumBackgroundDuration;
 
                         if (mLifecycleEventListener == null) {
-                            // Ensure we do not add the listener twice.
                             mLifecycleEventListener = new LifecycleEventListener() {
                                 private Date lastPausedDate = null;
                                 private Handler appSuspendHandler = new Handler(Looper.getMainLooper());
@@ -668,12 +589,10 @@ public class CodePushNativeModule extends BaseJavaModule {
                                 @Override
                                 public void onHostResume() {
                                     appSuspendHandler.removeCallbacks(loadBundleRunnable);
-                                    // As of RN 36, the resume handler fires immediately if the app is in
-                                    // the foreground, so explicitly wait for it to be backgrounded first
                                     if (lastPausedDate != null) {
                                         long durationInBackground = (new Date().getTime() - lastPausedDate.getTime()) / 1000;
-                                        if (installMode == CodePushInstallMode.IMMEDIATE.getValue()
-                                                || durationInBackground >= CodePushNativeModule.this.mMinimumBackgroundDuration) {
+                                        if (installModeValue == CodePushInstallMode.IMMEDIATE.getValue()
+                                                || durationInBackground >= CodePushNativeModuleImpl.this.mMinimumBackgroundDuration) {
                                             CodePushUtils.log("Loading bundle on resume");
                                             restartAppInternal(false);
                                         }
@@ -682,12 +601,10 @@ public class CodePushNativeModule extends BaseJavaModule {
 
                                 @Override
                                 public void onHostPause() {
-                                    // Save the current time so that when the app is later
-                                    // resumed, we can detect how long it was in the background.
                                     lastPausedDate = new Date();
 
-                                    if (installMode == CodePushInstallMode.ON_NEXT_SUSPEND.getValue() && mSettingsManager.isPendingUpdate(null)) {
-                                        appSuspendHandler.postDelayed(loadBundleRunnable, minimumBackgroundDuration * 1000);
+                                    if (installModeValue == CodePushInstallMode.ON_NEXT_SUSPEND.getValue() && mSettingsManager.isPendingUpdate(null)) {
+                                        appSuspendHandler.postDelayed(loadBundleRunnable, CodePushNativeModuleImpl.this.mMinimumBackgroundDuration * 1000L);
                                     }
                                 }
 
@@ -696,12 +613,12 @@ public class CodePushNativeModule extends BaseJavaModule {
                                 }
                             };
 
-                            getReactApplicationContext().addLifecycleEventListener(mLifecycleEventListener);
+                            reactContext.addLifecycleEventListener(mLifecycleEventListener);
                         }
                     }
 
-                    promise.resolve("");
-                } catch(CodePushUnknownException e) {
+                    promise.resolve(null);
+                } catch (CodePushUnknownException e) {
                     CodePushUtils.log(e);
                     promise.reject(e);
                 }
@@ -713,8 +630,7 @@ public class CodePushNativeModule extends BaseJavaModule {
         asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
     }
 
-    @ReactMethod
-    public void isFailedUpdate(String packageHash, Promise promise) {
+    void isFailedUpdate(String packageHash, Promise promise) {
         try {
             promise.resolve(mSettingsManager.isFailedHash(packageHash));
         } catch (CodePushUnknownException e) {
@@ -723,8 +639,7 @@ public class CodePushNativeModule extends BaseJavaModule {
         }
     }
 
-    @ReactMethod
-    public void getLatestRollbackInfo(Promise promise) {
+    void getLatestRollbackInfo(Promise promise) {
         try {
             JSONObject latestRollbackInfo = mSettingsManager.getLatestRollbackInfo();
             if (latestRollbackInfo != null) {
@@ -738,8 +653,7 @@ public class CodePushNativeModule extends BaseJavaModule {
         }
     }
 
-    @ReactMethod
-    public void setLatestRollbackInfo(String packageHash, Promise promise) {
+    void setLatestRollbackInfo(String packageHash, Promise promise) {
         try {
             mSettingsManager.setLatestRollbackInfo(packageHash);
             promise.resolve(null);
@@ -749,53 +663,46 @@ public class CodePushNativeModule extends BaseJavaModule {
         }
     }
 
-    @ReactMethod
-    public void isFirstRun(String packageHash, Promise promise) {
+    void isFirstRun(String packageHash, Promise promise) {
         try {
             boolean isFirstRun = mCodePush.didUpdate()
                     && packageHash != null
                     && packageHash.length() > 0
                     && packageHash.equals(mUpdateManager.getCurrentPackageHash());
             promise.resolve(isFirstRun);
-        } catch(CodePushUnknownException e) {
+        } catch (CodePushUnknownException e) {
             CodePushUtils.log(e);
             promise.reject(e);
         }
     }
 
-    @ReactMethod
-    public void notifyApplicationReady(Promise promise) {
+    void notifyApplicationReady(Promise promise) {
         try {
             mSettingsManager.removePendingUpdate();
-            promise.resolve("");
-        } catch(CodePushUnknownException e) {
+            promise.resolve(null);
+        } catch (CodePushUnknownException e) {
             CodePushUtils.log(e);
             promise.reject(e);
         }
     }
 
-    @ReactMethod
-    public void recordStatusReported(ReadableMap statusReport) {
+    void recordStatusReported(ReadableMap statusReport) {
         try {
             mTelemetryManager.recordStatusReported(statusReport);
-        } catch(CodePushUnknownException e) {
+        } catch (CodePushUnknownException e) {
             CodePushUtils.log(e);
         }
     }
 
-    @ReactMethod
-    public void saveStatusReportForRetry(ReadableMap statusReport) {
+    void saveStatusReportForRetry(ReadableMap statusReport) {
         try {
             mTelemetryManager.saveStatusReportForRetry(statusReport);
-        } catch(CodePushUnknownException e) {
+        } catch (CodePushUnknownException e) {
             CodePushUtils.log(e);
         }
     }
 
-    @ReactMethod
-    // Replaces the current bundle with the one downloaded from removeBundleUrl.
-    // It is only to be used during tests. No-ops if the test configuration flag is not set.
-    public void downloadAndReplaceCurrentBundle(String remoteBundleUrl) {
+    void downloadAndReplaceCurrentBundle(String remoteBundleUrl) {
         try {
             if (mCodePush.isUsingTestConfiguration()) {
                 try {
@@ -804,41 +711,29 @@ public class CodePushNativeModule extends BaseJavaModule {
                     throw new CodePushUnknownException("Unable to replace current bundle", e);
                 }
             }
-        } catch(CodePushUnknownException | CodePushMalformedDataException e) {
+        } catch (CodePushUnknownException | CodePushMalformedDataException e) {
             CodePushUtils.log(e);
         }
     }
 
-    /**
-     * This method clears CodePush's downloaded updates.
-     * It is needed to switch to a different deployment if the current deployment is more recent.
-     * Note: we don’t recommend to use this method in scenarios other than that (CodePush will call
-     * this method automatically when needed in other cases) as it could lead to unpredictable
-     * behavior.
-     */
-    @ReactMethod
-    public void clearUpdates() {
+    void clearUpdates() {
         CodePushUtils.log("Clearing updates.");
         mCodePush.clearUpdates();
     }
 
-    @ReactMethod
-    public void addListener(String eventName) {
-        // Set up any upstream listeners or background tasks as necessary
+    void addListener(String eventName) {
+        // no-op
     }
 
-    @ReactMethod
-    public void removeListeners(Integer count) {
-        // Remove upstream listeners, stop unnecessary background tasks
+    void removeListeners(double count) {
+        // no-op
     }
 
-    public ReactHostDelegate getReactHostDelegate(ReactHostImpl reactHostImpl) {
+    ReactHostDelegate getReactHostDelegate(ReactHostImpl reactHostImpl) {
         try {
             Class<?> clazz = reactHostImpl.getClass();
             Field field = clazz.getDeclaredField("mReactHostDelegate");
             field.setAccessible(true);
-
-            // Get the value of the field for the provided instance
             return (ReactHostDelegate) field.get(reactHostImpl);
         } catch (NoSuchFieldException | IllegalAccessException e) {
             e.printStackTrace();
@@ -846,3 +741,4 @@ public class CodePushNativeModule extends BaseJavaModule {
         }
     }
 }
+