@capgo/capacitor-updater 8.51.13 → 8.51.15

package/Package.swift

@@ -32,7 +32,8 @@ let package = Package(
             name: "CapacitorUpdaterPluginTests",
             dependencies: [
                 "CapacitorUpdaterPlugin",
-                .product(name: "Version", package: "Version")
+                .product(name: "Version", package: "Version"),
+                .product(name: "ZIPFoundation", package: "ZIPFoundation")
             ],
             path: "ios/Tests/CapacitorUpdaterPluginTests")
     ],

package/README.md

@@ -303,7 +303,7 @@ CapacitorUpdater can be configured with these options:
 | Prop                                   | Type                                                                                                       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Default                                                                       | Since   |
 | -------------------------------------- | ---------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ------- |
 | **`appReadyTimeout`**                  | <code>number</code>                                                                                        | Configure the number of milliseconds the native plugin should wait before considering an update 'failed'. Only available for Android and iOS.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | <code>10000 // (10 seconds)</code>                                            |         |
-| **`responseTimeout`**                  | <code>number</code>                                                                                        | Configure the number of seconds the native plugin should wait before considering API timeout. Only available for Android and iOS.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | <code>20 // (20 second)</code>                                                |         |
+| **`responseTimeout`**                  | <code>number</code>                                                                                        | Configure the number of seconds the native plugin should wait before considering an HTTP timeout. Applies to update checks and file downloads. On Android these are idle connect/read/write timeouts and do not cap total download time; on iOS the request timeout also bounds the total download duration. Only available for Android and iOS.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | <code>20 // (20 second)</code>                                                |         |
 | **`autoDeleteFailed`**                 | <code>boolean</code>                                                                                       | Configure whether the plugin should use automatically delete failed bundles. Only available for Android and iOS.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | <code>true</code>                                                             |         |
 | **`autoDeletePrevious`**               | <code>boolean</code>                                                                                       | Configure whether the plugin should use automatically delete previous bundles after a successful update. Only available for Android and iOS.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | <code>true</code>                                                             |         |
 | **`autoUpdate`**                       | <code>boolean \| 'always' \| 'off' \| 'atBackground' \| 'atInstall' \| 'onLaunch' \| 'onlyDownload'</code> | Configure how the plugin checks for, downloads, and applies live updates. The plugin checks for updates when the app moves to the foreground. When {@link periodCheckDelay} is greater than 0, it also checks on a repeating timer while the app stays open. Boolean values keep their existing behavior: - `true`: Same as `"atBackground"`. - `false`: Same as `"off"`. String values merge the previous Auto Update and Direct Update configuration: - `"off"`: Disable automatic update checks. - `"atBackground"`: Check and download automatically on each foreground check, then apply the update the next time the app moves to background. - `"atInstall"`: Apply immediately only after a fresh install or native app store update; otherwise use `"atBackground"` behavior. - `"onLaunch"`: Apply immediately only when the app is brought to the foreground from a killed state (cold start). After that first check, fall back to `"atBackground"` behavior. - `"always"`: Check on every foreground transition and apply immediately whenever an update is available. - `"onlyDownload"`: Check and download automatically, emit `updateAvailable`, and never set the next bundle or apply an update automatically. Only available for Android and iOS. | <code>true</code>                                                             |         |

package/android/src/main/java/ee/forgr/capacitor_updater/BundleInfo.java

@@ -99,7 +99,7 @@ public class BundleInfo {
     }
 
     public boolean isDownloaded() {
-        return (!this.isBuiltin() && this.downloaded != null && !this.downloaded.isEmpty() && !this.isDeleted() && !this.isDeleting());
+        return !this.isBuiltin() && this.downloaded != null && !this.downloaded.isEmpty() && !this.isDeleted() && !this.isDeleting();
     }
 
     public String getDownloaded() {

package/android/src/main/java/ee/forgr/capacitor_updater/CapacitorUpdaterPlugin.java

@@ -146,7 +146,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
     static final int APPLICATION_EXIT_REASON_USER_REQUESTED = 10;
     static final int APPLICATION_EXIT_REASON_DEPENDENCY_DIED = 12;
 
-    private final String pluginVersion = "8.51.13";
+    private final String pluginVersion = "8.51.15";
     private static final String DELAY_CONDITION_PREFERENCES = "";
 
     private SharedPreferences.Editor editor;
@@ -250,6 +250,8 @@ public class CapacitorUpdaterPlugin extends Plugin {
     private volatile long webViewPageStartedAtMs = 0;
     private volatile boolean launchStartReported = false;
     private volatile boolean launchReadyReported = false;
+    private volatile boolean launchTimeoutReported = false;
+    private final Object launchReportLock = new Object();
     private FrameLayout splashscreenLoaderOverlay;
     private Runnable splashscreenTimeoutRunnable;
     private FrameLayout previewTransitionLoaderOverlay;
@@ -879,7 +881,10 @@ public class CapacitorUpdaterPlugin extends Plugin {
         this.autoSplashscreenLoader = this.getConfig().getBoolean("autoSplashscreenLoader", false);
         int splashscreenTimeoutValue = this.getConfig().getInt("autoSplashscreenTimeout", 10000);
         this.autoSplashscreenTimeout = Math.max(0, splashscreenTimeoutValue);
-        this.implementation.timeout = this.getConfig().getInt("responseTimeout", 20) * 1000;
+        int responseTimeoutSeconds = this.getConfig().getInt("responseTimeout", 20);
+        long responseTimeoutMillis = responseTimeoutSeconds > 0 ? (long) responseTimeoutSeconds * 1000L : 20_000L;
+        this.implementation.timeout = (int) Math.min(Integer.MAX_VALUE, responseTimeoutMillis);
+        DownloadService.applyHttpTimeouts(this.implementation.timeout);
         this.shakeMenuEnabled = this.getConfig().getBoolean("shakeMenu", false);
         this.shakeChannelSelectorEnabled = this.getConfig().getBoolean("allowShakeChannelSelector", false);
         this.shakeMenuGesture = normalizedShakeMenuGesture(this.getConfig().getString("shakeMenuGesture", SHAKE_MENU_GESTURE_SHAKE));
@@ -1751,16 +1756,18 @@ public class CapacitorUpdaterPlugin extends Plugin {
     }
 
     private void reportAppLaunchReady(final BundleInfo bundle) {
-        if (
-            this.implementation == null ||
-            this.implementation.statsUrl == null ||
-            this.implementation.statsUrl.isEmpty() ||
-            this.launchReadyReported
-        ) {
-            return;
+        synchronized (this.launchReportLock) {
+            if (
+                this.implementation == null ||
+                this.implementation.statsUrl == null ||
+                this.implementation.statsUrl.isEmpty() ||
+                this.launchReadyReported ||
+                this.launchTimeoutReported
+            ) {
+                return;
+            }
+            this.launchReadyReported = true;
         }
-
-        this.launchReadyReported = true;
         final Map<String, String> metadata = new HashMap<>();
         metadata.put("duration_ms", Long.toString(Math.max(0, System.currentTimeMillis() - this.launchStartedAtMs)));
         metadata.put("launch_started_at", Long.toString(this.launchStartedAtMs));
@@ -1769,14 +1776,22 @@ public class CapacitorUpdaterPlugin extends Plugin {
     }
 
     private void reportAppLaunchTimeout(final BundleInfo bundle) {
-        if (this.implementation == null || this.implementation.statsUrl == null || this.implementation.statsUrl.isEmpty()) {
-            return;
+        synchronized (this.launchReportLock) {
+            if (
+                this.implementation == null ||
+                this.implementation.statsUrl == null ||
+                this.implementation.statsUrl.isEmpty() ||
+                this.launchReadyReported ||
+                this.launchTimeoutReported
+            ) {
+                return;
+            }
+            this.launchTimeoutReported = true;
         }
-
         final Map<String, String> metadata = new HashMap<>();
         metadata.put("duration_ms", Long.toString(Math.max(0, System.currentTimeMillis() - this.launchStartedAtMs)));
         metadata.put("launch_started_at", Long.toString(this.launchStartedAtMs));
-        metadata.put("timeout_ms", Long.toString(this.appReadyTimeout));
+        metadata.put("timeout_ms", Long.toString(this.resolveAppReadyCheckTimeoutMs()));
         metadata.put("source", "app_ready_timeout");
         this.implementation.sendStats("app_launch_timeout", bundle == null ? "" : bundle.getVersionName(), "", metadata);
     }
@@ -4218,12 +4233,18 @@ public class CapacitorUpdaterPlugin extends Plugin {
         if (this.shouldBlockAutoUpdateForPreviewSession()) {
             return "preview_session";
         }
-        if (this.isDownloadStuckOrTimedOut()) {
-            logger.info("Download already in progress, skipping duplicate download request");
-            return "already_running";
+        synchronized (this) {
+            final Thread previousTask = this.backgroundDownloadTask;
+            final Thread task = this.backgroundDownload();
+            if (task == null) {
+                return "unavailable";
+            }
+            if (previousTask != null && previousTask == task) {
+                logger.info("Download already in progress, skipping duplicate download request");
+                return "already_running";
+            }
+            return "queued";
         }
-        this.backgroundDownload();
-        return "queued";
     }
 
     @PluginMethod
@@ -4736,10 +4757,14 @@ public class CapacitorUpdaterPlugin extends Plugin {
         return true;
     }
 
-    private Thread backgroundDownload() {
+    private synchronized Thread backgroundDownload() {
         if (this.shouldBlockAutoUpdateForPreviewSession()) {
             return null;
         }
+        if (this.isDownloadStuckOrTimedOut()) {
+            logger.info("Download already in progress, skipping duplicate download request");
+            return this.backgroundDownloadTask;
+        }
         final boolean plannedDirectUpdate = this.shouldUseDirectUpdate();
         final boolean initialDirectUpdateAllowed = this.isDirectUpdateCurrentlyAllowed(plannedDirectUpdate);
         final String messageUpdate = initialDirectUpdateAllowed
@@ -4748,8 +4773,6 @@ public class CapacitorUpdaterPlugin extends Plugin {
                 ? "Update will occur next time app moves to background."
                 : "Update will be downloaded and made available.";
         Thread newTask = startNewThread(() -> {
-            // Wait for cleanup to complete before starting download
-            waitForCleanupIfNeeded();
             if (CapacitorUpdaterPlugin.this.shouldBlockAutoUpdateForPreviewSession()) {
                 CapacitorUpdaterPlugin.this.clearBackgroundDownloadState();
                 return;
@@ -4762,7 +4785,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
                         return;
                     }
                     JSObject jsRes = InternalUtils.mapToJSObject(res);
-                    final BundleInfo current = CapacitorUpdaterPlugin.this.implementation.getCurrentBundle();
+                    final BundleInfo currentBeforeCleanup = CapacitorUpdaterPlugin.this.implementation.getCurrentBundle();
 
                     // Handle network errors and other failures first
                     if (jsRes.has("error") || jsRes.has("kind")) {
@@ -4770,8 +4793,15 @@ public class CapacitorUpdaterPlugin extends Plugin {
                         String errorMessage = jsRes.has("message") ? jsRes.getString("message") : "server did not provide a message";
                         int statusCode = jsRes.has("statusCode") ? jsRes.optInt("statusCode", 0) : 0;
                         String kind = CapacitorUpdaterPlugin.this.getUpdateResponseKind(jsRes.has("kind") ? jsRes.getString("kind") : null);
-                        String latestVersion = jsRes.has("version") ? jsRes.getString("version") : current.getVersionName();
-                        CapacitorUpdaterPlugin.this.notifyUpdateCheckResult(kind, error, errorMessage, statusCode, latestVersion, current);
+                        String latestVersion = jsRes.has("version") ? jsRes.getString("version") : currentBeforeCleanup.getVersionName();
+                        CapacitorUpdaterPlugin.this.notifyUpdateCheckResult(
+                            kind,
+                            error,
+                            errorMessage,
+                            statusCode,
+                            latestVersion,
+                            currentBeforeCleanup
+                        );
                         CapacitorUpdaterPlugin.this.notifyBreakingEventsIfNeeded(
                             jsRes,
                             jsRes.has("version") ? jsRes.getString("version") : ""
@@ -4791,7 +4821,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
                         CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
                             errorMessage,
                             latestVersion,
-                            current,
+                            currentBeforeCleanup,
                             isFailure,
                             plannedDirectUpdate,
                             "download_fail",
@@ -4801,6 +4831,9 @@ public class CapacitorUpdaterPlugin extends Plugin {
                         return;
                     }
                     try {
+                        // File mutations wait here. getLatest already ran in parallel with cleanup.
+                        waitForCleanupIfNeeded();
+                        final BundleInfo current = CapacitorUpdaterPlugin.this.implementation.getCurrentBundle();
                         final String latestVersionName = jsRes.getString("version");
 
                         if ("builtin".equals(latestVersionName)) {
@@ -5049,8 +5082,8 @@ public class CapacitorUpdaterPlugin extends Plugin {
                         logger.error("error in update check " + e.getMessage());
                         CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
                             "Error in update check",
-                            current.getVersionName(),
-                            current,
+                            currentBeforeCleanup.getVersionName(),
+                            currentBeforeCleanup,
                             true,
                             plannedDirectUpdate
                         );

package/android/src/main/java/ee/forgr/capacitor_updater/CapgoUpdater.java

@@ -315,14 +315,17 @@ public class CapgoUpdater {
         return this.cachedKeyId;
     }
 
-    private File unzip(final String id, final File zipFile, final String dest) throws IOException {
+    File unzip(final String id, final File zipFile, final String dest) throws IOException {
+        return unzip(id, zipFile, dest, CryptoCipher.ioBufferBytes());
+    }
+
+    File unzip(final String id, final File zipFile, final String dest, final int bufferSize) throws IOException {
         final File targetDirectory = new File(this.documentsDir, dest);
         try (
             final BufferedInputStream bis = new BufferedInputStream(new FileInputStream(zipFile));
             final ZipInputStream zis = new ZipInputStream(bis)
         ) {
             int count;
-            final int bufferSize = 8192;
             final byte[] buffer = new byte[bufferSize];
             final long lengthTotal = zipFile.length();
             long lengthRead = bufferSize;
@@ -760,6 +763,13 @@ public class CapgoUpdater {
                                 }
                             });
                             break;
+                        case CANCELLED:
+                            DataManager.getInstance().clearManifest(id);
+                            CompletableFuture<BundleInfo> cancelledFuture = downloadFutures.remove(id);
+                            if (cancelledFuture != null) {
+                                cancelledFuture.cancel(true);
+                            }
+                            break;
                     }
                 });
         });
@@ -781,6 +791,10 @@ public class CapgoUpdater {
         }
         observeWorkProgress(this.activity, id, setNext);
 
+        if (manifest != null) {
+            DataManager.getInstance().setManifest(id, manifest);
+        }
+
         DownloadWorkerManager.enqueueDownload(
             this.activity,
             url,
@@ -805,10 +819,6 @@ public class CapgoUpdater {
             this.customId,
             this.defaultChannel
         );
-
-        if (manifest != null) {
-            DataManager.getInstance().setManifest(manifest);
-        }
     }
 
     public Boolean finishDownload(
@@ -1398,7 +1408,10 @@ public class CapgoUpdater {
             BundleInfo existingBundle = this.getBundleInfoByName(version);
             if (existingBundle != null && existingBundle.isErrorStatus()) {
                 // Cancel the failed download and allow retry
-                DownloadWorkerManager.cancelVersionDownload(this.activity, version);
+                if (!DownloadWorkerManager.cancelVersionDownloadAndAwait(this.activity, version)) {
+                    logger.error("Failed to cancel previous download before retry");
+                    return;
+                }
                 logger.info("Retrying failed download for version: " + version);
             } else {
                 logger.info("Version already downloading: " + version);
@@ -1419,7 +1432,9 @@ public class CapgoUpdater {
         BundleInfo existingBundle = this.getBundleInfoByName(version);
         if (existingBundle != null && (existingBundle.isErrorStatus() || existingBundle.isDeleted() || existingBundle.isDeleting())) {
             logger.info("Found existing failed bundle for version " + version + ", deleting before retry");
-            this.delete(existingBundle.getId(), true);
+            if (!Boolean.TRUE.equals(this.delete(existingBundle.getId(), true))) {
+                throw new IOException("Failed to delete existing bundle before retry");
+            }
         }
 
         final String id = this.randomString();
@@ -1472,7 +1487,9 @@ public class CapgoUpdater {
         BundleInfo existingBundle = this.getBundleInfoByName(version);
         if (existingBundle != null && (existingBundle.isErrorStatus() || existingBundle.isDeleted() || existingBundle.isDeleting())) {
             logger.info("Found existing failed bundle for version " + version + ", deleting before retry");
-            this.delete(existingBundle.getId(), true);
+            if (!Boolean.TRUE.equals(this.delete(existingBundle.getId(), true))) {
+                throw new IOException("Failed to delete existing bundle before retry");
+            }
         }
 
         final String id = this.randomString();
@@ -1587,7 +1604,10 @@ public class CapgoUpdater {
 
             // Cancel download for this version if active
             if (cancelActiveDownload && this.activity != null) {
-                DownloadWorkerManager.cancelVersionDownload(this.activity, deleted.getVersionName());
+                if (!DownloadWorkerManager.cancelVersionDownloadAndAwait(this.activity, deleted.getVersionName())) {
+                    logger.error("Failed to cancel active download before delete");
+                    return false;
+                }
             }
 
             if (bundle.exists()) {
@@ -1922,32 +1942,35 @@ public class CapgoUpdater {
             !fallbackIsPreviewFallback &&
             !previousIsNext;
         if (shouldDeletePrevious) {
-            // Cancel any in-flight download for the old version before the async boundary
-            // so a later download of the same version name is not cancelled mid-flight.
-            if (this.activity != null) {
-                DownloadWorkerManager.cancelVersionDownload(this.activity, previousFallbackVersion);
-            }
-            // Mark durable intent before fallback switch so a kill mid-flight still retries.
             if (!this.saveBundleInfo(previousFallbackId, fallback.setStatus(BundleStatus.DELETING))) {
                 logger.error("Failed to persist DELETING for previous bundle; queueing durable retry");
                 logger.debug("Bundle ID: " + previousFallbackId);
                 this.enqueuePendingDelete(previousFallbackId);
             }
         }
+        boolean deletePreviousAsync = shouldDeletePrevious;
         this.setFallbackBundle(bundle);
-        if (shouldDeletePrevious) {
-            new Thread(() -> {
+        if (deletePreviousAsync) {
+            final String asyncPreviousFallbackId = previousFallbackId;
+            final String asyncPreviousFallbackVersion = previousFallbackVersion;
+            io.execute(() -> {
+                if (this.activity != null) {
+                    if (!DownloadWorkerManager.cancelVersionDownloadAndAwait(this.activity, asyncPreviousFallbackVersion)) {
+                        logger.error("Failed to cancel previous version download before delete");
+                        return;
+                    }
+                }
                 try {
-                    final Boolean res = this.delete(previousFallbackId, true, false);
+                    final Boolean res = this.delete(asyncPreviousFallbackId, true, false);
                     if (Boolean.TRUE.equals(res)) {
-                        logger.info("Deleted previous bundle: " + previousFallbackVersion);
+                        logger.info("Deleted previous bundle: " + asyncPreviousFallbackVersion);
                     } else {
-                        logger.debug("Previous bundle delete incomplete, will retry: " + previousFallbackId);
+                        logger.debug("Previous bundle delete incomplete, will retry: " + asyncPreviousFallbackId);
                     }
                 } catch (final IOException e) {
-                    logger.error("Failed to delete previous bundle: " + previousFallbackId + " " + e.getMessage());
+                    logger.error("Failed to delete previous bundle: " + asyncPreviousFallbackId + " " + e.getMessage());
                 }
-            }, "CapgoUpdater-autoDeletePrevious").start();
+            });
         }
     }
 
@@ -2854,7 +2877,17 @@ public class CapgoUpdater {
 
     public void restorePendingStats() {
         File file = pendingStatsFile();
-        if (file == null || !file.exists()) {
+        if (file == null) {
+            return;
+        }
+        File backup = new File(file.getAbsolutePath() + ".bak");
+        if (!file.exists() && backup.exists() && !backup.renameTo(file)) {
+            if (logger != null) {
+                logger.error("Failed to restore stats backup");
+            }
+            return;
+        }
+        if (!file.exists()) {
             return;
         }
         try {
@@ -2958,18 +2991,39 @@ public class CapgoUpdater {
 
     private static void writeFileAtomically(final File file, final byte[] bytes) throws IOException {
         final File tmp = new File(file.getAbsolutePath() + ".tmp");
-        try (FileOutputStream out = new FileOutputStream(tmp)) {
-            out.write(bytes);
-            out.flush();
-        }
-        if (tmp.renameTo(file)) {
-            return;
-        }
-        if (file.exists() && !file.delete()) {
-            throw new IOException("Failed to replace " + file.getAbsolutePath());
-        }
-        if (!tmp.renameTo(file)) {
+        File backup = null;
+        try {
+            try (FileOutputStream out = new FileOutputStream(tmp)) {
+                out.write(bytes);
+                out.flush();
+            }
+            if (tmp.renameTo(file)) {
+                return;
+            }
+            if (file.exists()) {
+                backup = new File(file.getAbsolutePath() + ".bak");
+                if (backup.exists() && !backup.delete()) {
+                    throw new IOException("Failed to replace " + file.getAbsolutePath());
+                }
+                if (!file.renameTo(backup)) {
+                    throw new IOException("Failed to replace " + file.getAbsolutePath());
+                }
+            }
+            if (tmp.renameTo(file)) {
+                if (backup != null && backup.exists() && !backup.delete()) {
+                    backup.deleteOnExit();
+                }
+                backup = null;
+                return;
+            }
             throw new IOException("Failed to persist " + file.getAbsolutePath());
+        } finally {
+            if (backup != null && !file.exists()) {
+                backup.renameTo(file);
+            }
+            if (tmp.exists() && !tmp.delete()) {
+                tmp.deleteOnExit();
+            }
         }
     }
 

package/android/src/main/java/ee/forgr/capacitor_updater/CryptoCipher.java

@@ -169,7 +169,11 @@ public class CryptoCipher {
         }
         Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
         cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key.getEncoded(), "AES"), new IvParameterSpec(iv));
-        File tempFile = File.createTempFile("capgo-aes-", ".tmp", file.getParentFile());
+        File parent = file.getAbsoluteFile().getParentFile();
+        if (parent == null) {
+            throw new IOException("Cannot create temp file for " + file.getAbsolutePath());
+        }
+        File tempFile = File.createTempFile("capgo-aes-", ".tmp", parent);
         try {
             byte[] inBuf = new byte[ioBufferBytes()];
             // Reuse one output buffer. cipher.update(in) allocates a new byte[] per chunk.
@@ -187,6 +191,9 @@ public class CryptoCipher {
                     fos.write(outBuf, 0, last);
                 }
             }
+            if (tempFile.length() == 0) {
+                throw new IOException("Empty decrypted data");
+            }
             replaceFile(tempFile, file);
             tempFile = null;
         } finally {

package/android/src/main/java/ee/forgr/capacitor_updater/DataManager.java

@@ -1,11 +1,13 @@
 package ee.forgr.capacitor_updater;
 
+import java.util.HashMap;
+import java.util.Map;
 import org.json.JSONArray;
 
 public class DataManager {
 
     private static DataManager instance;
-    private JSONArray currentManifest;
+    private final Map<String, JSONArray> manifestsById = new HashMap<>();
 
     private DataManager() {}
 
@@ -16,13 +18,27 @@ public class DataManager {
         return instance;
     }
 
-    public void setManifest(JSONArray manifest) {
-        this.currentManifest = manifest;
+    public synchronized void setManifest(String downloadId, JSONArray manifest) {
+        if (downloadId == null || manifest == null) {
+            return;
+        }
+        this.manifestsById.put(downloadId, manifest);
+    }
+
+    public synchronized JSONArray getAndClearManifest(String downloadId) {
+        if (downloadId == null) {
+            return null;
+        }
+        return this.manifestsById.remove(downloadId);
+    }
+
+    public synchronized void clearManifest(String downloadId) {
+        if (downloadId != null) {
+            this.manifestsById.remove(downloadId);
+        }
     }
 
-    public JSONArray getAndClearManifest() {
-        JSONArray manifest = this.currentManifest;
-        this.currentManifest = null;
-        return manifest;
+    public synchronized void clearAllManifests() {
+        this.manifestsById.clear();
     }
 }