@capgo/capacitor-updater 8.51.14 → 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/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.14";
+    private final String pluginVersion = "8.51.15";
     private static final String DELAY_CONDITION_PREFERENCES = "";
 
     private SharedPreferences.Editor editor;
@@ -881,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));
@@ -4230,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
@@ -4748,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
@@ -4760,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;
@@ -4774,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")) {
@@ -4782,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") : ""
@@ -4803,7 +4821,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
                         CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
                             errorMessage,
                             latestVersion,
-                            current,
+                            currentBeforeCleanup,
                             isFailure,
                             plannedDirectUpdate,
                             "download_fail",
@@ -4813,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)) {
@@ -5061,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();
+            });
         }
     }
 

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();
     }
 }

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

@@ -83,7 +83,11 @@ public class DownloadService extends Worker {
     private static final String UPDATE_FILE = "update.dat";
 
     // Shared OkHttpClient to prevent resource leaks
-    protected static OkHttpClient sharedClient;
+    protected static volatile OkHttpClient sharedClient;
+    private static final Object HTTP_CLIENT_LOCK = new Object();
+    // Match CapgoUpdater.timeout / responseTimeout default (20s). OkHttp's 10s
+    // defaults were unused by the plugin config and aborted slow manifest GETs.
+    private static volatile int httpTimeoutMs = 20_000;
     private static String currentAppId = "unknown";
     private static String currentPluginVersion = "unknown";
     private static String currentVersionOs = "unknown";
@@ -96,6 +100,9 @@ public class DownloadService extends Worker {
         sharedClient = new OkHttpClient.Builder()
             .dispatcher(dispatcher)
             .protocols(Arrays.asList(Protocol.HTTP_2, Protocol.HTTP_1_1))
+            .connectTimeout(httpTimeoutMs, TimeUnit.MILLISECONDS)
+            .readTimeout(httpTimeoutMs, TimeUnit.MILLISECONDS)
+            .writeTimeout(httpTimeoutMs, TimeUnit.MILLISECONDS)
             .addInterceptor((chain) -> {
                 Request originalRequest = chain.request();
                 String userAgent = buildUserAgent(currentAppId, currentPluginVersion, currentVersionOs);
@@ -105,6 +112,32 @@ public class DownloadService extends Worker {
             .build();
     }
 
+    static int httpTimeoutMs() {
+        return httpTimeoutMs;
+    }
+
+    static void applyHttpTimeouts(int timeoutMs) {
+        // OkHttp treats 0 as infinite; keep plugin responseTimeout floor (20s default).
+        int ms = timeoutMs > 0 ? timeoutMs : 20_000;
+        synchronized (HTTP_CLIENT_LOCK) {
+            if (
+                sharedClient.connectTimeoutMillis() == ms &&
+                sharedClient.readTimeoutMillis() == ms &&
+                sharedClient.writeTimeoutMillis() == ms
+            ) {
+                httpTimeoutMs = ms;
+                return;
+            }
+            sharedClient = sharedClient
+                .newBuilder()
+                .connectTimeout(ms, TimeUnit.MILLISECONDS)
+                .readTimeout(ms, TimeUnit.MILLISECONDS)
+                .writeTimeout(ms, TimeUnit.MILLISECONDS)
+                .build();
+            httpTimeoutMs = ms;
+        }
+    }
+
     static int manifestMaxConcurrentFiles() {
         return manifestMaxConcurrentFiles(Runtime.getRuntime().availableProcessors());
     }
@@ -342,10 +375,12 @@ public class DownloadService extends Worker {
             logger.debug("doWork isManifest: " + isManifest);
 
             if (isManifest) {
-                JSONArray manifest = DataManager.getInstance().getAndClearManifest();
+                JSONArray manifest = DataManager.getInstance().getAndClearManifest(id);
                 if (manifest != null) {
                     handleManifestDownload(id, documentsDir, dest, version, sessionKey, publicKey, manifest);
                     return createSuccessResult(dest, version, sessionKey, checksum, true);
+                } else if (isStopped()) {
+                    return createFailureResult("download_cancelled");
                 } else {
                     logger.error("Manifest is null");
                     return createFailureResult("Manifest is null");
@@ -526,8 +561,7 @@ public class DownloadService extends Worker {
                     try {
                         if (tryCopyBuiltinAsset(assets, fileName, targetFile, finalFileHash)) {
                             logger.debug("using builtin asset " + fileName);
-                        } else if (builtinFile.exists() && verifyChecksum(builtinFile, finalFileHash)) {
-                            copyFile(builtinFile, targetFile);
+                        } else if (tryCopyBuiltinFile(builtinFile, targetFile, finalFileHash)) {
                             logger.debug("using builtin file " + fileName);
                         } else if (
                             tryCopyFromCache(cacheFile, targetFile, finalFileHash) ||
@@ -626,9 +660,11 @@ public class DownloadService extends Worker {
             URL u = new URL(url);
             httpConn = (HttpURLConnection) u.openConnection();
 
-            // Set reasonable timeouts
-            httpConn.setConnectTimeout(30000); // 30 seconds
-            httpConn.setReadTimeout(60000); // 60 seconds
+            // Zip can stall longer than a JSON API call; keep a floor so
+            // responseTimeout cannot shrink large-bundle downloads.
+            int zipTimeoutMs = Math.max(httpTimeoutMs, 60_000);
+            httpConn.setConnectTimeout(zipTimeoutMs);
+            httpConn.setReadTimeout(zipTimeoutMs);
 
             // Reading progress file (if exist)
             long downloadedBytes = 0;
@@ -678,7 +714,7 @@ public class DownloadService extends Worker {
                         writer = null;
                     }
 
-                    byte[] buffer = new byte[8192]; // Larger buffer for better performance
+                    byte[] buffer = new byte[CryptoCipher.ioBufferBytes()];
                     int lastNotifiedPercent = 0;
                     int bytesRead;
 
@@ -801,6 +837,10 @@ public class DownloadService extends Worker {
     }
 
     private void copyFile(File source, File dest) throws IOException {
+        copyFileChannel(source, dest);
+    }
+
+    static void copyFileChannel(final File source, final File dest) throws IOException {
         final File parent = dest.getParentFile();
         if (parent != null && !parent.exists() && !parent.mkdirs()) {
             throw new IOException("Failed to create parent directory: " + parent.getAbsolutePath());
@@ -971,33 +1011,19 @@ public class DownloadService extends Worker {
         }
     }
 
-    private boolean verifyChecksum(File file, String expectedHash) {
-        try {
-            String actualHash = calculateFileHash(file);
-            return actualHash.equalsIgnoreCase(expectedHash);
-        } catch (Exception e) {
-            e.printStackTrace();
+    static boolean tryCopyBuiltinFile(final File builtinFile, final File dest, final String expectedHash) {
+        if (builtinFile == null || dest == null || expectedHash == null || expectedHash.isEmpty() || !builtinFile.isFile()) {
             return false;
         }
-    }
-
-    private String calculateFileHash(File file) throws Exception {
-        MessageDigest digest = MessageDigest.getInstance("SHA-256");
-        byte[] byteArray = new byte[1024];
-        int bytesCount = 0;
-
-        try (FileInputStream fis = new FileInputStream(file)) {
-            while ((bytesCount = fis.read(byteArray)) != -1) {
-                digest.update(byteArray, 0, bytesCount);
+        try {
+            if (!expectedHash.equalsIgnoreCase(CryptoCipher.calcChecksum(builtinFile))) {
+                return false;
             }
+            copyFileChannel(builtinFile, dest);
+            return true;
+        } catch (IOException e) {
+            return false;
         }
-
-        byte[] bytes = digest.digest();
-        StringBuilder sb = new StringBuilder();
-        for (byte aByte : bytes) {
-            sb.append(Integer.toString((aByte & 0xff) + 0x100, 16).substring(1));
-        }
-        return sb.toString();
     }
 
     static void decompressBrotli(File input, File output, String fileName) throws IOException {