use queue instead

Author: geof90

RestartManager.js

@@ -1,78 +1,55 @@
 const log = require("./logging");
 const NativeCodePush = require("react-native").NativeModules.CodePush;
-const CodePush = require("./CodePush");
 
 const RestartManager = (() => {
-    let _inProgressPromise = null;
-    let _inProgressOnUpdateOnly = false;
-    
     let _allowed = true;
-    let _restartPending = false;
-    let _restartPendingOnUpdateOnly = false;
+    let _restartQueue = [];
 
     function allow() {
         log("Re-allowing restarts");
         _allowed = true;
-        
-        if (_restartPending) {
+
+        if (_restartQueue.length) {
             log("Executing pending restart");
-            restartApp(_restartPendingOnUpdateOnly);
+            restartApp(_restartQueue.shift(1));
         }
     }
-    
+
     function clearPendingRestart() {
-        _restartPending = false;
+        _restartQueue = [];
     }
-    
+
     function disallow() {
         log("Disallowing restarts");
         _allowed = false;
     }
 
-    function restartApp(onlyIfUpdateIsPending = false) {
-        (async function(onlyIfUpdateIsPending) {
-            var didRestartSucceed = false;
-            
-            if (_restartPending) {
-                _restartPendingOnUpdateOnly = _restartPendingOnUpdateOnly && onlyIfUpdateIsPending;
-                log("Restart request queued until restarts are re-allowed");
+    async function restartApp(onlyIfUpdateIsPending = false) {
+        if (_restartInProgress) {
+            log("Restart request queued until the current restart is completed");
+            _restartQueue.push(onlyIfUpdateIsPending);
+        } else if (!_allowed) {
+            log("Restart request queued until restarts are re-allowed");
+            _restartQueue.push(onlyIfUpdateIsPending);
+        } else {
+            _restartInProgress = true;
+            log("Restarting app");
+            if (await NativeCodePush.restartApp(onlyIfUpdateIsPending)) {
+                // The app has already restarted, so there is no need to
+                // process the remaining queued restarts.
                 return;
             }
-            
-            if (!!_inProgressPromise) {
-                didRestartSucceed = await _inProgressPromise;
-                if (didRestartSucceed) {
-                    log("A restart is already in progress.");
-                    return;
-                }
+
+            _restartInProgress = false;
+            if (_restartQueue.length) {
+                restartApp(_restartQueue.shift(1));
             }
-            
-            _inProgressPromise = new Promise(async function(resolve, reject) {
-                resolve(await restartAppInternal(onlyIfUpdateIsPending));
-            });
-            _inProgressOnUpdateOnly = onlyIfUpdateIsPending;
-            
-            didRestartSucceed = await _inProgressPromise;
-            if (!didRestartSucceed) _inProgressPromise = null;
-        })(onlyIfUpdateIsPending);
-    };
-    
-    async function restartAppInternal(onlyIfUpdateIsPending = false) {
-        if (_allowed) {
-            var didRestartSucceed = await NativeCodePush.restartApp(onlyIfUpdateIsPending);
-            log("Restarting app");
-            return didRestartSucceed;
-        } else {
-            log("Restart request queued until restarts are re-allowed");
-            _restartPending = true;
-            _restartPendingOnUpdateOnly = onlyIfUpdateIsPending;
-            return true;
         }
     }
 
     return {
         allow,
-        clearPendingRestart,        
+        clearPendingRestart,
         disallow,
         restartApp
     };