@capawesome/capacitor-live-update 8.7.0 → 8.7.1

package/android/src/main/java/io/capawesome/capacitorjs/plugins/liveupdate/LiveUpdate.java

@@ -9,6 +9,7 @@ import android.content.res.AssetManager;
 import android.os.Build;
 import android.os.Handler;
 import android.os.Looper;
+import android.os.SystemClock;
 import android.util.Base64;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -115,8 +116,18 @@ public class LiveUpdate {
     private final Handler rollbackHandler = new Handler(Looper.getMainLooper());
     private final String manifestFileName = "capawesome-live-update-manifest.json"; // DO NOT CHANGE!
 
+    private boolean activityStopped = false;
     private boolean initialPageLoaded = false;
     private long lastAutoUpdateCheckTimestamp = 0;
+
+    /** Milliseconds left on the rollback timer while it is paused in the background. */
+    @Nullable
+    private Long remainingRollbackTimeout = null;
+
+    /** Uptime at which the scheduled rollback fires, or {@code null} if none is scheduled. */
+    @Nullable
+    private Long rollbackDeadline = null;
+
     private boolean rollbackPerformed = false;
     private boolean syncInProgress = false;
 
@@ -421,6 +432,16 @@ public class LiveUpdate {
         }
     }
 
+    public synchronized void handleOnStart() {
+        activityStopped = false;
+        resumeRollbackTimer();
+    }
+
+    public synchronized void handleOnStop() {
+        activityStopped = true;
+        pauseRollbackTimer();
+    }
+
     public void ready(@NonNull NonEmptyCallback callback) {
         Logger.debug(LiveUpdatePlugin.TAG, "App is ready.");
         if (config.getReadyTimeout() <= 0) {
@@ -1356,6 +1377,23 @@ public class LiveUpdate {
         sync(options, callback);
     }
 
+    private void pauseRollbackTimer() {
+        if (rollbackDeadline == null) {
+            return;
+        }
+        rollbackHandler.removeCallbacksAndMessages(null);
+        remainingRollbackTimeout = Math.max(0, rollbackDeadline - SystemClock.uptimeMillis());
+        rollbackDeadline = null;
+    }
+
+    private void resumeRollbackTimer() {
+        if (remainingRollbackTimeout == null) {
+            return;
+        }
+        scheduleRollback(remainingRollbackTimeout);
+        remainingRollbackTimeout = null;
+    }
+
     @NonNull
     private String requireAppId() throws Exception {
         return requireAppId(null);
@@ -1532,16 +1570,33 @@ public class LiveUpdate {
         preferences.setPreviousBundleId(bundleId);
     }
 
-    private void startRollbackTimer() {
+    private void scheduleRollback(long delayMillis) {
+        rollbackDeadline = SystemClock.uptimeMillis() + delayMillis;
+        rollbackHandler.postDelayed(() -> {
+            synchronized (this) {
+                rollbackDeadline = null;
+            }
+            rollback();
+        }, delayMillis);
+    }
+
+    /** The timer only counts time in the foreground, because a stopped activity may not run JS. */
+    private synchronized void startRollbackTimer() {
         if (config.getReadyTimeout() <= 0) {
             return;
         }
         stopRollbackTimer();
-        rollbackHandler.postDelayed(() -> rollback(), config.getReadyTimeout());
+        if (activityStopped) {
+            remainingRollbackTimeout = (long) config.getReadyTimeout();
+        } else {
+            scheduleRollback(config.getReadyTimeout());
+        }
     }
 
-    private void stopRollbackTimer() {
+    private synchronized void stopRollbackTimer() {
         rollbackHandler.removeCallbacksAndMessages(null);
+        rollbackDeadline = null;
+        remainingRollbackTimeout = null;
     }
 
     private boolean tryCopyCurrentBundleFile(@NonNull ManifestItem fileToCopy, @NonNull File destinationDirectory) {

package/android/src/main/java/io/capawesome/capacitorjs/plugins/liveupdate/LiveUpdatePlugin.java

@@ -41,7 +41,7 @@ import java.util.Map;
 public class LiveUpdatePlugin extends Plugin {
 
     public static final String TAG = "LiveUpdate";
-    public static final String VERSION = "8.7.0";
+    public static final String VERSION = "8.7.1";
     public static final String SHARED_PREFERENCES_NAME = "CapawesomeLiveUpdate"; // DO NOT CHANGE
     public static final String ERROR_APP_ID_MISSING = "appId must be configured.";
     public static final String ERROR_BUNDLE_DIRECTORY_NOT_FOUND = "Bundle directory could not be resolved.";
@@ -132,6 +132,22 @@ public class LiveUpdatePlugin extends Plugin {
         }
     }
 
+    @Override
+    protected void handleOnStart() {
+        super.handleOnStart();
+        if (implementation != null) {
+            implementation.handleOnStart();
+        }
+    }
+
+    @Override
+    protected void handleOnStop() {
+        super.handleOnStop();
+        if (implementation != null) {
+            implementation.handleOnStop();
+        }
+    }
+
     @PluginMethod
     public void clearBlockedBundles(PluginCall call) {
         try {

package/ios/Plugin/LiveUpdate.swift

@@ -27,9 +27,15 @@ import CommonCrypto
     private let plugin: LiveUpdatePlugin?
     private let preferences: LiveUpdatePreferences
 
+    private var isAppInBackground = false
+    private var lastAutoUpdateCheckTimestamp: Int64 = 0
+    /// Milliseconds left on the rollback timer while it is paused in the background.
+    private var remainingRollbackTimeout: Int?
+    private var rollbackDeadline: DispatchTime?
     private var rollbackDispatchWorkItem: DispatchWorkItem?
     private var rollbackPerformed = false
-    private var lastAutoUpdateCheckTimestamp: Int64 = 0
+    /// Guards the rollback timer state: plugin methods run on the bridge queue, lifecycle callbacks on main.
+    private let rollbackTimerLock = NSLock()
     private var syncInProgress = false
 
     /// - Parameter plugin: The Capacitor plugin, or `nil` for a headless instance
@@ -225,7 +231,18 @@ import CommonCrypto
         }
     }
 
+    @objc public func handleAppDidEnterBackground() {
+        rollbackTimerLock.lock()
+        defer { rollbackTimerLock.unlock() }
+        isAppInBackground = true
+        pauseRollbackTimer()
+    }
+
     @objc public func handleAppWillEnterForeground() {
+        rollbackTimerLock.lock()
+        defer { rollbackTimerLock.unlock() }
+        isAppInBackground = false
+        resumeRollbackTimer()
         if config.autoUpdateStrategy == "background" {
             performAutoUpdate()
         }
@@ -410,6 +427,14 @@ import CommonCrypto
         return Self.downloadsDirectoryUrl
     }
 
+    /// Must be called with `rollbackTimerLock` held.
+    private func clearRollbackTimer() {
+        rollbackDispatchWorkItem?.cancel()
+        rollbackDispatchWorkItem = nil
+        rollbackDeadline = nil
+        remainingRollbackTimeout = nil
+    }
+
     private func copyCurrentBundleFile(fileToCopy: ManifestItem, toDirectory: URL) throws {
         let currentBundleId = getCurrentBundleId()
         let destination = toDirectory.appendingPathComponent(fileToCopy.href)
@@ -816,6 +841,27 @@ import CommonCrypto
         }
     }
 
+    /// Must be called with `rollbackTimerLock` held.
+    private func pauseRollbackTimer() {
+        guard let deadline = rollbackDeadline else {
+            return
+        }
+        rollbackDispatchWorkItem?.cancel()
+        rollbackDispatchWorkItem = nil
+        rollbackDeadline = nil
+        let now = DispatchTime.now()
+        remainingRollbackTimeout = deadline > now ? Int((deadline.uptimeNanoseconds - now.uptimeNanoseconds) / 1_000_000) : 0
+    }
+
+    /// Must be called with `rollbackTimerLock` held.
+    private func resumeRollbackTimer() {
+        guard let remainingRollbackTimeout = remainingRollbackTimeout else {
+            return
+        }
+        self.remainingRollbackTimeout = nil
+        scheduleRollback(afterMilliseconds: remainingRollbackTimeout)
+    }
+
     private func requireAppId(_ appIdOverride: String? = nil) throws -> String {
         guard let appId = appIdOverride ?? getAppId(), !appId.isEmpty else {
             throw CustomError.appIdMissing
@@ -968,19 +1014,41 @@ import CommonCrypto
         preferences.setPreviousBundleId(bundleId)
     }
 
+    private func scheduleRollback(afterMilliseconds milliseconds: Int) {
+        let deadline = DispatchTime.now() + DispatchTimeInterval.milliseconds(milliseconds)
+        let workItem = DispatchWorkItem { [weak self] in
+            guard let self = self else {
+                return
+            }
+            self.rollbackTimerLock.lock()
+            self.rollbackDeadline = nil
+            self.rollbackTimerLock.unlock()
+            self.rollback()
+        }
+        rollbackDeadline = deadline
+        rollbackDispatchWorkItem = workItem
+        DispatchQueue.main.asyncAfter(deadline: deadline, execute: workItem)
+    }
+
+    /// The timer only counts time in the foreground, because a suspended app cannot call `ready()`.
     private func startRollbackTimer() {
         guard config.readyTimeout > 0 else {
             return
         }
-        stopRollbackTimer()
-        rollbackDispatchWorkItem = DispatchWorkItem { [weak self] in
-            self?.rollback()
+        rollbackTimerLock.lock()
+        defer { rollbackTimerLock.unlock() }
+        clearRollbackTimer()
+        if isAppInBackground {
+            remainingRollbackTimeout = config.readyTimeout
+        } else {
+            scheduleRollback(afterMilliseconds: config.readyTimeout)
         }
-        DispatchQueue.main.asyncAfter(deadline: .now() + DispatchTimeInterval.milliseconds(config.readyTimeout), execute: rollbackDispatchWorkItem!)
     }
 
     private func stopRollbackTimer() {
-        rollbackDispatchWorkItem?.cancel()
+        rollbackTimerLock.lock()
+        defer { rollbackTimerLock.unlock() }
+        clearRollbackTimer()
     }
 
     private func tryCopyCurrentBundleFile(

package/ios/Plugin/LiveUpdatePlugin.swift

@@ -8,7 +8,7 @@ import Capacitor
 @objc(LiveUpdatePlugin)
 public class LiveUpdatePlugin: CAPPlugin, CAPBridgedPlugin {
     public static let tag = "LiveUpdate"
-    public static let version = "8.7.0"
+    public static let version = "8.7.1"
     public static let userDefaultsPrefix = "CapawesomeLiveUpdate" // DO NOT CHANGE
 
     public let identifier = "LiveUpdatePlugin"
@@ -54,13 +54,22 @@ public class LiveUpdatePlugin: CAPPlugin, CAPBridgedPlugin {
         // Notify implementation about load
         implementation?.handleLoad()
 
-        // Register for app resume notifications
+        // Register for app lifecycle notifications
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleAppDidEnterBackground),
+            name: UIApplication.didEnterBackgroundNotification,
+            object: nil
+        )
         NotificationCenter.default.addObserver(
             self,
             selector: #selector(handleAppWillEnterForeground),
             name: UIApplication.willEnterForegroundNotification,
             object: nil
         )
+        if UIApplication.shared.applicationState == .background {
+            implementation?.handleAppDidEnterBackground()
+        }
     }
 
     @objc func clearBlockedBundles(_ call: CAPPluginCall) {
@@ -387,6 +396,10 @@ public class LiveUpdatePlugin: CAPPlugin, CAPBridgedPlugin {
         notifyListeners(eventReloaded, data: event, retainUntilConsumed: true)
     }
 
+    @objc private func handleAppDidEnterBackground() {
+        implementation?.handleAppDidEnterBackground()
+    }
+
     @objc private func handleAppWillEnterForeground() {
         implementation?.handleAppWillEnterForeground()
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capawesome/capacitor-live-update",
-  "version": "8.7.0",
+  "version": "8.7.1",
   "description": "Capacitor plugin to update your app remotely in real-time on Android, iOS and Electron.",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",