Merge pull request #71 from Microsoft/fix-rollback

geof90 · geof90 · commit c4b96ede9f6b · 2015-11-25T17:11:20.000-08:00
Fix rollback
diff --git a/CodePush.m b/CodePush.m
@@ -7,7 +7,7 @@
 #import "CodePush.h"
 
 @implementation CodePush {
-    BOOL _resumablePendingUpdateAvailable;
+    BOOL _hasResumeListener;
 }
 
 RCT_EXPORT_MODULE()
@@ -84,55 +84,6 @@ - (void)cancelRollbackTimer
     });
 }
 
-/* 
- * This method checks to see whether a "pending update" has been applied
- * (e.g. install was called with a non-immediate mode), but the app hasn't
- * yet been restarted (either naturally or programmatically). If there is one,
- * it will restart the app (if specified), and start the rollback timer.
- *
- * Note: This method is safe to call from any thread.
- */
-- (void)checkForPendingUpdate:(BOOL)needsRestart
-{
-    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-        NSUserDefaults *preferences = [NSUserDefaults standardUserDefaults];
-        NSDictionary *pendingUpdate = [preferences objectForKey:PendingUpdateKey];
-        
-        if (pendingUpdate) {
-            NSError *error;
-            NSString *pendingHash = pendingUpdate[PendingUpdateHashKey];
-            NSString *currentHash = [CodePushPackage getCurrentPackageHash:&error];
-            
-            NSAssert([pendingHash isEqualToString:currentHash], @"There is a pending update but it's hash doesn't match that of the current package.");
-            
-            // Kick off the rollback timer and ensure that the necessary state is setup for the pending update.
-            int rollbackTimeout = [pendingUpdate[PendingUpdateRollbackTimeoutKey] intValue];
-            [self initializeUpdateWithRollbackTimeout:rollbackTimeout needsRestart:needsRestart];
-                            
-            // Clear the pending update and sync
-            [preferences removeObjectForKey:PendingUpdateKey];
-            [preferences synchronize];
-        }
-    });
-}
-
-/*
- * This method is meant as a handler for the global app
- * resume notification, and therefore, should not be called
- * directly. It simply checks to see whether there is a pending
- * update that is meant to be installed on resume, and if so
- * it applies it and restarts the app.
- */
-- (void)checkForPendingUpdateDuringResume
-{
-    // In order to ensure that CodePush doesn't impact the app's
-    // resume experience, we're using a simple boolean check to
-    // check whether we need to restart, before reading the defaults store
-    if (_resumablePendingUpdateAvailable) {
-        [self checkForPendingUpdate:YES];
-    }
-}
-
 /*
  * This method is used by the React Native bridge to allow
  * our plugin to expose constants to the JS-side. In our case
@@ -162,43 +113,33 @@ - (instancetype)init
     self = [super init];
     
     if (self) {
-        // Do an async check to see whether
-        // we need to start the rollback timer
-        // due to a pending update being installed at start
-        [self checkForPendingUpdate:NO];
-        
-        // Register for app resume notifications so that we
-        // can check for pending updates which support "restart on resume"
-        [[NSNotificationCenter defaultCenter] addObserver:self
-                                                 selector:@selector(checkForPendingUpdateDuringResume)
-                                                     name:UIApplicationWillEnterForegroundNotification
-                                                   object:[UIApplication sharedApplication]];
+        [self initializeUpdateAfterRestart];
     }
     
     return self;
 }
 
 /*
- * This method performs the actual initialization work for an update
- * to ensure that the necessary state is setup, including:
- * --------------------------------------------------------
- * 1. Updating the current bundle URL to point at the latest update on disk
- * 2. Optionally restarting the app to load the new bundle
- * 3. Optionally starting the rollback protection timer
+ * This method starts the rollback protection timer
+ * and is used when a new update is initialized.
  */
-- (void)initializeUpdateWithRollbackTimeout:(int)rollbackTimeout
-                               needsRestart:(BOOL)needsRestart
+- (void)initializeUpdateAfterRestart
 {
-    didUpdate = YES;
-    
-    if (needsRestart) {
-        [self loadBundle];
-    }
+    NSUserDefaults *preferences = [NSUserDefaults standardUserDefaults];
+    NSDictionary *pendingUpdate = [preferences objectForKey:PendingUpdateKey];
     
-    if (0 != rollbackTimeout) {
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [self startRollbackTimer:rollbackTimeout];
-        });
+    if (pendingUpdate) {
+        didUpdate = true;
+        int rollbackTimeout = [pendingUpdate[PendingUpdateRollbackTimeoutKey] intValue];
+        if (0 != rollbackTimeout) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                [self startRollbackTimer:rollbackTimeout];
+            });
+        }
+        
+        // Clear the pending update and sync
+        [preferences removeObjectForKey:PendingUpdateKey];
+        [preferences synchronize];
     }
 }
 
@@ -390,10 +331,22 @@ - (void)startRollbackTimer:(int)rollbackTimeout
         if (error) {
             reject(error);
         } else {
-            if (installMode != CodePushInstallModeImmediate) {
-                _resumablePendingUpdateAvailable = (installMode == CodePushInstallModeOnNextResume);
-                [self savePendingUpdate:updatePackage[@"packageHash"]
-                        rollbackTimeout:rollbackTimeout];
+            [self savePendingUpdate:updatePackage[@"packageHash"]
+                    rollbackTimeout:rollbackTimeout];
+            
+            if (installMode == CodePushInstallModeImmediate) {
+                [self loadBundle];
+            } else if (installMode == CodePushInstallModeOnNextResume) {
+                // Ensure we do not add the listener twice.
+                if (!_hasResumeListener) {
+                    // Register for app resume notifications so that we
+                    // can check for pending updates which support "restart on resume"
+                    [[NSNotificationCenter defaultCenter] addObserver:self
+                                                             selector:@selector(loadBundle)
+                                                                 name:UIApplicationWillEnterForegroundNotification
+                                                               object:[UIApplication sharedApplication]];
+                    _hasResumeListener = true;
+                }
             }
             // Signal to JS that the update has been applied.
             resolve(nil);
@@ -446,15 +399,28 @@ - (void)startRollbackTimer:(int)rollbackTimeout
  */
 RCT_EXPORT_METHOD(restartImmediateUpdate:(int)rollbackTimeout)
 {
-    [self initializeUpdateWithRollbackTimeout:rollbackTimeout needsRestart:YES];
+    [self loadBundle];
 }
 
 /*
  * This method is the native side of the CodePush.restartPendingUpdate() method.
  */
 RCT_EXPORT_METHOD(restartPendingUpdate)
 {
-    [self checkForPendingUpdate:YES];
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSUserDefaults *preferences = [NSUserDefaults standardUserDefaults];
+        NSDictionary *pendingUpdate = [preferences objectForKey:PendingUpdateKey];
+        
+        if (pendingUpdate) {
+            NSError *error;
+            NSString *pendingHash = pendingUpdate[PendingUpdateHashKey];
+            NSString *currentHash = [CodePushPackage getCurrentPackageHash:&error];
+            
+            NSAssert([pendingHash isEqualToString:currentHash], @"There is a pending update but it's hash doesn't match that of the current package.");
+            
+            [self loadBundle];
+        }
+    });
 }
 
 RCT_EXPORT_METHOD(setUsingTestFolder:(BOOL)shouldUseTestFolder)
diff --git a/android/app/src/main/java/com/microsoft/codepush/react/CodePush.java b/android/app/src/main/java/com/microsoft/codepush/react/CodePush.java
@@ -1,6 +1,7 @@
 package com.microsoft.codepush.react;
 
 import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.ActivityEventListener;
 import com.facebook.react.bridge.JavaScriptModule;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.NativeModule;
@@ -41,7 +42,6 @@
 
 public class CodePush {
 
-    private boolean resumablePendingUpdateAvailable = false;
     private boolean didUpdate = false;
     private Timer timer;
     private boolean usingTestFolder = false;
@@ -87,7 +87,7 @@ public CodePush(String deploymentKey, Activity mainActivity) {
             throw new CodePushUnknownException("Unable to get package info for " + applicationContext.getPackageName(), e);
         }
 
-        checkForPendingUpdate(/*needsRestart*/ false);
+        initializeUpdateAfterRestart();
     }
 
     public ReactPackage getReactPackage() {
@@ -144,52 +144,6 @@ private void cancelRollbackTimer() {
         }
     }
 
-    private void checkForPendingUpdate(boolean needsRestart) {
-        SharedPreferences settings = applicationContext.getSharedPreferences(CODE_PUSH_PREFERENCES, 0);
-        String pendingUpdateString = settings.getString(PENDING_UPDATE_KEY, null);
-
-        if (pendingUpdateString != null) {
-            try {
-                JSONObject pendingUpdateJSON = new JSONObject(pendingUpdateString);
-                String pendingHash = pendingUpdateJSON.getString(PENDING_UPDATE_HASH_KEY);
-                String currentHash = codePushPackage.getCurrentPackageHash();
-                if (!pendingHash.equals(currentHash)) {
-                    throw new CodePushUnknownException("Pending hash " + pendingHash +
-                            " and current hash " + currentHash + " are different");
-                }
-
-                int rollbackTimeout = pendingUpdateJSON.getInt(PENDING_UPDATE_ROLLBACK_TIMEOUT_KEY);
-                initializeUpdateWithRollbackTimeout(rollbackTimeout, needsRestart);
-                settings.edit().remove(PENDING_UPDATE_KEY).commit();
-            } catch (JSONException e) {
-                // Should not happen.
-                throw new CodePushUnknownException("Unable to parse pending update metadata " +
-                        pendingUpdateString + " stored in SharedPreferences", e);
-            } catch (IOException e) {
-                // There is no current package hash.
-                throw new CodePushUnknownException("Should not register a pending update without a saving a current package", e);
-            }
-        }
-    }
-
-    private void checkForPendingUpdateDuringResume() {
-        if (resumablePendingUpdateAvailable) {
-            checkForPendingUpdate(/*needsRestart*/ true);
-        }
-    }
-
-    private void initializeUpdateWithRollbackTimeout(int rollbackTimeout, boolean needsRestart) {
-        didUpdate = true;
-
-        if (needsRestart) {
-            codePushNativeModule.loadBundle();
-        }
-
-        if (0 != rollbackTimeout) {
-            startRollbackTimer(rollbackTimeout);
-        }
-    }
-
     private boolean isFailedHash(String packageHash) {
         SharedPreferences settings = applicationContext.getSharedPreferences(CODE_PUSH_PREFERENCES, 0);
         String failedUpdatesString = settings.getString(FAILED_UPDATES_KEY, null);
@@ -277,8 +231,32 @@ public void run() {
         }, timeout);
     }
 
+    private void initializeUpdateAfterRestart() {
+        SharedPreferences settings = applicationContext.getSharedPreferences(CODE_PUSH_PREFERENCES, 0);
+        String pendingUpdateString = settings.getString(PENDING_UPDATE_KEY, null);
+
+        if (pendingUpdateString != null) {
+            try {
+                didUpdate = true;
+                JSONObject pendingUpdateJSON = new JSONObject(pendingUpdateString);
+                int rollbackTimeout = pendingUpdateJSON.getInt(PENDING_UPDATE_ROLLBACK_TIMEOUT_KEY);
+                if (0 != rollbackTimeout) {
+                    startRollbackTimer(rollbackTimeout);
+                }
+
+                settings.edit().remove(PENDING_UPDATE_KEY).commit();
+            } catch (JSONException e) {
+                // Should not happen.
+                throw new CodePushUnknownException("Unable to parse pending update metadata " +
+                        pendingUpdateString + " stored in SharedPreferences", e);
+            }
+        }
+    }
+
     private class CodePushNativeModule extends ReactContextBaseJavaModule {
 
+        private LifecycleEventListener lifecycleEventListener = null;
+
         private void loadBundle() {
             Intent intent = mainActivity.getIntent();
             mainActivity.finish();
@@ -289,15 +267,37 @@ private void loadBundle() {
         public void installUpdate(ReadableMap updatePackage, int rollbackTimeout, int installMode, Promise promise) {
             try {
                 codePushPackage.installPackage(updatePackage);
+
+                String pendingHash = CodePushUtils.tryGetString(updatePackage, codePushPackage.PACKAGE_HASH_KEY);
+                if (pendingHash == null) {
+                    throw new CodePushUnknownException("Update package to be installed has no hash.");
+                } else {
+                    savePendingUpdate(pendingHash, rollbackTimeout);
+                }
+
                 if (installMode != CodePushInstallMode.IMMEDIATE.getValue()) {
-                    resumablePendingUpdateAvailable = installMode == CodePushInstallMode.ON_NEXT_RESUME.getValue();
-                    String pendingHash = CodePushUtils.tryGetString(updatePackage, codePushPackage.PACKAGE_HASH_KEY);
-                    if (pendingHash == null) {
-                        throw new CodePushUnknownException("Update package to be installed has no hash.");
-                    } else {
-                        savePendingUpdate(pendingHash, rollbackTimeout);
+                    loadBundle();
+                } else if (installMode == CodePushInstallMode.ON_NEXT_RESUME.getValue()) {
+                    // Ensure we do not add the listener twice.
+                    if (lifecycleEventListener == null) {
+                        lifecycleEventListener = new LifecycleEventListener() {
+                            @Override
+                            public void onHostResume() {
+                                loadBundle();
+                            }
+
+                            @Override
+                            public void onHostPause() {
+                            }
+
+                            @Override
+                            public void onHostDestroy() {
+                            }
+                        };
+                        getReactApplicationContext().addLifecycleEventListener(lifecycleEventListener);
                     }
                 }
+
                 promise.resolve("");
             } catch (IOException e) {
                 e.printStackTrace();
@@ -377,12 +377,34 @@ public void setUsingTestFolder(boolean shouldUseTestFolder) {
 
         @ReactMethod
         public void restartImmediateUpdate(int rollbackTimeout) {
-            initializeUpdateWithRollbackTimeout(rollbackTimeout, /*needsRestart*/ true);
+            loadBundle();
         }
 
         @ReactMethod
         public void restartPendingUpdate() {
-            checkForPendingUpdate(/*needsRestart*/ true);
+            SharedPreferences settings = applicationContext.getSharedPreferences(CODE_PUSH_PREFERENCES, 0);
+            String pendingUpdateString = settings.getString(PENDING_UPDATE_KEY, null);
+
+            if (pendingUpdateString != null) {
+                try {
+                    JSONObject pendingUpdateJSON = new JSONObject(pendingUpdateString);
+                    String pendingHash = pendingUpdateJSON.getString(PENDING_UPDATE_HASH_KEY);
+                    String currentHash = codePushPackage.getCurrentPackageHash();
+                    if (!pendingHash.equals(currentHash)) {
+                        throw new CodePushUnknownException("Pending hash " + pendingHash +
+                                " and current hash " + currentHash + " are different");
+                    }
+
+                    loadBundle();
+                } catch (JSONException e) {
+                    // Should not happen.
+                    throw new CodePushUnknownException("Unable to parse pending update metadata " +
+                            pendingUpdateString + " stored in SharedPreferences", e);
+                } catch (IOException e) {
+                    // There is no current package hash.
+                    throw new CodePushUnknownException("Should not register a pending update without a saving a current package", e);
+                }
+            }
         }
 
         @Override
@@ -414,21 +436,6 @@ public List<NativeModule> createNativeModules(ReactApplicationContext reactAppli
             nativeModules.add(CodePush.this.codePushNativeModule);
             nativeModules.add(dialogModule);
 
-            reactApplicationContext.addLifecycleEventListener(new LifecycleEventListener() {
-                @Override
-                public void onHostResume() {
-                    CodePush.this.checkForPendingUpdateDuringResume();
-                }
-
-                @Override
-                public void onHostPause() {
-                }
-
-                @Override
-                public void onHostDestroy() {
-                }
-            });
-
             return nativeModules;
         }
 
