@capgo/cordova-updater 8.1.1

package/src/android/app/capgo/cordova/updater/CapgoUpdater.java

@@ -0,0 +1,3404 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package app.capgo.cordova.updater;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import androidx.annotation.NonNull;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.work.Constraints;
+import androidx.work.Data;
+import androidx.work.ExistingPeriodicWorkPolicy;
+import androidx.work.ExistingWorkPolicy;
+import androidx.work.ListenableWorker;
+import androidx.work.NetworkType;
+import androidx.work.OneTimeWorkRequest;
+import androidx.work.PeriodicWorkRequest;
+import androidx.work.WorkInfo;
+import androidx.work.WorkManager;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.io.BufferedInputStream;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+import okhttp3.*;
+import okhttp3.HttpUrl;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class CapgoUpdater {
+
+    private final Logger logger;
+
+    private static final String AB = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    private static final SecureRandom rnd = new SecureRandom();
+
+    private static final String INFO_SUFFIX = "_info";
+
+    private static final String FALLBACK_VERSION = "pastVersion";
+    private static final String NEXT_VERSION = "nextVersion";
+    private static final String PREVIEW_FALLBACK_VERSION = "previewFallbackVersion";
+    private static final String PENDING_DELETE_IDS = "pendingDeleteIds";
+    private static final String bundleDirectory = "versions";
+    private static final String TEMP_UNZIP_PREFIX = "capgo_unzip_";
+    private static final long DELETE_PACE_MS = 75L;
+    private final Object deleteLock = new Object();
+    private static final String CAPACITOR_CONFIG_ASSET = "capacitor.config.json";
+    private static final String BACKGROUND_RUNNER_CONFIG_KEY = "BackgroundRunner";
+    private static final String BACKGROUND_RUNNER_WORKER_CLASS = "io.ionic.backgroundrunner.plugin.RunnerWorker";
+
+    public static final String TAG = "Capacitor-updater";
+    public SharedPreferences.Editor editor;
+
+    /** Optional gate run before any download touches disk (e.g. wait for launch cleanup). */
+    public Runnable downloadGate = null;
+    public SharedPreferences prefs;
+
+    public File documentsDir;
+    public File noBackupDir;
+    public Boolean directUpdate = false;
+    public Activity activity;
+    public String pluginVersion = "";
+    public String versionBuild = "";
+    public String versionCode = "";
+    public String versionOs = "";
+    public String CAP_SERVER_PATH = "";
+
+    public String customId = "";
+    public String statsUrl = "";
+    public String channelUrl = "";
+    public String defaultChannel = "";
+    public String appId = "";
+    public volatile boolean previewSession = false;
+    public String publicKey = "";
+    public String deviceID = "";
+    public int timeout = 20000;
+
+    // Cached key ID calculated once from publicKey
+    private String cachedKeyId = "";
+
+    // Temporary 429 block until this epoch ms (Retry-After / rateLimitResetAt). No sticky latch.
+    // Guarded by rateLimitStateLock so concurrent 429s cannot shorten the window or mix metadata.
+    private static final Object rateLimitStateLock = new Object();
+    private static long rateLimitBlockedUntilMs = 0L;
+    private static String rateLimitBlockedError = "too_many_requests";
+    private static String rateLimitBlockedMessage = "Too many requests";
+
+    // Flag to track if we've already sent the rate limit statistic - prevents infinite loop.
+    // Released again when the send fails, so a later 429 can retry it.
+    private static boolean rateLimitStatisticSent = false;
+
+    // Upper bound for a client-side 429 block, so a bogus Retry-After cannot block the app for days.
+    private static final long MAX_RATE_LIMIT_WINDOW_MS = 24 * 60 * 60 * 1000L;
+
+    // Stats batching - queue events and send max once per second
+    private final List<QueuedStatsEvent> statsQueue = new CopyOnWriteArrayList<>();
+    private final List<QueuedStatsEvent> statsInFlight = new ArrayList<>();
+    private final Object pendingStatsPersistLock = new Object();
+    private final ScheduledExecutorService statsScheduler = Executors.newSingleThreadScheduledExecutor();
+    private ScheduledFuture<?> statsFlushTask = null;
+    private final AtomicBoolean statsFlushInFlight = new AtomicBoolean(false);
+    private final AtomicBoolean statsStopped = new AtomicBoolean(false);
+    private static final long STATS_FLUSH_INTERVAL_MS = 1000;
+    private static final String PENDING_STATS_FILE = "capgo_pending_stats.json";
+    private static final int MAX_PENDING_STATS = 200;
+
+    private static final class QueuedStatsEvent {
+
+        private final JSONObject event;
+        private final Runnable onSent;
+
+        private QueuedStatsEvent(final JSONObject event, final Runnable onSent) {
+            this.event = event;
+            this.onSent = onSent;
+        }
+    }
+
+    private final Map<String, CompletableFuture<BundleInfo>> downloadFutures = new ConcurrentHashMap<>();
+    private final ExecutorService io = Executors.newSingleThreadExecutor();
+
+    public CapgoUpdater(Logger logger) {
+        this.logger = logger;
+    }
+
+    private final FilenameFilter filter = (f, name) -> {
+        // ignore directories generated by mac os x
+        return !name.startsWith("__MACOSX") && !name.startsWith(".") && !name.startsWith(".DS_Store");
+    };
+
+    private boolean isProd() {
+        try {
+            if (activity == null) {
+                return true; // Default to production if no activity context
+            }
+            return (activity.getApplicationInfo().flags & android.content.pm.ApplicationInfo.FLAG_DEBUGGABLE) == 0;
+        } catch (Exception e) {
+            return true; // Default to production if we can't determine
+        }
+    }
+
+    static String installSourceForInstallerPackage(final String installerPackageName) {
+        if (installerPackageName == null || installerPackageName.trim().isEmpty()) {
+            return "";
+        }
+
+        switch (installerPackageName) {
+            case "com.android.vending":
+                // Android exposes the Google Play installer package, but not whether the app came from production, alpha, beta, or internal testing.
+                return "google_play";
+            case "com.amazon.venezia":
+                return "amazon_appstore";
+            case "com.sec.android.app.samsungapps":
+                return "samsung_galaxy_store";
+            case "com.huawei.appmarket":
+                return "huawei_appgallery";
+            default:
+                return "";
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+    private String getInstallSource() {
+        if (activity == null) {
+            return "";
+        }
+
+        try {
+            PackageManager packageManager = activity.getPackageManager();
+            String packageName = activity.getPackageName();
+            String installerPackageName;
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                android.content.pm.InstallSourceInfo installSourceInfo = packageManager.getInstallSourceInfo(packageName);
+                installerPackageName = installSourceInfo.getInstallingPackageName();
+                if (installerPackageName == null || installerPackageName.trim().isEmpty()) {
+                    installerPackageName = installSourceInfo.getInitiatingPackageName();
+                }
+            } else {
+                installerPackageName = packageManager.getInstallerPackageName(packageName);
+            }
+            return installSourceForInstallerPackage(installerPackageName);
+        } catch (Exception e) {
+            return "";
+        }
+    }
+
+    private boolean isEmulator() {
+        final String brand = String.valueOf(Build.BRAND);
+        final String device = String.valueOf(Build.DEVICE);
+        final String fingerprint = String.valueOf(Build.FINGERPRINT);
+        final String hardware = String.valueOf(Build.HARDWARE);
+        final String model = String.valueOf(Build.MODEL);
+        final String manufacturer = String.valueOf(Build.MANUFACTURER);
+        final String product = String.valueOf(Build.PRODUCT);
+
+        return (
+            (brand.startsWith("generic") && device.startsWith("generic")) ||
+            fingerprint.startsWith("generic") ||
+            fingerprint.startsWith("unknown") ||
+            hardware.contains("goldfish") ||
+            hardware.contains("ranchu") ||
+            model.contains("google_sdk") ||
+            model.contains("Emulator") ||
+            model.contains("Android SDK built for x86") ||
+            manufacturer.contains("Genymotion") ||
+            product.contains("sdk_google") ||
+            product.contains("google_sdk") ||
+            product.contains("sdk") ||
+            product.contains("sdk_x86") ||
+            product.contains("sdk_gphone64_arm64") ||
+            product.contains("vbox86p") ||
+            product.contains("emulator") ||
+            product.contains("simulator")
+        );
+    }
+
+    private int calcTotalPercent(final int percent, final int min, final int max) {
+        return (percent * (max - min)) / 100 + min;
+    }
+
+    void notifyDownload(final String id, final int percent) {}
+
+    void directUpdateFinish(final BundleInfo latest) {}
+
+    void notifyListeners(final String id, final Map<String, Object> res) {}
+
+    public String randomString() {
+        final StringBuilder sb = new StringBuilder(10);
+        for (int i = 0; i < 10; i++) sb.append(AB.charAt(rnd.nextInt(AB.length())));
+        return sb.toString();
+    }
+
+    public void setPublicKey(String publicKey) {
+        // Empty string means no encryption - proceed normally
+        if (publicKey == null || publicKey.isEmpty()) {
+            this.publicKey = "";
+            this.cachedKeyId = "";
+            return;
+        }
+
+        // Non-empty: must be a valid RSA key or crash
+        try {
+            CryptoCipher.stringToPublicKey(publicKey);
+        } catch (Exception e) {
+            throw new RuntimeException(
+                "Invalid public key in capacitor.config.json: failed to parse RSA key. Remove the key or provide a valid PEM-formatted RSA public key.",
+                e
+            );
+        }
+
+        this.publicKey = publicKey;
+        this.cachedKeyId = CryptoCipher.calcKeyId(publicKey);
+    }
+
+    static File resolvePathInsideDirectory(final File baseDirectory, final String relativePath) throws IOException {
+        if (relativePath == null || relativePath.isEmpty()) {
+            throw new IOException("Invalid empty path");
+        }
+        if (relativePath.contains("\\") || relativePath.indexOf('\0') >= 0) {
+            throw new IOException("Invalid path separator");
+        }
+        if (new File(relativePath).isAbsolute()) {
+            throw new IOException("Absolute paths are not allowed");
+        }
+
+        final File canonicalBase = baseDirectory.getCanonicalFile();
+        final File canonicalTarget = new File(canonicalBase, relativePath).getCanonicalFile();
+        final String basePath = canonicalBase.getPath();
+        final String targetPath = canonicalTarget.getPath();
+        final String normalizedBasePath = basePath.endsWith(File.separator) ? basePath : basePath + File.separator;
+
+        if (!targetPath.equals(basePath) && !targetPath.startsWith(normalizedBasePath)) {
+            throw new IOException("Path escapes base directory: " + relativePath);
+        }
+
+        return canonicalTarget;
+    }
+
+    public String getKeyId() {
+        return this.cachedKeyId;
+    }
+
+    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 byte[] buffer = new byte[bufferSize];
+            final long lengthTotal = zipFile.length();
+            long lengthRead = bufferSize;
+            int percent = 0;
+            this.notifyDownload(id, 75);
+
+            ZipEntry entry;
+            while ((entry = zis.getNextEntry()) != null) {
+                final File file;
+                try {
+                    file = resolvePathInsideDirectory(targetDirectory, entry.getName());
+                } catch (IOException e) {
+                    if (entry.getName().contains("\\")) {
+                        logger.error("Unzip failed: Windows path not supported");
+                        logger.debug("Invalid path: " + entry.getName());
+                        this.sendStats("windows_path_fail");
+                    } else {
+                        this.sendStats("canonical_path_fail");
+                    }
+                    throw e;
+                }
+                final File dir = entry.isDirectory() ? file : file.getParentFile();
+
+                assert dir != null;
+                if (!dir.isDirectory() && !dir.mkdirs()) {
+                    this.sendStats("directory_path_fail");
+                    throw new FileNotFoundException("Failed to ensure directory: " + dir.getAbsolutePath());
+                }
+
+                if (entry.isDirectory()) {
+                    continue;
+                }
+
+                try (final FileOutputStream outputStream = new FileOutputStream(file)) {
+                    while ((count = zis.read(buffer)) != -1) outputStream.write(buffer, 0, count);
+                }
+
+                final int newPercent = (int) ((lengthRead / (float) lengthTotal) * 100);
+                if (lengthTotal > 1 && newPercent != percent) {
+                    percent = newPercent;
+                    this.notifyDownload(id, this.calcTotalPercent(percent, 75, 90));
+                }
+
+                lengthRead += entry.getCompressedSize();
+            }
+            return targetDirectory;
+        } catch (IOException e) {
+            this.sendStats("unzip_fail");
+            throw new IOException("Failed to unzip: " + zipFile.getPath());
+        }
+    }
+
+    private void flattenAssets(final File sourceFile, final String dest) throws IOException {
+        if (!sourceFile.exists()) {
+            throw new FileNotFoundException("Source file not found: " + sourceFile.getPath());
+        }
+        final File destinationFile = new File(this.documentsDir, dest);
+        Objects.requireNonNull(destinationFile.getParentFile()).mkdirs();
+        final String[] entries = sourceFile.list(this.filter);
+        if (entries == null || entries.length == 0) {
+            throw new IOException("Source file was not a directory or was empty: " + sourceFile.getPath());
+        }
+        if (entries.length == 1 && !"index.html".equals(entries[0])) {
+            final File child = new File(sourceFile, entries[0]);
+            if (!child.renameTo(destinationFile)) {
+                throw new IOException("Failed to move bundle contents: " + child.getPath() + " -> " + destinationFile.getPath());
+            }
+        } else {
+            if (!sourceFile.renameTo(destinationFile)) {
+                throw new IOException("Failed to move bundle contents: " + sourceFile.getPath() + " -> " + destinationFile.getPath());
+            }
+        }
+        sourceFile.delete();
+    }
+
+    private void cacheBundleFilesAsync(final String id) {
+        io.execute(() -> cacheBundleFiles(id));
+    }
+
+    void cacheBundleFiles(final String id) {
+        if (this.activity == null) {
+            logger.debug("Skip delta cache population: activity is null");
+            return;
+        }
+
+        final File bundleDir = this.getBundleDirectory(id);
+        if (!bundleDir.exists()) {
+            logger.debug("Skip delta cache population: bundle dir missing");
+            return;
+        }
+
+        final File cacheDir = new File(this.activity.getCacheDir(), "capgo_downloads");
+        if (cacheDir.exists() && !cacheDir.isDirectory()) {
+            logger.debug("Skip delta cache population: cache dir is not a directory");
+            return;
+        }
+        if (!cacheDir.exists() && !cacheDir.mkdirs()) {
+            logger.debug("Skip delta cache population: failed to create cache dir");
+            return;
+        }
+
+        final File builtinFolder = new File(this.activity.getFilesDir(), "public");
+
+        final List<File> files = new ArrayList<>();
+        collectFiles(bundleDir, files);
+        final int bundlePrefixLength = bundleDir.getAbsolutePath().length() + 1;
+        for (File file : files) {
+            final String checksum = CryptoCipher.calcChecksum(file);
+            if (checksum.isEmpty()) {
+                continue;
+            }
+
+            // Builtin is already a permanent reuse source (see isManifestEntryAvailableLocally),
+            // so there's no need to also duplicate a byte-identical file into the delta cache.
+            final String relativePath = file.getAbsolutePath().substring(bundlePrefixLength);
+            final File builtinFile = new File(builtinFolder, relativePath);
+            if (verifyChecksum(builtinFile, checksum)) {
+                continue;
+            }
+
+            final String cacheName = checksum + "_" + file.getName();
+            final File cacheFile = new File(cacheDir, cacheName);
+            if (cacheFile.exists()) {
+                continue;
+            }
+            try {
+                copyFileAtomically(file, cacheFile);
+            } catch (IOException e) {
+                logger.debug("Delta cache copy failed: " + file.getPath());
+            }
+        }
+    }
+
+    private void collectFiles(final File dir, final List<File> files) {
+        final File[] entries = dir.listFiles();
+        if (entries == null) {
+            return;
+        }
+        for (File entry : entries) {
+            if (!this.filter.accept(dir, entry.getName())) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                collectFiles(entry, files);
+            } else if (entry.isFile()) {
+                files.add(entry);
+            }
+        }
+    }
+
+    private void copyFile(final File source, final File dest) throws IOException {
+        try (final FileInputStream input = new FileInputStream(source); final FileOutputStream output = new FileOutputStream(dest)) {
+            final byte[] buffer = new byte[CryptoCipher.copyBufferBytes()];
+            int length;
+            while ((length = input.read(buffer)) != -1) {
+                output.write(buffer, 0, length);
+            }
+        }
+    }
+
+    private boolean verifyChecksum(final File file, final String expectedHash) {
+        if (expectedHash == null || expectedHash.isEmpty() || file == null || !file.exists()) {
+            return false;
+        }
+        final String actualHash = CryptoCipher.calcChecksum(file);
+        return expectedHash.equalsIgnoreCase(actualHash);
+    }
+
+    private String resolveManifestFileHash(final JSONObject entry, final String sessionKey) {
+        String fileHash = entry.optString("file_hash", "");
+        if (fileHash.isEmpty()) {
+            return "";
+        }
+        if (this.publicKey != null && !this.publicKey.isEmpty() && sessionKey != null && !sessionKey.isEmpty()) {
+            try {
+                fileHash = CryptoCipher.decryptChecksum(fileHash, this.publicKey);
+            } catch (Exception e) {
+                logger.error("Checksum decryption failed while checking missing manifest files");
+                logger.debug("File: " + entry.optString("file_name", "unknown") + ", Error: " + e.getMessage());
+                return "";
+            }
+        }
+        return fileHash;
+    }
+
+    private boolean isManifestEntryAvailableLocally(final JSONObject entry, final String sessionKey) {
+        final String fileName = entry.optString("file_name", "");
+        final String fileHash = resolveManifestFileHash(entry, sessionKey);
+        if (fileName.isEmpty() || fileHash.isEmpty() || this.activity == null) {
+            return false;
+        }
+
+        if (DownloadService.builtinAssetMatches(this.activity.getAssets(), fileName, fileHash)) {
+            return true;
+        }
+
+        try {
+            final File builtinFile = DownloadService.resolveManifestBuiltinFile(new File(this.activity.getFilesDir(), "public"), fileName);
+            if (verifyChecksum(builtinFile, fileHash)) {
+                return true;
+            }
+        } catch (IOException ignored) {
+            // Invalid path; fall through to cache lookup.
+        }
+
+        final boolean isBrotli = fileName.endsWith(".br");
+        final String fileNameWithoutPath = new File(fileName).getName();
+        final String cacheBaseName = isBrotli ? fileNameWithoutPath.substring(0, fileNameWithoutPath.length() - 3) : fileNameWithoutPath;
+        if (isSafeCacheHash(fileHash)) {
+            final File cacheFolder = new File(this.activity.getCacheDir(), "capgo_downloads");
+            final File cacheFile = new File(cacheFolder, fileHash + "_" + cacheBaseName);
+            // Cache files are named `{hash}_{filename}` and were checksum-verified
+            // when written. Re-hashing every hit re-reads the whole bundle and
+            // OOMs/janks low-RAM devices during getMissing / delta apply.
+            if (isReusableCacheFile(cacheFile, fileHash)) {
+                return true;
+            }
+
+            if (isBrotli) {
+                final File legacyCacheFile = new File(cacheFolder, fileHash + "_" + fileNameWithoutPath);
+                return isReusableCacheFile(legacyCacheFile, fileHash);
+            }
+        }
+
+        return false;
+    }
+
+    static final String EMPTY_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+
+    static boolean isSafeCacheHash(final String hash) {
+        if (hash == null) {
+            return false;
+        }
+        final int len = hash.length();
+        if (len != 64 && len != 8) {
+            return false;
+        }
+        for (int i = 0; i < len; i++) {
+            final char c = hash.charAt(i);
+            if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // SHA-256 hash-named cache files were verified when written. Existence is
+    // enough for non-empty files; empty files are reused only for the empty SHA-256.
+    // CRC32 (8 hex) is too collision-prone to trust without a re-read.
+    static boolean isReusableCacheFile(final File file, final String expectedHash) {
+        if (file == null || !file.isFile() || !isSafeCacheHash(expectedHash) || expectedHash.length() != 64) {
+            return false;
+        }
+        final long length = file.length();
+        if (length > 0) {
+            return true;
+        }
+        return length == 0 && EMPTY_SHA256.equalsIgnoreCase(expectedHash);
+    }
+
+    public JSONArray getMissingBundleFiles(final JSONArray manifest, final String sessionKey) throws JSONException {
+        final JSONArray missing = new JSONArray();
+        for (int i = 0; i < manifest.length(); i++) {
+            final JSONObject entry = manifest.getJSONObject(i);
+            if (!isManifestEntryAvailableLocally(entry, sessionKey)) {
+                missing.put(entry);
+            }
+        }
+        return missing;
+    }
+
+    public JSONObject missingBundleFilesResult(final JSONArray manifest, final String sessionKey) throws JSONException {
+        final JSONArray missing = getMissingBundleFiles(manifest, sessionKey);
+        final JSONObject ret = new JSONObject();
+        ret.put("missing", missing);
+        ret.put("total", manifest.length());
+        ret.put("missingCount", missing.length());
+        ret.put("reusableCount", manifest.length() - missing.length());
+        return ret;
+    }
+
+    private String manifestSizeUrl(final String updateUrl) {
+        HttpUrl parsed = HttpUrl.parse(updateUrl);
+        if (parsed == null) {
+            return updateUrl;
+        }
+        return parsed.newBuilder().addPathSegment("manifest_size").query(null).build().toString();
+    }
+
+    private JSONObject unavailableBundleSizeResult(final JSONArray manifest, final String error) throws JSONException {
+        final JSONObject ret = new JSONObject();
+        final JSONArray files = new JSONArray();
+        for (int i = 0; i < manifest.length(); i++) {
+            final JSONObject entry = new JSONObject(manifest.getJSONObject(i).toString());
+            entry.put("error", error);
+            files.put(entry);
+        }
+        ret.put("totalSize", 0);
+        ret.put("knownFiles", 0);
+        ret.put("unknownFiles", manifest.length());
+        ret.put("files", files);
+        return ret;
+    }
+
+    public JSONObject getBundleDownloadSize(final String updateUrl, final String version, final JSONArray manifest) throws JSONException {
+        if (manifest.length() == 0) {
+            final JSONObject ret = new JSONObject();
+            ret.put("totalSize", 0);
+            ret.put("knownFiles", 0);
+            ret.put("unknownFiles", 0);
+            ret.put("files", new JSONArray());
+            return ret;
+        }
+
+        final JSONObject json = this.createInfoObject();
+        json.put("version", version != null ? version : "");
+        json.put("manifest", manifest);
+
+        Request request = new Request.Builder()
+            .url(manifestSizeUrl(updateUrl))
+            .post(RequestBody.create(json.toString(), MediaType.get("application/json; charset=utf-8")))
+            .build();
+
+        try (Response response = DownloadService.sharedClient.newCall(request).execute()) {
+            final ResponseBody responseBody = response.body();
+            final String responseData = responseBody != null ? responseBody.string() : "";
+            if (!response.isSuccessful() || responseData.isEmpty()) {
+                return unavailableBundleSizeResult(manifest, "response_error");
+            }
+            return new JSONObject(responseData);
+        } catch (IOException e) {
+            logger.error("Error getting bundle download size");
+            logger.debug("Error: " + e.getMessage());
+            return unavailableBundleSizeResult(manifest, "response_error");
+        }
+    }
+
+    private void observeWorkProgress(Context context, String id, boolean setNext) {
+        if (!(context instanceof LifecycleOwner)) {
+            logger.error("Context is not a LifecycleOwner, cannot observe work progress");
+            return;
+        }
+
+        activity.runOnUiThread(() -> {
+            WorkManager.getInstance(context)
+                .getWorkInfosByTagLiveData(id)
+                .observe((LifecycleOwner) context, (workInfos) -> {
+                    if (workInfos == null || workInfos.isEmpty()) return;
+
+                    WorkInfo workInfo = workInfos.get(0);
+                    Data progress = workInfo.getProgress();
+
+                    switch (workInfo.getState()) {
+                        case RUNNING:
+                            int percent = progress.getInt(DownloadService.PERCENT, 0);
+                            notifyDownload(id, percent);
+                            break;
+                        case SUCCEEDED:
+                            logger.info("Download succeeded: " + workInfo.getState());
+                            Data outputData = workInfo.getOutputData();
+                            String dest = outputData.getString(DownloadService.FILEDEST);
+                            String version = outputData.getString(DownloadService.VERSION);
+                            String sessionKey = outputData.getString(DownloadService.SESSIONKEY);
+                            String checksum = outputData.getString(DownloadService.CHECKSUM);
+                            boolean isManifest = outputData.getBoolean(DownloadService.IS_MANIFEST, false);
+
+                            io.execute(() -> {
+                                boolean success = finishDownload(id, dest, version, sessionKey, checksum, setNext, isManifest);
+                                BundleInfo resultBundle;
+                                if (!success) {
+                                    logger.error("Finish download failed");
+                                    logger.debug("Version: " + version);
+                                    resultBundle = new BundleInfo(
+                                        id,
+                                        version,
+                                        BundleStatus.ERROR,
+                                        new Date(System.currentTimeMillis()),
+                                        ""
+                                    );
+                                    saveBundleInfo(id, resultBundle);
+                                    // Cleanup download tracking
+                                    DownloadWorkerManager.cancelBundleDownload(activity, id, version);
+                                    Map<String, Object> ret = new HashMap<>();
+                                    ret.put("version", version);
+                                    ret.put("error", "finish_download_fail");
+                                    sendStats("finish_download_fail", version);
+                                    notifyListeners("downloadFailed", ret);
+                                } else {
+                                    // Successful download - cleanup tracking
+                                    DownloadWorkerManager.cancelBundleDownload(activity, id, version);
+                                    resultBundle = getBundleInfo(id);
+                                }
+
+                                // Complete the future if it exists
+                                CompletableFuture<BundleInfo> future = downloadFutures.remove(id);
+                                if (future != null) {
+                                    future.complete(resultBundle);
+                                }
+                            });
+                            break;
+                        case FAILED:
+                            Data failedData = workInfo.getOutputData();
+                            String error = failedData.getString(DownloadService.ERROR);
+                            logger.error("Download failed");
+                            logger.debug("Error: " + error + ", State: " + workInfo.getState());
+                            String failedVersion = failedData.getString(DownloadService.VERSION);
+
+                            io.execute(() -> {
+                                BundleInfo failedBundle = new BundleInfo(
+                                    id,
+                                    failedVersion,
+                                    BundleStatus.ERROR,
+                                    new Date(System.currentTimeMillis()),
+                                    ""
+                                );
+                                saveBundleInfo(id, failedBundle);
+                                // Cleanup download tracking for failed downloads
+                                DownloadWorkerManager.cancelBundleDownload(activity, id, failedVersion);
+                                Map<String, Object> ret = new HashMap<>();
+                                ret.put("version", failedVersion);
+                                if ("low_mem_fail".equals(error)) {
+                                    sendStats("low_mem_fail", failedVersion);
+                                }
+                                if ("insufficient_disk_space".equals(error)) {
+                                    sendStats("insufficient_disk_space", failedVersion);
+                                }
+                                ret.put("error", error != null ? error : "download_fail");
+                                sendStats("download_fail", failedVersion);
+                                notifyListeners("downloadFailed", ret);
+
+                                // Complete the future with error status
+                                CompletableFuture<BundleInfo> failedFuture = downloadFutures.remove(id);
+                                if (failedFuture != null) {
+                                    failedFuture.complete(failedBundle);
+                                }
+                            });
+                            break;
+                        case CANCELLED:
+                            DataManager.getInstance().clearManifest(id);
+                            CompletableFuture<BundleInfo> cancelledFuture = downloadFutures.remove(id);
+                            if (cancelledFuture != null) {
+                                cancelledFuture.cancel(true);
+                            }
+                            break;
+                    }
+                });
+        });
+    }
+
+    private void download(
+        final String id,
+        final String url,
+        final String dest,
+        final String version,
+        final String sessionKey,
+        final String checksum,
+        final JSONArray manifest,
+        final boolean setNext
+    ) {
+        if (this.activity == null) {
+            logger.error("Activity is null, cannot observe work progress");
+            return;
+        }
+        observeWorkProgress(this.activity, id, setNext);
+
+        if (manifest != null) {
+            DataManager.getInstance().setManifest(id, manifest);
+        }
+
+        DownloadWorkerManager.enqueueDownload(
+            this.activity,
+            url,
+            id,
+            this.documentsDir.getAbsolutePath(),
+            dest,
+            version,
+            sessionKey,
+            checksum,
+            this.publicKey,
+            manifest != null,
+            this.isEmulator(),
+            this.appId,
+            this.pluginVersion,
+            this.isProd(),
+            this.getInstallSource(),
+            this.statsUrl,
+            this.deviceID,
+            this.versionBuild,
+            this.versionCode,
+            this.versionOs,
+            this.customId,
+            this.defaultChannel
+        );
+    }
+
+    public Boolean finishDownload(
+        String id,
+        String dest,
+        String version,
+        String sessionKey,
+        String checksumRes,
+        Boolean setNext,
+        Boolean isManifest
+    ) {
+        File downloaded = null;
+        File extractedDir = null;
+        String checksum = "";
+
+        try {
+            this.notifyDownload(id, 71);
+            downloaded = new File(this.documentsDir, dest);
+
+            if (!isManifest) {
+                String checksumDecrypted = Objects.requireNonNullElse(checksumRes, "");
+
+                // If public key is present but no checksum provided, refuse installation
+                if (!this.publicKey.isEmpty() && checksumDecrypted.isEmpty()) {
+                    logger.error("Public key present but no checksum provided");
+                    this.sendStats("checksum_required");
+                    throw new IOException("Checksum required when public key is present: " + id);
+                }
+
+                if (!sessionKey.isEmpty()) {
+                    CryptoCipher.decryptFile(downloaded, publicKey, sessionKey);
+                    checksumDecrypted = CryptoCipher.decryptChecksum(checksumRes, publicKey);
+                    checksum = CryptoCipher.calcChecksum(downloaded);
+                } else {
+                    checksum = CryptoCipher.calcChecksum(downloaded);
+                }
+                CryptoCipher.logChecksumInfo("Calculated checksum", checksum);
+                CryptoCipher.logChecksumInfo("Expected checksum", checksumDecrypted);
+                if ((!checksumDecrypted.isEmpty() || !this.publicKey.isEmpty()) && !checksumDecrypted.equals(checksum)) {
+                    logger.error("Checksum mismatch");
+                    logger.debug("Expected: " + checksumDecrypted + ", Got: " + checksum);
+                    this.sendStats("checksum_fail");
+                    throw new IOException("Checksum failed: " + id);
+                }
+            }
+            // Remove the decryption for manifest downloads
+        } catch (Exception e) {
+            if (!isManifest) {
+                safeDelete(downloaded);
+            }
+            final Boolean res = this.delete(id);
+            if (!res) {
+                logger.info("Failed to cleanup after error");
+                logger.debug("Version: " + version);
+            }
+
+            final Map<String, Object> ret = new HashMap<>();
+            ret.put("version", version);
+
+            CapgoUpdater.this.notifyListeners("downloadFailed", ret);
+            CapgoUpdater.this.sendStats("download_fail");
+            return false;
+        }
+
+        try {
+            if (!isManifest) {
+                extractedDir = this.unzip(id, downloaded, TEMP_UNZIP_PREFIX + this.randomString());
+                this.notifyDownload(id, 91);
+                final String idName = bundleDirectory + "/" + id;
+                this.flattenAssets(extractedDir, idName);
+                this.cacheBundleFilesAsync(id);
+            } else {
+                this.notifyDownload(id, 91);
+                final String idName = bundleDirectory + "/" + id;
+                this.flattenAssets(downloaded, idName);
+                downloaded.delete();
+            }
+            // Remove old bundle info and set new one
+            this.saveBundleInfo(id, null);
+            BundleInfo next = new BundleInfo(id, version, BundleStatus.PENDING, new Date(System.currentTimeMillis()), checksum);
+            this.saveBundleInfo(id, next);
+            this.notifyDownload(id, 100);
+
+            final Map<String, Object> ret = new HashMap<>();
+            ret.put("bundle", InternalUtils.mapToJSONObject(next.toJSONMap()));
+            logger.info("updateAvailable: " + ret);
+            CapgoUpdater.this.notifyListeners("updateAvailable", ret);
+            logger.info("setNext: " + setNext);
+            if (setNext) {
+                if (this.previewSession) {
+                    logger.info("Preview session is active, skipping automatic install of downloaded bundle");
+                    this.directUpdate = false;
+                } else if (this.directUpdate) {
+                    logger.info("directUpdate: " + this.directUpdate);
+                    CapgoUpdater.this.directUpdateFinish(next);
+                    this.directUpdate = false;
+                } else {
+                    logger.info("directUpdate: " + this.directUpdate);
+                    this.setNextBundle(next.getId());
+                }
+            }
+        } catch (IOException e) {
+            if (!isManifest) {
+                safeDelete(extractedDir);
+                safeDelete(downloaded);
+            }
+            e.printStackTrace();
+            final Map<String, Object> ret = new HashMap<>();
+            ret.put("version", version);
+            CapgoUpdater.this.notifyListeners("downloadFailed", ret);
+            CapgoUpdater.this.sendStats("download_fail");
+            return false;
+        }
+        if (!isManifest) {
+            safeDelete(downloaded);
+        }
+        return true;
+    }
+
+    private void deleteDirectory(final File file) throws IOException {
+        deleteDirectory(file, null);
+    }
+
+    private void deleteDirectory(final File file, final Thread threadToCheck) throws IOException {
+        // Check if thread was interrupted (cancelled)
+        if (threadToCheck != null && threadToCheck.isInterrupted()) {
+            throw new IOException("Operation cancelled");
+        }
+
+        if (file.isDirectory()) {
+            final File[] entries = file.listFiles();
+            if (entries != null) {
+                for (final File entry : entries) {
+                    this.deleteDirectory(entry, threadToCheck);
+                }
+            }
+        }
+        if (!file.delete()) {
+            throw new IOException("Failed to delete: " + file);
+        }
+    }
+
+    public void cleanupDeltaCache() {
+        cleanupDeltaCache(null);
+    }
+
+    public void cleanupDeltaCache(final Thread threadToCheck) {
+        if (this.activity == null) {
+            logger.warn("Activity is null, skipping delta cache cleanup");
+            return;
+        }
+        final File cacheFolder = new File(this.activity.getCacheDir(), "capgo_downloads");
+        if (!cacheFolder.exists()) {
+            return;
+        }
+        try {
+            this.deleteDirectory(cacheFolder, threadToCheck);
+            logger.info("Cleaned up delta cache folder");
+        } catch (IOException e) {
+            logger.error("Failed to cleanup delta cache");
+            logger.debug("Error: " + e.getMessage());
+        }
+    }
+
+    public void cleanupDownloadDirectories(final Set<String> allowedIds) {
+        cleanupDownloadDirectories(allowedIds, null);
+    }
+
+    public void cleanupDownloadDirectories(final Set<String> allowedIds, final Thread threadToCheck) {
+        if (this.documentsDir == null) {
+            logger.warn("Documents directory is null, skipping download cleanup");
+            return;
+        }
+
+        final File bundleRoot = new File(this.documentsDir, bundleDirectory);
+        if (!bundleRoot.exists() || !bundleRoot.isDirectory()) {
+            return;
+        }
+
+        final File[] entries = bundleRoot.listFiles();
+        if (entries != null) {
+            for (final File entry : entries) {
+                // Check if thread was interrupted (cancelled)
+                if (threadToCheck != null && threadToCheck.isInterrupted()) {
+                    logger.warn("cleanupDownloadDirectories was cancelled");
+                    return;
+                }
+
+                if (!entry.isDirectory()) {
+                    continue;
+                }
+
+                final String id = entry.getName();
+
+                if (allowedIds != null && allowedIds.contains(id)) {
+                    continue;
+                }
+
+                try {
+                    this.deleteDirectory(entry, threadToCheck);
+                    if (entry.exists()) {
+                        logger.error("Orphan bundle directory still present after delete");
+                        logger.debug("Bundle ID: " + id);
+                        continue;
+                    }
+                    this.removeBundleInfo(id);
+                    logger.info("Deleted orphan bundle directory");
+                    logger.debug("Bundle ID: " + id);
+                } catch (IOException e) {
+                    logger.error("Failed to delete orphan bundle directory");
+                    logger.debug("Bundle ID: " + id + ", Error: " + e.getMessage());
+                }
+            }
+        }
+    }
+
+    public Set<String> allowedBundleIdsForCleanup() {
+        final Set<String> allowedIds = new HashSet<>();
+        for (final BundleInfo info : this.list(true)) {
+            if (info == null || info.getId() == null || info.getId().isEmpty()) {
+                continue;
+            }
+            // DELETED tombstones must not protect leftover folders.
+            // DELETING stays protected so drainPendingDeletes owns the removal.
+            if (info.isDeleted()) {
+                continue;
+            }
+            allowedIds.add(info.getId());
+        }
+        final String currentId = this.getCurrentBundleId();
+        if (currentId != null && !currentId.isEmpty()) {
+            allowedIds.add(currentId);
+        }
+        final BundleInfo fallback = this.getFallbackBundle();
+        if (fallback != null && fallback.getId() != null && !fallback.getId().isEmpty() && !fallback.isDeleting()) {
+            allowedIds.add(fallback.getId());
+        }
+        final BundleInfo next = this.getNextBundle();
+        if (next != null && next.getId() != null && !next.getId().isEmpty() && !next.isDeleting()) {
+            allowedIds.add(next.getId());
+        }
+        final BundleInfo previewFallback = this.getPreviewFallbackBundle();
+        if (
+            previewFallback != null &&
+            previewFallback.getId() != null &&
+            !previewFallback.getId().isEmpty() &&
+            !previewFallback.isDeleting()
+        ) {
+            allowedIds.add(previewFallback.getId());
+        }
+        return allowedIds;
+    }
+
+    public void cleanupOrphanedTempFolders(final Thread threadToCheck) {
+        if (this.documentsDir == null) {
+            logger.warn("Documents directory is null, skipping temp folder cleanup");
+            return;
+        }
+
+        final File[] entries = this.documentsDir.listFiles();
+        if (entries == null) {
+            return;
+        }
+
+        for (final File entry : entries) {
+            // Check if thread was interrupted (cancelled)
+            if (threadToCheck != null && threadToCheck.isInterrupted()) {
+                logger.warn("cleanupOrphanedTempFolders was cancelled");
+                return;
+            }
+
+            if (!entry.isDirectory()) {
+                continue;
+            }
+
+            final String folderName = entry.getName();
+
+            // Only delete folders with the temp unzip prefix
+            if (!folderName.startsWith(TEMP_UNZIP_PREFIX)) {
+                continue;
+            }
+
+            try {
+                this.deleteDirectory(entry, threadToCheck);
+                logger.info("Deleted orphaned temp unzip folder");
+                logger.debug("Folder: " + folderName);
+            } catch (IOException e) {
+                logger.error("Failed to delete orphaned temp folder");
+                logger.debug("Folder: " + folderName + ", Error: " + e.getMessage());
+            }
+        }
+    }
+
+    private void safeDelete(final File target) {
+        if (target == null || !target.exists()) {
+            return;
+        }
+        try {
+            if (target.isDirectory()) {
+                this.deleteDirectory(target);
+            } else if (!target.delete()) {
+                logger.warn("Failed to delete file: " + target.getAbsolutePath());
+            }
+        } catch (IOException cleanupError) {
+            logger.warn("Cleanup failed for " + target.getAbsolutePath() + ": " + cleanupError.getMessage());
+        }
+    }
+
+    private void setCurrentBundle(final File bundle) {
+        this.resetBackgroundRunnerWorkForBundleSwitch(bundle);
+        this.editor.putString(this.CAP_SERVER_PATH, bundle.getPath());
+        logger.info("Current bundle set to: " + bundle);
+        this.editor.commit();
+    }
+
+    static boolean shouldResetForForeignBundle(final String bundlePath, final boolean isBuiltin, final boolean hasStoredBundleInfo) {
+        return bundlePath != null && !bundlePath.trim().isEmpty() && !isBuiltin && !hasStoredBundleInfo;
+    }
+
+    static final class BackgroundRunnerWorkConfig {
+
+        final String label;
+        final String src;
+        final String event;
+        final boolean autoStart;
+        final boolean repeat;
+        final int interval;
+
+        BackgroundRunnerWorkConfig(
+            final String label,
+            final String src,
+            final String event,
+            final boolean autoStart,
+            final boolean repeat,
+            final int interval
+        ) {
+            this.label = label;
+            this.src = src;
+            this.event = event;
+            this.autoStart = autoStart;
+            this.repeat = repeat;
+            this.interval = interval;
+        }
+    }
+
+    static BackgroundRunnerWorkConfig getBackgroundRunnerWorkConfigFromConfig(final String configJson) {
+        if (configJson == null || configJson.trim().isEmpty()) {
+            return null;
+        }
+
+        try {
+            final JSONObject config = new JSONObject(configJson);
+            final JSONObject plugins = config.optJSONObject("plugins");
+            if (plugins == null) {
+                return null;
+            }
+
+            final JSONObject backgroundRunner = plugins.optJSONObject(BACKGROUND_RUNNER_CONFIG_KEY);
+            if (backgroundRunner == null) {
+                return null;
+            }
+
+            final String label = backgroundRunner.optString("label", "").trim();
+            if (label.isEmpty()) {
+                return null;
+            }
+
+            final String src = backgroundRunner.optString("src", "").trim();
+            final String event = backgroundRunner.optString("event", "").trim();
+            return new BackgroundRunnerWorkConfig(
+                label,
+                src,
+                event,
+                backgroundRunner.optBoolean("autoStart", false),
+                backgroundRunner.optBoolean("repeat", false),
+                backgroundRunner.optInt("interval", 0)
+            );
+        } catch (JSONException ignored) {
+            return null;
+        }
+    }
+
+    static String getBackgroundRunnerLabelFromConfig(final String configJson) {
+        final BackgroundRunnerWorkConfig config = getBackgroundRunnerWorkConfigFromConfig(configJson);
+        return config == null ? null : config.label;
+    }
+
+    private String readAssetAsString(final String assetPath) throws IOException {
+        final StringBuilder buffer = new StringBuilder();
+        try (
+            final BufferedReader reader = new BufferedReader(
+                new InputStreamReader(this.activity.getAssets().open(assetPath), StandardCharsets.UTF_8)
+            )
+        ) {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                buffer.append(line).append('\n');
+            }
+        }
+        return buffer.toString();
+    }
+
+    private void copyFileAtomically(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());
+        }
+
+        final File tempFile = File.createTempFile("capgo-", ".tmp", parent);
+        try {
+            try (
+                final FileInputStream input = new FileInputStream(source);
+                final FileOutputStream output = new FileOutputStream(tempFile)
+            ) {
+                final byte[] buffer = new byte[CryptoCipher.copyBufferBytes()];
+                int length;
+                while ((length = input.read(buffer)) != -1) {
+                    output.write(buffer, 0, length);
+                }
+            }
+            CryptoCipher.replaceFile(tempFile, dest);
+        } finally {
+            if (tempFile.exists()) {
+                tempFile.delete();
+            }
+        }
+    }
+
+    private void syncBackgroundRunnerScriptFromBundle(final File bundle, final BackgroundRunnerWorkConfig config) {
+        if (this.activity == null || bundle == null || config == null || config.src == null || config.src.isEmpty()) {
+            return;
+        }
+
+        if (bundle.getPath().endsWith("/public") || "public".equals(bundle.getName())) {
+            return;
+        }
+
+        try {
+            final File source = resolvePathInsideDirectory(bundle, config.src);
+            if (!source.isFile()) {
+                return;
+            }
+
+            final File publicDir = new File(this.activity.getFilesDir(), "public");
+            final File dest = resolvePathInsideDirectory(publicDir, config.src);
+            this.copyFileAtomically(source, dest);
+            logger.info("Synced Background Runner script into native public storage before bundle switch.");
+            logger.debug("Background Runner script path: " + dest.getAbsolutePath());
+        } catch (Exception e) {
+            logger.debug("Background Runner script sync skipped: " + e.getMessage());
+        }
+    }
+
+    private void resetBackgroundRunnerWorkForBundleSwitch(final File bundle) {
+        if (this.activity == null) {
+            return;
+        }
+
+        final BackgroundRunnerWorkConfig config;
+        try {
+            config = getBackgroundRunnerWorkConfigFromConfig(this.readAssetAsString(CAPACITOR_CONFIG_ASSET));
+        } catch (IOException ignored) {
+            return;
+        }
+
+        if (config == null) {
+            return;
+        }
+
+        try {
+            final WorkManager workManager = WorkManager.getInstance(this.activity.getApplicationContext());
+            workManager.cancelUniqueWork(config.label);
+            workManager.cancelAllWorkByTag(config.label);
+            logger.info("Cancelled Background Runner work before bundle switch.");
+            logger.debug("Background Runner label: " + config.label);
+        } catch (Exception e) {
+            logger.warn("Failed to cancel Background Runner work before bundle switch.");
+            logger.debug("Background Runner cancellation error: " + e.getMessage());
+        }
+
+        this.syncBackgroundRunnerScriptFromBundle(bundle, config);
+        this.rescheduleBackgroundRunnerWork(config);
+    }
+
+    private void rescheduleBackgroundRunnerWork(final BackgroundRunnerWorkConfig config) {
+        if (!config.autoStart || config.interval <= 0 || config.src.isEmpty()) {
+            return;
+        }
+
+        try {
+            @SuppressWarnings("unchecked")
+            final Class<? extends ListenableWorker> workerClass = (Class<? extends ListenableWorker>) Class.forName(
+                BACKGROUND_RUNNER_WORKER_CLASS
+            );
+            final Data data = new Data.Builder()
+                .putString("label", config.label)
+                .putString("src", config.src)
+                .putString("event", config.event)
+                .build();
+            final Constraints constraints = new Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build();
+            final WorkManager workManager = WorkManager.getInstance(this.activity.getApplicationContext());
+
+            if (!config.repeat) {
+                final OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(workerClass)
+                    .setInitialDelay(config.interval, TimeUnit.MINUTES)
+                    .setInputData(data)
+                    .addTag(config.label)
+                    .setConstraints(constraints)
+                    .build();
+                workManager.enqueueUniqueWork(config.label, ExistingWorkPolicy.REPLACE, work);
+            } else {
+                final PeriodicWorkRequest work = new PeriodicWorkRequest.Builder(workerClass, config.interval, TimeUnit.MINUTES)
+                    .setInitialDelay(config.interval, TimeUnit.MINUTES)
+                    .setInputData(data)
+                    .addTag(config.label)
+                    .setConstraints(constraints)
+                    .build();
+                workManager.enqueueUniquePeriodicWork(config.label, ExistingPeriodicWorkPolicy.UPDATE, work);
+            }
+
+            logger.info("Rescheduled Background Runner work after bundle switch.");
+        } catch (ClassNotFoundException ignored) {
+            logger.debug("Background Runner plugin not installed, skipping reschedule.");
+        } catch (Exception e) {
+            logger.warn("Failed to reschedule Background Runner work after bundle switch.");
+            logger.debug("Background Runner reschedule error: " + e.getMessage());
+        }
+    }
+
+    private boolean hasStoredBundleInfo(final String id) {
+        return (
+            id != null &&
+            !id.isEmpty() &&
+            !BundleInfo.ID_BUILTIN.equals(id) &&
+            !BundleInfo.VERSION_UNKNOWN.equals(id) &&
+            this.prefs.contains(id + INFO_SUFFIX)
+        );
+    }
+
+    private void runDownloadGate() throws IOException {
+        if (this.downloadGate == null) {
+            return;
+        }
+        try {
+            this.downloadGate.run();
+        } catch (final RuntimeException e) {
+            throw new IOException(e.getMessage() == null ? "Download gate failed" : e.getMessage(), e);
+        }
+    }
+
+    private boolean runDownloadGateQuiet() {
+        try {
+            this.runDownloadGate();
+            return true;
+        } catch (final IOException e) {
+            logger.error("Download blocked by cleanup gate: " + e.getMessage());
+            return false;
+        }
+    }
+
+    public void downloadBackground(
+        final String url,
+        final String version,
+        final String sessionKey,
+        final String checksum,
+        final JSONArray manifest
+    ) {
+        downloadBackground(url, version, sessionKey, checksum, manifest, true);
+    }
+
+    public void downloadBackground(
+        final String url,
+        final String version,
+        final String sessionKey,
+        final String checksum,
+        final JSONArray manifest,
+        final boolean setNext
+    ) {
+        if (!this.runDownloadGateQuiet()) {
+            return;
+        }
+        final String id = this.randomString();
+
+        // Check if version is already downloading, but allow retry if previous download failed
+        if (this.activity != null && DownloadWorkerManager.isVersionDownloading(this.activity, version)) {
+            // Check if there's an existing bundle with error status that we can retry
+            BundleInfo existingBundle = this.getBundleInfoByName(version);
+            if (existingBundle != null && existingBundle.isErrorStatus()) {
+                // Cancel the failed download and allow retry
+                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);
+                return;
+            }
+        }
+
+        saveBundleInfo(id, new BundleInfo(id, version, BundleStatus.DOWNLOADING, new Date(System.currentTimeMillis()), ""));
+        this.notifyDownload(id, 0);
+        this.notifyDownload(id, 5);
+
+        this.download(id, url, this.randomString(), version, sessionKey, checksum, manifest, setNext);
+    }
+
+    public BundleInfo download(final String url, final String version, final String sessionKey, final String checksum) throws IOException {
+        this.runDownloadGate();
+        // Check for existing bundle with same version and clean up if in error state
+        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");
+            if (!Boolean.TRUE.equals(this.delete(existingBundle.getId(), true))) {
+                throw new IOException("Failed to delete existing bundle before retry");
+            }
+        }
+
+        final String id = this.randomString();
+        saveBundleInfo(id, new BundleInfo(id, version, BundleStatus.DOWNLOADING, new Date(System.currentTimeMillis()), ""));
+        this.notifyDownload(id, 0);
+        this.notifyDownload(id, 5);
+        final String dest = this.randomString();
+
+        // Create a CompletableFuture to track download completion
+        CompletableFuture<BundleInfo> downloadFuture = new CompletableFuture<>();
+        downloadFutures.put(id, downloadFuture);
+
+        // Start the download
+        this.download(id, url, dest, version, sessionKey, checksum, null, false);
+
+        // Wait for completion without timeout
+        try {
+            BundleInfo result = downloadFuture.get();
+            if (result.isErrorStatus()) {
+                throw new IOException("Download failed with status: " + result.getStatus());
+            }
+            return result;
+        } catch (Exception e) {
+            // Clean up on failure
+            downloadFutures.remove(id);
+            logger.error("Error waiting for download");
+            logger.debug("Error: " + e.getMessage());
+            BundleInfo errorBundle = new BundleInfo(id, version, BundleStatus.ERROR, new Date(System.currentTimeMillis()), "");
+            saveBundleInfo(id, errorBundle);
+            if (e instanceof IOException) {
+                throw (IOException) e;
+            }
+            throw new IOException("Error waiting for download: " + e.getMessage(), e);
+        }
+    }
+
+    public BundleInfo downloadManifest(
+        final String url,
+        final String version,
+        final String sessionKey,
+        final String checksum,
+        final JSONArray manifest
+    ) throws IOException {
+        this.runDownloadGate();
+        if (manifest == null) {
+            return download(url, version, sessionKey, checksum);
+        }
+
+        // Check for existing bundle with same version and clean up if in error state
+        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");
+            if (!Boolean.TRUE.equals(this.delete(existingBundle.getId(), true))) {
+                throw new IOException("Failed to delete existing bundle before retry");
+            }
+        }
+
+        final String id = this.randomString();
+        saveBundleInfo(id, new BundleInfo(id, version, BundleStatus.DOWNLOADING, new Date(System.currentTimeMillis()), ""));
+        this.notifyDownload(id, 0);
+        this.notifyDownload(id, 5);
+        final String dest = this.randomString();
+
+        // Create a CompletableFuture to track download completion
+        CompletableFuture<BundleInfo> downloadFuture = new CompletableFuture<>();
+        downloadFutures.put(id, downloadFuture);
+
+        // Start the download
+        this.download(id, url, dest, version, sessionKey, checksum, manifest, false);
+
+        // Wait for completion without timeout
+        try {
+            BundleInfo result = downloadFuture.get();
+            if (result.isErrorStatus()) {
+                throw new IOException("Download failed with status: " + result.getStatus());
+            }
+            return result;
+        } catch (Exception e) {
+            // Clean up on failure
+            downloadFutures.remove(id);
+            logger.error("Error waiting for download");
+            logger.debug("Error: " + e.getMessage());
+            BundleInfo errorBundle = new BundleInfo(id, version, BundleStatus.ERROR, new Date(System.currentTimeMillis()), "");
+            saveBundleInfo(id, errorBundle);
+            if (e instanceof IOException) {
+                throw (IOException) e;
+            }
+            throw new IOException("Error waiting for download: " + e.getMessage(), e);
+        }
+    }
+
+    public List<BundleInfo> list(boolean rawList) {
+        if (!rawList) {
+            final List<BundleInfo> res = new ArrayList<>();
+            final File destHot = new File(this.documentsDir, bundleDirectory);
+            logger.debug("list File : " + destHot.getPath());
+            if (destHot.exists()) {
+                for (final File i : Objects.requireNonNull(destHot.listFiles())) {
+                    final String id = i.getName();
+                    res.add(this.getBundleInfo(id));
+                }
+            } else {
+                logger.info("No versions available to list" + destHot);
+            }
+            return res;
+        } else {
+            final List<BundleInfo> res = new ArrayList<>();
+            for (String value : this.prefs.getAll().keySet()) {
+                if (!value.matches("^[0-9A-Za-z]{10}_info$")) {
+                    continue;
+                }
+
+                res.add(this.getBundleInfo(value.split("_")[0]));
+            }
+            return res;
+        }
+    }
+
+    public Boolean delete(final String id, final Boolean removeInfo) throws IOException {
+        return this.delete(id, removeInfo, true);
+    }
+
+    public Boolean delete(final String id, final Boolean removeInfo, final boolean cancelActiveDownload) throws IOException {
+        synchronized (this.deleteLock) {
+            final BundleInfo deleted = this.getBundleInfo(id);
+            if (deleted.isBuiltin() || this.getCurrentBundleId().equals(id)) {
+                logger.error("Cannot delete current or builtin bundle");
+                logger.debug("Bundle ID: " + id);
+                return false;
+            }
+            final BundleInfo previewFallback = this.getPreviewFallbackBundle();
+            if (
+                previewFallback != null &&
+                !previewFallback.isDeleted() &&
+                !previewFallback.isErrorStatus() &&
+                !previewFallback.isDeleting() &&
+                previewFallback.getId().equals(id)
+            ) {
+                logger.error("Cannot delete the preview fallback bundle");
+                logger.debug("Bundle ID: " + id);
+                return false;
+            }
+            final BundleInfo next = this.getNextBundle();
+            if (next != null && !next.isDeleted() && !next.isErrorStatus() && !next.isDeleting() && next.getId().equals(id)) {
+                logger.error("Cannot delete the next bundle");
+                logger.debug("Bundle ID: " + id);
+                return false;
+            }
+
+            final File bundle = this.getBundleDirectory(id);
+            final boolean hadRegistry = this.hasStoredBundleInfo(id);
+            final boolean hadFolder = bundle.exists();
+            if (!hadRegistry && !hadFolder) {
+                logger.error("Cannot delete unknown bundle");
+                logger.debug("Bundle ID: " + id);
+                return false;
+            }
+
+            // Persist DELETING before touching disk so kill/OOM can resume on next launch.
+            if (!deleted.isDeleting()) {
+                if (!this.saveBundleInfo(id, deleted.setStatus(BundleStatus.DELETING))) {
+                    logger.error("Failed to persist DELETING marker, aborting disk delete");
+                    logger.debug("Bundle ID: " + id);
+                    return false;
+                }
+            }
+
+            // Cancel download for this version if active
+            if (cancelActiveDownload && this.activity != null) {
+                if (!DownloadWorkerManager.cancelVersionDownloadAndAwait(this.activity, deleted.getVersionName())) {
+                    logger.error("Failed to cancel active download before delete");
+                    return false;
+                }
+            }
+
+            if (bundle.exists()) {
+                try {
+                    this.deleteDirectory(bundle);
+                } catch (final IOException e) {
+                    logger.error("Failed to delete bundle folder, will retry later");
+                    logger.debug("Bundle ID: " + id + ", Error: " + e.getMessage());
+                    return false;
+                }
+            }
+
+            // Only drop registry after the folder is confirmed gone.
+            if (bundle.exists()) {
+                logger.error("Bundle folder still present after delete, will retry later");
+                logger.debug("Bundle ID: " + id);
+                return false;
+            }
+
+            final boolean finalized;
+            if (Boolean.FALSE.equals(removeInfo)) {
+                finalized = this.saveBundleInfo(id, deleted.setStatus(BundleStatus.DELETED));
+            } else {
+                finalized = this.saveBundleInfo(id, null);
+            }
+            if (!finalized) {
+                logger.error("Failed to finalize delete registry update, will retry later");
+                logger.debug("Bundle ID: " + id);
+                return false;
+            }
+            this.sendStats("delete", deleted.getVersionName());
+            this.dequeuePendingDelete(id);
+            logger.info("Bundle deleted and confirmed gone");
+            logger.debug("Bundle ID: " + id);
+            return true;
+        }
+    }
+
+    public Boolean delete(final String id) {
+        try {
+            return this.delete(id, true);
+        } catch (IOException e) {
+            e.printStackTrace();
+            logger.info("Failed to delete bundle (" + id + ")" + "\nError:\n" + e.toString());
+            return false;
+        }
+    }
+
+    /**
+     * Resume incomplete deletes one-by-one. Safe across app kill / OOM because
+     * delete() marks DELETING before disk work and only clears registry after confirm.
+     */
+    public void drainPendingDeletes() {
+        final LinkedHashSet<String> pendingIds = new LinkedHashSet<>();
+        for (final BundleInfo info : this.list(true)) {
+            if (info != null && info.isDeleting() && info.getId() != null && !info.getId().isEmpty()) {
+                pendingIds.add(info.getId());
+            }
+        }
+        pendingIds.addAll(this.getPendingDeleteIds());
+        for (final String id : pendingIds) {
+            try {
+                logger.info("Resuming pending delete for bundle: " + id);
+                if (Boolean.TRUE.equals(this.delete(id, true))) {
+                    this.dequeuePendingDelete(id);
+                }
+            } catch (final Exception e) {
+                logger.error("Pending delete failed, will retry next launch");
+                logger.debug("Bundle ID: " + id + ", Error: " + e.getMessage());
+            }
+            try {
+                Thread.sleep(DELETE_PACE_MS);
+            } catch (final InterruptedException ie) {
+                Thread.currentThread().interrupt();
+                return;
+            }
+        }
+    }
+
+    private Set<String> getPendingDeleteIds() {
+        final Set<String> ids = new LinkedHashSet<>();
+        if (this.prefs == null) {
+            return ids;
+        }
+        final String raw = this.prefs.getString(PENDING_DELETE_IDS, "");
+        if (raw == null || raw.isEmpty()) {
+            return ids;
+        }
+        for (final String part : raw.split(",")) {
+            if (part != null && !part.isEmpty()) {
+                ids.add(part);
+            }
+        }
+        return ids;
+    }
+
+    private void enqueuePendingDelete(final String id) {
+        if (id == null || id.isEmpty() || this.editor == null || this.prefs == null) {
+            return;
+        }
+        final Set<String> ids = this.getPendingDeleteIds();
+        if (!ids.add(id)) {
+            return;
+        }
+        this.editor.putString(PENDING_DELETE_IDS, String.join(",", ids));
+        this.editor.commit();
+    }
+
+    private void dequeuePendingDelete(final String id) {
+        if (id == null || id.isEmpty() || this.editor == null || this.prefs == null) {
+            return;
+        }
+        final Set<String> ids = this.getPendingDeleteIds();
+        if (!ids.remove(id)) {
+            return;
+        }
+        if (ids.isEmpty()) {
+            this.editor.remove(PENDING_DELETE_IDS);
+        } else {
+            this.editor.putString(PENDING_DELETE_IDS, String.join(",", ids));
+        }
+        this.editor.commit();
+    }
+
+    private File getBundleDirectory(final String id) {
+        return new File(this.documentsDir, bundleDirectory + "/" + id);
+    }
+
+    private boolean bundleExists(final String id) {
+        final File bundle = this.getBundleDirectory(id);
+        final BundleInfo bundleInfo = this.getBundleInfo(id);
+        return (
+            bundle.isDirectory() &&
+            bundle.exists() &&
+            new File(bundle.getPath(), "/index.html").exists() &&
+            !bundleInfo.isDeleted() &&
+            !bundleInfo.isDeleting()
+        );
+    }
+
+    static final class ResetState {
+
+        final String currentBundlePath;
+        final String fallbackBundleId;
+        final String nextBundleId;
+
+        ResetState(final String currentBundlePath, final String fallbackBundleId, final String nextBundleId) {
+            this.currentBundlePath = currentBundlePath;
+            this.fallbackBundleId = fallbackBundleId;
+            this.nextBundleId = nextBundleId;
+        }
+    }
+
+    ResetState captureResetState() {
+        return new ResetState(
+            this.getCurrentBundlePath(),
+            this.prefs.getString(FALLBACK_VERSION, BundleInfo.ID_BUILTIN),
+            this.prefs.getString(NEXT_VERSION, null)
+        );
+    }
+
+    void restoreResetState(final ResetState state) {
+        final String currentBundlePath =
+            state.currentBundlePath == null || state.currentBundlePath.trim().isEmpty() ? "public" : state.currentBundlePath;
+        final String fallbackBundleId =
+            state.fallbackBundleId == null || state.fallbackBundleId.isEmpty() ? BundleInfo.ID_BUILTIN : state.fallbackBundleId;
+
+        this.editor.putString(this.CAP_SERVER_PATH, currentBundlePath);
+        this.editor.putString(FALLBACK_VERSION, fallbackBundleId);
+        if (state.nextBundleId == null || state.nextBundleId.isEmpty()) {
+            this.editor.remove(NEXT_VERSION);
+        } else {
+            this.editor.putString(NEXT_VERSION, state.nextBundleId);
+        }
+        this.editor.commit();
+    }
+
+    void prepareResetStateForTransition() {
+        this.setCurrentBundle(new File("public"));
+        this.setFallbackBundle(null);
+        this.setNextBundle(null);
+    }
+
+    void finalizeResetTransition(final String previousBundleName, final boolean internal) {
+        if (this.activity != null) {
+            DownloadWorkerManager.cancelAllDownloads(this.activity);
+        }
+        if (!internal) {
+            this.sendStats("reset", this.getCurrentBundle().getVersionName(), previousBundleName);
+        }
+    }
+
+    boolean canSet(final BundleInfo bundle) {
+        return bundle != null && (bundle.isBuiltin() || this.bundleExists(bundle.getId()));
+    }
+
+    public Boolean set(final BundleInfo bundle) {
+        return this.set(bundle.getId());
+    }
+
+    public Boolean set(final String id) {
+        final BundleInfo newBundle = this.getBundleInfo(id);
+        if (newBundle.isBuiltin()) {
+            this.reset();
+            return true;
+        }
+        final File bundle = this.getBundleDirectory(id);
+        logger.info("Setting next active bundle: " + id);
+        if (this.bundleExists(id)) {
+            var currentBundleName = this.getCurrentBundle().getVersionName();
+            this.setCurrentBundle(bundle);
+            this.setBundleStatus(id, BundleStatus.PENDING);
+            this.sendStats("set", newBundle.getVersionName(), currentBundleName);
+            return true;
+        }
+        this.setBundleStatus(id, BundleStatus.ERROR);
+        this.sendStats("set_fail", newBundle.getVersionName());
+        return false;
+    }
+
+    boolean stagePendingReload(final BundleInfo bundle) {
+        if (bundle == null || bundle.isBuiltin() || !this.bundleExists(bundle.getId())) {
+            return false;
+        }
+        this.setCurrentBundle(this.getBundleDirectory(bundle.getId()));
+        return true;
+    }
+
+    boolean stagePreviewFallbackReload(final BundleInfo bundle) {
+        if (bundle == null || bundle.isErrorStatus()) {
+            return false;
+        }
+        if (bundle.isBuiltin()) {
+            this.setCurrentBundle(new File("public"));
+            return true;
+        }
+        if (!this.bundleExists(bundle.getId())) {
+            return false;
+        }
+        this.setCurrentBundle(this.getBundleDirectory(bundle.getId()));
+        return true;
+    }
+
+    void finalizePendingReload(final BundleInfo bundle, final String previousBundleName) {
+        if (bundle == null || bundle.isBuiltin()) {
+            return;
+        }
+        this.sendStats("set", bundle.getVersionName(), previousBundleName);
+    }
+
+    @Deprecated
+    public void autoReset() {
+        this.autoReset(this.versionCode == null ? "" : this.versionCode);
+    }
+
+    public void autoReset(final String currentNativeBuildVersion) {
+        this.autoReset(currentNativeBuildVersion, true);
+    }
+
+    public void autoReset(final String currentNativeBuildVersion, final boolean resetWhenNativeVersionChanged) {
+        final BundleInfo currentBundle = this.getCurrentBundle();
+        if (!currentBundle.isBuiltin() && !this.bundleExists(currentBundle.getId())) {
+            logger.info("Folder at bundle path does not exist. Triggering reset.");
+            this.reset();
+            return;
+        }
+        String bundlePath = this.prefs.getString(this.CAP_SERVER_PATH, null);
+        if (shouldResetForForeignBundle(bundlePath, currentBundle.isBuiltin(), this.hasStoredBundleInfo(currentBundle.getId()))) {
+            logger.info("Current bundle id is not one of the bundle ids stored by this plugin. Triggering reset.");
+            this.reset();
+            return;
+        }
+        final String previousNativeBuildVersion = this.getStoredNativeBuildVersion();
+        if (
+            resetWhenNativeVersionChanged &&
+            !previousNativeBuildVersion.isEmpty() &&
+            currentNativeBuildVersion != null &&
+            !currentNativeBuildVersion.isEmpty() &&
+            !Objects.equals(previousNativeBuildVersion, currentNativeBuildVersion)
+        ) {
+            logger.info(
+                "Stored native build version " +
+                    previousNativeBuildVersion +
+                    " does not match current native build version " +
+                    currentNativeBuildVersion +
+                    ". Triggering reset."
+            );
+            this.reset();
+        }
+    }
+
+    private String getStoredNativeBuildVersion() {
+        if (this.prefs == null) {
+            return "";
+        }
+        String previousNativeBuildVersion = this.prefs.getString("LatestNativeBuildVersion", "");
+        if (previousNativeBuildVersion == null || previousNativeBuildVersion.isEmpty()) {
+            previousNativeBuildVersion = this.prefs.getString("LatestVersionNative", "");
+        }
+        return previousNativeBuildVersion == null ? "" : previousNativeBuildVersion;
+    }
+
+    public void reset() {
+        this.reset(false);
+    }
+
+    public void setSuccess(final BundleInfo bundle, Boolean autoDeletePrevious) {
+        this.setBundleStatus(bundle.getId(), BundleStatus.SUCCESS);
+        final BundleInfo fallback = this.getFallbackBundle();
+        final BundleInfo previewFallback = this.getPreviewFallbackBundle();
+        final boolean fallbackIsPreviewFallback = previewFallback != null && previewFallback.getId().equals(fallback.getId());
+        logger.debug("Fallback bundle is: " + fallback);
+        logger.info("Version successfully loaded: " + bundle.getVersionName());
+        // Only attempt to delete when the fallback is a different bundle than the
+        // currently loaded one. Otherwise we spam logs with "Cannot delete <id>"
+        // because delete() protects the current bundle from removal.
+        final String previousFallbackId = fallback.getId();
+        final String previousFallbackVersion = fallback.getVersionName();
+        final BundleInfo nextBundle = this.getNextBundle();
+        final boolean previousIsNext =
+            nextBundle != null &&
+            previousFallbackId != null &&
+            previousFallbackId.equals(nextBundle.getId()) &&
+            !nextBundle.isDeleted() &&
+            !nextBundle.isErrorStatus() &&
+            !nextBundle.isDeleting();
+        final boolean shouldDeletePrevious =
+            Boolean.TRUE.equals(autoDeletePrevious) &&
+            !fallback.isBuiltin() &&
+            previousFallbackId != null &&
+            !previousFallbackId.equals(bundle.getId()) &&
+            !fallbackIsPreviewFallback &&
+            !previousIsNext;
+        if (shouldDeletePrevious) {
+            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 (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(asyncPreviousFallbackId, true, false);
+                    if (Boolean.TRUE.equals(res)) {
+                        logger.info("Deleted previous bundle: " + asyncPreviousFallbackVersion);
+                    } else {
+                        logger.debug("Previous bundle delete incomplete, will retry: " + asyncPreviousFallbackId);
+                    }
+                } catch (final IOException e) {
+                    logger.error("Failed to delete previous bundle: " + asyncPreviousFallbackId + " " + e.getMessage());
+                }
+            });
+        }
+    }
+
+    public void setError(final BundleInfo bundle) {
+        this.setBundleStatus(bundle.getId(), BundleStatus.ERROR);
+    }
+
+    public void reset(final boolean internal) {
+        logger.debug("reset: " + internal);
+        final String currentBundleName = this.getCurrentBundle().getVersionName();
+        this.prepareResetStateForTransition();
+        this.finalizeResetTransition(currentBundleName, internal);
+    }
+
+    private JSONObject createInfoObject() throws JSONException {
+        return this.createInfoObject(null);
+    }
+
+    private JSONObject createInfoObject(final String appIdOverride) throws JSONException {
+        JSONObject json = new JSONObject();
+        json.put("platform", "android");
+        json.put("device_id", this.deviceID);
+        json.put("app_id", appIdOverride == null || appIdOverride.trim().isEmpty() ? this.appId : appIdOverride);
+        json.put("custom_id", this.customId);
+        json.put("version_build", this.versionBuild);
+        json.put("version_code", this.versionCode);
+        json.put("version_os", this.versionOs);
+        json.put("version_name", this.getCurrentBundle().getVersionName());
+        json.put("plugin_version", this.pluginVersion);
+        json.put("is_emulator", this.isEmulator());
+        json.put("is_prod", this.isProd());
+        json.put("install_source", this.getInstallSource());
+        json.put("defaultChannel", this.defaultChannel);
+
+        // Add encryption key ID if encryption is enabled (use cached value)
+        if (!this.cachedKeyId.isEmpty()) {
+            json.put("key_id", this.cachedKeyId);
+        }
+
+        return json;
+    }
+
+    private static final class RemoteBlockResult {
+
+        final boolean blocked;
+        final String error;
+        final String message;
+
+        RemoteBlockResult(final boolean blocked, final String error, final String message) {
+            this.blocked = blocked;
+            this.error = error;
+            this.message = message;
+        }
+    }
+
+    /**
+     * Handle HTTP 429 responses by honouring Retry-After / rateLimitResetAt.
+     * All 429s use the same temporary client block — no sticky latch until restart.
+     */
+    private RemoteBlockResult checkAndHandleRateLimitResponse(Response response, String responseData) {
+        if (response == null || response.code() != 429) {
+            return new RemoteBlockResult(false, "", "");
+        }
+
+        final String parsedError = parseRemoteError(responseData);
+        final String parsedMessage = parseRemoteMessage(responseData);
+        final String errorCode = parsedError.isEmpty() ? "too_many_requests" : parsedError;
+        final String message = parsedMessage.isEmpty() ? "Too many requests" : parsedMessage;
+
+        final long retryUntilMs = resolveRateLimitBlockedUntilMs(response, responseData);
+        synchronized (rateLimitStateLock) {
+            if (retryUntilMs > rateLimitBlockedUntilMs) {
+                rateLimitBlockedUntilMs = retryUntilMs;
+                rateLimitBlockedError = errorCode;
+                rateLimitBlockedMessage = message;
+            } else if (rateLimitBlockedUntilMs <= 0L) {
+                rateLimitBlockedError = errorCode;
+                rateLimitBlockedMessage = message;
+            }
+        }
+
+        // Claim last, and only when there is somewhere to send it, so a 429 burst with no
+        // stats URL does not claim and release the latch once per response.
+        if ("too_many_requests".equals(errorCode) && !this.previewSession && this.hasStatsUrl() && claimRateLimitStatistic()) {
+            sendRateLimitStatistic();
+        }
+
+        final long nowMs = System.currentTimeMillis();
+        final long retryAfter = Math.max(0L, (Math.max(retryUntilMs, nowMs) - nowMs + 999L) / 1000L);
+        logger.warn("Received 429 (" + errorCode + "). Honouring Retry-After: " + retryAfter + "s.");
+        return new RemoteBlockResult(true, errorCode, message);
+    }
+
+    private String parseRemoteError(final String responseData) {
+        if (responseData == null || responseData.isEmpty()) {
+            return "";
+        }
+        try {
+            final JSONObject json = new JSONObject(responseData);
+            return json.optString("error", "");
+        } catch (JSONException ignored) {
+            return "";
+        }
+    }
+
+    private String parseRemoteMessage(final String responseData) {
+        if (responseData == null || responseData.isEmpty()) {
+            return "";
+        }
+        try {
+            final JSONObject json = new JSONObject(responseData);
+            return json.optString("message", "");
+        } catch (JSONException ignored) {
+            return "";
+        }
+    }
+
+    private long resolveRateLimitBlockedUntilMs(final Response response, final String responseData) {
+        final long nowMs = System.currentTimeMillis();
+        final double candidate = rawRateLimitDeadlineMs(response, responseData, nowMs);
+        // NaN and past deadlines mean "no client-side block"; anything further out is capped.
+        if (!(candidate > nowMs)) {
+            return 0L;
+        }
+        return (long) Math.min(candidate, (double) nowMs + MAX_RATE_LIMIT_WINDOW_MS);
+    }
+
+    private double rawRateLimitDeadlineMs(final Response response, final String responseData, final long nowMs) {
+        final String header = response.header("Retry-After");
+        if (header != null) {
+            try {
+                final double seconds = Double.parseDouble(header.trim());
+                if (seconds >= 0) {
+                    return nowMs + seconds * 1000d;
+                }
+            } catch (NumberFormatException ignored) {
+                // Fall through to body fields
+            }
+        }
+
+        if (responseData != null && !responseData.isEmpty()) {
+            try {
+                final JSONObject json = new JSONObject(responseData);
+                final JSONObject moreInfo = json.optJSONObject("moreInfo");
+                if (moreInfo != null && moreInfo.has("retryAfterSeconds")) {
+                    final double retryAfter = moreInfo.getDouble("retryAfterSeconds");
+                    if (retryAfter >= 0) {
+                        return nowMs + retryAfter * 1000d;
+                    }
+                } else if (json.has("retryAfterSeconds")) {
+                    final double retryAfter = json.getDouble("retryAfterSeconds");
+                    if (retryAfter >= 0) {
+                        return nowMs + retryAfter * 1000d;
+                    }
+                }
+                if (moreInfo != null && moreInfo.has("rateLimitResetAt")) {
+                    return moreInfo.getDouble("rateLimitResetAt");
+                } else if (json.has("rateLimitResetAt")) {
+                    return json.getDouble("rateLimitResetAt");
+                }
+            } catch (JSONException ignored) {
+                // No retry hint
+            }
+        }
+
+        // No retry hint — do not hold a client-side block; allow immediate retry to the worker
+        return 0d;
+    }
+
+    private static boolean claimRateLimitStatistic() {
+        synchronized (rateLimitStateLock) {
+            if (rateLimitStatisticSent) {
+                return false;
+            }
+            rateLimitStatisticSent = true;
+            return true;
+        }
+    }
+
+    /**
+     * Give the claim back when the statistic never made it out, so a later 429 can retry it.
+     */
+    private static void releaseRateLimitStatisticClaim() {
+        synchronized (rateLimitStateLock) {
+            rateLimitStatisticSent = false;
+        }
+    }
+
+    private boolean hasStatsUrl() {
+        final String url = this.statsUrl;
+        return url != null && !url.isEmpty();
+    }
+
+    private boolean isRemoteBlocked() {
+        synchronized (rateLimitStateLock) {
+            if (rateLimitBlockedUntilMs <= 0L) {
+                return false;
+            }
+            if (System.currentTimeMillis() >= rateLimitBlockedUntilMs) {
+                rateLimitBlockedUntilMs = 0L;
+                return false;
+            }
+            return true;
+        }
+    }
+
+    private RemoteBlockResult remoteBlockedClientError() {
+        synchronized (rateLimitStateLock) {
+            return new RemoteBlockResult(true, rateLimitBlockedError, rateLimitBlockedMessage);
+        }
+    }
+
+    /**
+     * Send a statistic about rate limiting.
+     * Dispatched through OkHttp so no caller thread waits on the request.
+     */
+    private void sendRateLimitStatistic() {
+        String statsUrl = this.statsUrl;
+        if (statsUrl == null || statsUrl.isEmpty()) {
+            // The URL was cleared after the claim was taken; nothing went out, so hand it back.
+            releaseRateLimitStatisticClaim();
+            return;
+        }
+
+        try {
+            BundleInfo current = this.getCurrentBundle();
+            JSONObject json = this.createInfoObject();
+            json.put("version_name", current.getVersionName());
+            json.put("old_version_name", "");
+            json.put("action", "rate_limit_reached");
+
+            Request request = new Request.Builder()
+                .url(statsUrl)
+                .post(RequestBody.create(json.toString(), MediaType.get("application/json")))
+                .build();
+
+            // User-Agent header is automatically added by DownloadService.sharedClient interceptor
+            DownloadService.sharedClient.newCall(request).enqueue(
+                new okhttp3.Callback() {
+                    @Override
+                    public void onFailure(@NonNull Call call, @NonNull IOException e) {
+                        releaseRateLimitStatisticClaim();
+                        logger.error("Failed to send rate limit statistic");
+                        logger.debug("Error: " + e.getMessage());
+                    }
+
+                    @Override
+                    public void onResponse(@NonNull Call call, @NonNull Response response) {
+                        // The body is unused here; closing the Response closes it.
+                        try (response) {
+                            if (response.isSuccessful()) {
+                                logger.info("Rate limit statistic sent");
+                            } else {
+                                releaseRateLimitStatisticClaim();
+                                logger.error("Error sending rate limit statistic");
+                                logger.debug("Response code: " + response.code());
+                            }
+                        }
+                    }
+                }
+            );
+        } catch (final Exception e) {
+            releaseRateLimitStatisticClaim();
+            logger.error("Failed to send rate limit statistic");
+            logger.debug("Error: " + e.getMessage());
+        }
+    }
+
+    private void makeJsonRequest(String url, JSONObject jsonBody, Callback callback) {
+        MediaType JSON = MediaType.get("application/json; charset=utf-8");
+        RequestBody body = RequestBody.create(jsonBody.toString(), JSON);
+
+        Request request = new Request.Builder().url(url).post(body).build();
+
+        DownloadService.sharedClient.newCall(request).enqueue(
+            new okhttp3.Callback() {
+                @Override
+                public void onFailure(@NonNull Call call, @NonNull IOException e) {
+                    Map<String, Object> retError = new HashMap<>();
+                    retError.put("message", "Request failed: " + e.getMessage());
+                    retError.put("error", "network_error");
+                    retError.put("kind", "failed");
+                    callback.callback(retError);
+                }
+
+                @Override
+                public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
+                    try (ResponseBody responseBody = response.body()) {
+                        final int statusCode = response.code();
+                        final String responseData = responseBody != null ? responseBody.string() : "";
+                        JSONObject jsonResponse = null;
+                        if (!responseData.isEmpty()) {
+                            try {
+                                jsonResponse = new JSONObject(responseData);
+                            } catch (JSONException ignored) {
+                                // Non-JSON responses are handled as response or parse errors below.
+                            }
+                        }
+
+                        if (jsonResponse != null && (jsonResponse.has("error") || jsonResponse.has("kind"))) {
+                            if (statusCode == 429) {
+                                final RemoteBlockResult rateLimit = checkAndHandleRateLimitResponse(response, responseData);
+                                Map<String, Object> retError = new HashMap<>();
+                                retError.put(
+                                    "error",
+                                    rateLimit.error.isEmpty() ? jsonResponse.optString("error", "too_many_requests") : rateLimit.error
+                                );
+                                retError.put(
+                                    "message",
+                                    rateLimit.message.isEmpty() ? jsonResponse.optString("message", "Too many requests") : rateLimit.message
+                                );
+                                if (jsonResponse.has("kind") && !jsonResponse.isNull("kind")) {
+                                    retError.put("kind", jsonResponse.getString("kind"));
+                                } else {
+                                    retError.put("kind", "failed");
+                                }
+                                if (jsonResponse.has("version") && !jsonResponse.isNull("version")) {
+                                    retError.put("version", jsonResponse.getString("version"));
+                                }
+                                retError.put("statusCode", statusCode);
+                                callback.callback(retError);
+                                return;
+                            }
+                            Map<String, Object> retError = new HashMap<>();
+                            if (jsonResponse.has("error") && !jsonResponse.isNull("error")) {
+                                retError.put("error", jsonResponse.getString("error"));
+                            }
+                            if (jsonResponse.has("kind") && !jsonResponse.isNull("kind")) {
+                                retError.put("kind", jsonResponse.getString("kind"));
+                            }
+                            if (jsonResponse.has("message") && !jsonResponse.isNull("message")) {
+                                retError.put("message", jsonResponse.getString("message"));
+                            } else {
+                                retError.put("message", "server did not provide a message");
+                            }
+                            if (jsonResponse.has("version") && !jsonResponse.isNull("version")) {
+                                retError.put("version", jsonResponse.getString("version"));
+                            }
+                            retError.put("statusCode", statusCode);
+                            callback.callback(retError);
+                            return;
+                        }
+
+                        // Check for 429 rate limit without JSON body
+                        final RemoteBlockResult rateLimit = checkAndHandleRateLimitResponse(response, responseData);
+                        if (rateLimit.blocked) {
+                            Map<String, Object> retError = new HashMap<>();
+                            retError.put("message", rateLimit.message);
+                            retError.put("error", rateLimit.error);
+                            retError.put("kind", "failed");
+                            retError.put("statusCode", statusCode);
+                            callback.callback(retError);
+                            return;
+                        }
+
+                        if (!response.isSuccessful()) {
+                            Map<String, Object> retError = new HashMap<>();
+                            retError.put("message", "Server error: " + response.code());
+                            retError.put("error", "response_error");
+                            retError.put("kind", "failed");
+                            retError.put("statusCode", statusCode);
+                            callback.callback(retError);
+                            return;
+                        }
+
+                        if (jsonResponse == null) {
+                            throw new JSONException("Response is not a JSON object");
+                        }
+
+                        Map<String, Object> ret = new HashMap<>();
+                        ret.put("statusCode", statusCode);
+
+                        Iterator<String> keys = jsonResponse.keys();
+                        while (keys.hasNext()) {
+                            String key = keys.next();
+                            if (jsonResponse.has(key)) {
+                                if ("session_key".equals(key)) {
+                                    ret.put("sessionKey", jsonResponse.get(key));
+                                } else {
+                                    ret.put(key, jsonResponse.get(key));
+                                }
+                            }
+                        }
+                        callback.callback(ret);
+                    } catch (JSONException e) {
+                        Map<String, Object> retError = new HashMap<>();
+                        retError.put("message", "JSON parse error: " + e.getMessage());
+                        retError.put("error", "parse_error");
+                        retError.put("kind", "failed");
+                        callback.callback(retError);
+                    }
+                }
+            }
+        );
+    }
+
+    public void getLatest(final String updateUrl, final String channel, final Callback callback) {
+        this.getLatest(updateUrl, channel, null, callback);
+    }
+
+    public void getLatest(final String updateUrl, final String channel, final String appIdOverride, final Callback callback) {
+        if (isRemoteBlocked()) {
+            final RemoteBlockResult blocked = remoteBlockedClientError();
+            logger.debug("Skipping getLatest due to remote block (" + blocked.error + ").");
+            final Map<String, Object> retError = new HashMap<>();
+            retError.put("message", blocked.message);
+            retError.put("error", blocked.error);
+            retError.put("kind", "failed");
+            callback.callback(retError);
+            return;
+        }
+        JSONObject json;
+        try {
+            json = this.createInfoObject(appIdOverride);
+            if (channel != null && json != null) {
+                json.put("defaultChannel", channel);
+            }
+        } catch (JSONException e) {
+            logger.error("Error getting latest version");
+            logger.debug("JSONException: " + e.getMessage());
+            final Map<String, Object> retError = new HashMap<>();
+            retError.put("message", "Cannot get info: " + e);
+            retError.put("error", "json_error");
+            callback.callback(retError);
+            return;
+        }
+
+        if (logger != null) {
+            logger.info("Auto-update parameters: " + json);
+        }
+
+        makeJsonRequest(updateUrl, json, callback);
+    }
+
+    public void unsetChannel(
+        final SharedPreferences.Editor editor,
+        final String defaultChannelKey,
+        final String configDefaultChannel,
+        final Callback callback
+    ) {
+        // Clear persisted defaultChannel and revert to config value
+        editor.remove(defaultChannelKey);
+        editor.apply();
+        this.defaultChannel = configDefaultChannel;
+        logger.info("Persisted defaultChannel cleared, reverted to config value: " + configDefaultChannel);
+
+        Map<String, Object> ret = new HashMap<>();
+        ret.put("status", "ok");
+        ret.put("message", "Channel override removed");
+        callback.callback(ret);
+    }
+
+    public void setChannel(
+        final String channel,
+        final SharedPreferences.Editor editor,
+        final String defaultChannelKey,
+        final boolean allowSetDefaultChannel,
+        final Callback callback
+    ) {
+        this.setChannel(channel, editor, defaultChannelKey, allowSetDefaultChannel, "", callback);
+    }
+
+    public void setChannel(
+        final String channel,
+        final SharedPreferences.Editor editor,
+        final String defaultChannelKey,
+        final boolean allowSetDefaultChannel,
+        final String configDefaultChannel,
+        final Callback callback
+    ) {
+        // Check if setting defaultChannel is allowed
+        if (!allowSetDefaultChannel) {
+            logger.error("setChannel is disabled by allowSetDefaultChannel config");
+            final Map<String, Object> retError = new HashMap<>();
+            retError.put("message", "setChannel is disabled by configuration");
+            retError.put("error", "disabled_by_config");
+            callback.callback(retError);
+            return;
+        }
+
+        if (isRemoteBlocked()) {
+            final RemoteBlockResult blocked = remoteBlockedClientError();
+            logger.debug("Skipping setChannel due to remote block (" + blocked.error + ").");
+            final Map<String, Object> retError = new HashMap<>();
+            retError.put("message", blocked.message);
+            retError.put("error", blocked.error);
+            callback.callback(retError);
+            return;
+        }
+
+        String channelUrl = this.channelUrl;
+        if (channelUrl == null || channelUrl.isEmpty()) {
+            logger.error("Channel URL is not set");
+            final Map<String, Object> retError = new HashMap<>();
+            retError.put("message", "channelUrl missing");
+            retError.put("error", "missing_config");
+            callback.callback(retError);
+            return;
+        }
+        JSONObject json;
+        try {
+            json = this.createInfoObject();
+            json.put("channel", channel);
+        } catch (JSONException e) {
+            logger.error("Error setting channel");
+            logger.debug("JSONException: " + e.getMessage());
+            final Map<String, Object> retError = new HashMap<>();
+            retError.put("message", "Cannot get info: " + e);
+            retError.put("error", "json_error");
+            callback.callback(retError);
+            return;
+        }
+
+        makeJsonRequest(channelUrl, json, (res) -> {
+            if (res.containsKey("error")) {
+                callback.callback(res);
+            } else if (Boolean.TRUE.equals(res.get("unset"))) {
+                // Server requested to unset channel (public channel was requested)
+                // Clear persisted defaultChannel and revert to config value
+                editor.remove(defaultChannelKey);
+                editor.apply();
+                this.defaultChannel = configDefaultChannel;
+                logger.info("Public channel requested, channel override removed");
+                callback.callback(res);
+            } else {
+                this.defaultChannel = channel;
+                editor.putString(defaultChannelKey, channel);
+                editor.apply();
+                logger.info("defaultChannel persisted locally: " + channel);
+                callback.callback(res);
+            }
+        });
+    }
+
+    public void getChannel(final Callback callback) {
+        this.getChannel(callback, null, null);
+    }
+
+    public void getChannel(final Callback callback, final SharedPreferences.Editor editor, final String defaultChannelKey) {
+        if (isRemoteBlocked()) {
+            final RemoteBlockResult blocked = remoteBlockedClientError();
+            logger.debug("Skipping getChannel due to remote block (" + blocked.error + ").");
+            final Map<String, Object> retError = new HashMap<>();
+            retError.put("message", blocked.message);
+            retError.put("error", blocked.error);
+            callback.callback(retError);
+            return;
+        }
+
+        String channelUrl = this.channelUrl;
+        if (channelUrl == null || channelUrl.isEmpty()) {
+            logger.error("Channel URL is not set");
+            final Map<String, Object> retError = new HashMap<>();
+            retError.put("message", "Channel URL is not set");
+            retError.put("error", "missing_config");
+            callback.callback(retError);
+            return;
+        }
+        JSONObject json;
+        try {
+            json = this.createInfoObject();
+        } catch (JSONException e) {
+            logger.error("Error getting channel");
+            logger.debug("JSONException: " + e.getMessage());
+            final Map<String, Object> retError = new HashMap<>();
+            retError.put("message", "Cannot get info: " + e);
+            retError.put("error", "json_error");
+            callback.callback(retError);
+            return;
+        }
+
+        Request request = new Request.Builder()
+            .url(channelUrl)
+            .put(RequestBody.create(json.toString(), MediaType.get("application/json")))
+            .build();
+
+        DownloadService.sharedClient.newCall(request).enqueue(
+            new okhttp3.Callback() {
+                @Override
+                public void onFailure(@NonNull Call call, @NonNull IOException e) {
+                    Map<String, Object> retError = new HashMap<>();
+                    retError.put("message", "Request failed: " + e.getMessage());
+                    retError.put("error", "network_error");
+                    callback.callback(retError);
+                }
+
+                @Override
+                public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
+                    try (ResponseBody responseBody = response.body()) {
+                        final String responseData = responseBody != null ? responseBody.string() : "";
+                        final RemoteBlockResult rateLimit = checkAndHandleRateLimitResponse(response, responseData);
+                        if (rateLimit.blocked) {
+                            Map<String, Object> retError = new HashMap<>();
+                            retError.put("message", rateLimit.message);
+                            retError.put("error", rateLimit.error);
+                            callback.callback(retError);
+                            return;
+                        }
+
+                        if (response.code() == 400) {
+                            if (responseData.contains("channel_not_found") && !defaultChannel.isEmpty()) {
+                                Map<String, Object> ret = new HashMap<>();
+                                ret.put("channel", defaultChannel);
+                                ret.put("status", "default");
+                                logger.info("Channel get to \"" + ret);
+                                callback.callback(ret);
+                                return;
+                            }
+                        }
+
+                        if (!response.isSuccessful()) {
+                            Map<String, Object> retError = new HashMap<>();
+                            retError.put("message", "Server error: " + response.code());
+                            retError.put("error", "response_error");
+                            callback.callback(retError);
+                            return;
+                        }
+
+                        if (responseData.isEmpty()) {
+                            Map<String, Object> retError = new HashMap<>();
+                            retError.put("message", "Empty response body");
+                            retError.put("error", "no_response_body");
+                            callback.callback(retError);
+                            return;
+                        }
+                        JSONObject jsonResponse = new JSONObject(responseData);
+
+                        // Check for server-side errors first
+                        if (jsonResponse.has("error")) {
+                            Map<String, Object> retError = new HashMap<>();
+                            retError.put("error", jsonResponse.getString("error"));
+                            if (jsonResponse.has("message")) {
+                                retError.put("message", jsonResponse.getString("message"));
+                            } else {
+                                retError.put("message", "server did not provide a message");
+                            }
+                            callback.callback(retError);
+                            return;
+                        }
+
+                        Map<String, Object> ret = new HashMap<>();
+
+                        Iterator<String> keys = jsonResponse.keys();
+                        while (keys.hasNext()) {
+                            String key = keys.next();
+                            if (jsonResponse.has(key)) {
+                                ret.put(key, jsonResponse.get(key));
+                            }
+                        }
+                        persistDefaultChannelFromResponse(ret.get("channel"), editor, defaultChannelKey);
+                        logger.info("Channel get to \"" + ret);
+                        callback.callback(ret);
+                    } catch (JSONException e) {
+                        Map<String, Object> retError = new HashMap<>();
+                        retError.put("message", "JSON parse error: " + e.getMessage());
+                        retError.put("error", "parse_error");
+                        callback.callback(retError);
+                    }
+                }
+            }
+        );
+    }
+
+    void persistDefaultChannelFromResponse(final Object channel, final SharedPreferences.Editor editor, final String defaultChannelKey) {
+        if (!(channel instanceof String)) {
+            return;
+        }
+
+        final String channelName = ((String) channel).trim();
+        if (channelName.isEmpty() || BundleInfo.ID_BUILTIN.equals(channelName)) {
+            return;
+        }
+
+        this.defaultChannel = channelName;
+        if (editor != null && defaultChannelKey != null && !defaultChannelKey.isEmpty()) {
+            editor.putString(defaultChannelKey, channelName);
+            editor.apply();
+        }
+        logger.info("defaultChannel synchronized from getChannel(): " + channelName);
+    }
+
+    public void listChannels(final Callback callback) {
+        if (isRemoteBlocked()) {
+            final RemoteBlockResult blocked = remoteBlockedClientError();
+            logger.debug("Skipping listChannels due to remote block (" + blocked.error + ").");
+            final Map<String, Object> retError = new HashMap<>();
+            retError.put("message", blocked.message);
+            retError.put("error", blocked.error);
+            callback.callback(retError);
+            return;
+        }
+
+        String channelUrl = this.channelUrl;
+        if (channelUrl == null || channelUrl.isEmpty()) {
+            logger.error("Channel URL is not set");
+            final Map<String, Object> retError = new HashMap<>();
+            retError.put("message", "Channel URL is not set");
+            retError.put("error", "missing_config");
+            callback.callback(retError);
+            return;
+        }
+
+        JSONObject json;
+        try {
+            json = this.createInfoObject();
+        } catch (JSONException e) {
+            logger.error("Error creating info object");
+            logger.debug("JSONException: " + e.getMessage());
+            final Map<String, Object> retError = new HashMap<>();
+            retError.put("message", "Cannot get info: " + e);
+            retError.put("error", "json_error");
+            callback.callback(retError);
+            return;
+        }
+
+        // Build URL with query parameters from JSON
+        HttpUrl.Builder urlBuilder = HttpUrl.parse(channelUrl).newBuilder();
+        try {
+            Iterator<String> keys = json.keys();
+            while (keys.hasNext()) {
+                String key = keys.next();
+                Object value = json.get(key);
+                if (value != null) {
+                    urlBuilder.addQueryParameter(key, value.toString());
+                }
+            }
+        } catch (JSONException e) {
+            logger.error("Error adding query parameters");
+            logger.debug("JSONException: " + e.getMessage());
+        }
+
+        Request request = new Request.Builder().url(urlBuilder.build()).get().build();
+
+        DownloadService.sharedClient.newCall(request).enqueue(
+            new okhttp3.Callback() {
+                @Override
+                public void onFailure(@NonNull Call call, @NonNull IOException e) {
+                    Map<String, Object> retError = new HashMap<>();
+                    retError.put("message", "Request failed: " + e.getMessage());
+                    retError.put("error", "network_error");
+                    callback.callback(retError);
+                }
+
+                @Override
+                public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
+                    try (ResponseBody responseBody = response.body()) {
+                        final String data = responseBody != null ? responseBody.string() : "";
+                        final RemoteBlockResult rateLimit = checkAndHandleRateLimitResponse(response, data);
+                        if (rateLimit.blocked) {
+                            Map<String, Object> retError = new HashMap<>();
+                            retError.put("message", rateLimit.message);
+                            retError.put("error", rateLimit.error);
+                            callback.callback(retError);
+                            return;
+                        }
+
+                        if (!response.isSuccessful()) {
+                            Map<String, Object> retError = new HashMap<>();
+                            retError.put("message", "Server error: " + response.code());
+                            retError.put("error", "response_error");
+                            callback.callback(retError);
+                            return;
+                        }
+
+                        if (data.isEmpty()) {
+                            Map<String, Object> retError = new HashMap<>();
+                            retError.put("message", "Empty response body");
+                            retError.put("error", "no_response_body");
+                            callback.callback(retError);
+                            return;
+                        }
+
+                        try {
+                            Map<String, Object> ret = parseListChannelsResponse(data);
+
+                            logger.info("Channels listed successfully");
+                            callback.callback(ret);
+                        } catch (JSONException arrayException) {
+                            // If not an array, try to parse as error object
+                            try {
+                                JSONObject json = new JSONObject(data);
+                                if (json.has("error")) {
+                                    Map<String, Object> retError = new HashMap<>();
+                                    retError.put("error", json.getString("error"));
+                                    if (json.has("message")) {
+                                        retError.put("message", json.getString("message"));
+                                    } else {
+                                        retError.put("message", "server did not provide a message");
+                                    }
+                                    callback.callback(retError);
+                                    return;
+                                }
+                                Map<String, Object> retError = new HashMap<>();
+                                retError.put("message", "Unexpected channels response format");
+                                retError.put("error", "parse_error");
+                                callback.callback(retError);
+                                return;
+                            } catch (JSONException objException) {
+                                // If neither array nor object, throw parse error
+                                arrayException.addSuppressed(objException);
+                                Map<String, Object> retError = new HashMap<>();
+                                retError.put("message", "JSON parse error: " + arrayException.getMessage());
+                                retError.put("error", "parse_error");
+                                callback.callback(retError);
+                            }
+                        }
+                    }
+                }
+            }
+        );
+    }
+
+    static Map<String, Object> parseListChannelsResponse(final String data) throws JSONException {
+        JSONArray channelsJson = new JSONArray(data);
+        List<Map<String, Object>> channelsList = new ArrayList<>();
+
+        for (int i = 0; i < channelsJson.length(); i++) {
+            JSONObject channelJson = channelsJson.getJSONObject(i);
+            Object channelId = channelJson.get("id");
+            if (!(channelId instanceof Number)) {
+                throw new JSONException("Channel id must be a number");
+            }
+            Map<String, Object> channel = new HashMap<>();
+            channel.put("id", channelId);
+            channel.put("name", channelJson.optString("name", ""));
+            channel.put("public", channelJson.optBoolean("public", false));
+            channel.put("allow_self_set", channelJson.optBoolean("allow_self_set", false));
+            channelsList.add(channel);
+        }
+
+        Map<String, Object> ret = new HashMap<>();
+        ret.put("channels", channelsList);
+        return ret;
+    }
+
+    public void sendStats(final String action) {
+        this.sendStats(action, this.getCurrentBundle().getVersionName());
+    }
+
+    public void sendStats(final String action, final String versionName) {
+        this.sendStats(action, versionName, "");
+    }
+
+    public void sendStats(final String action, final String versionName, final String oldVersionName) {
+        this.sendStats(action, versionName, oldVersionName, null);
+    }
+
+    public void sendStats(final String action, final String versionName, final String oldVersionName, final Map<String, String> metadata) {
+        this.sendStats(action, versionName, oldVersionName, metadata, null);
+    }
+
+    public void sendStats(
+        final String action,
+        final String versionName,
+        final String oldVersionName,
+        final Map<String, String> metadata,
+        final Runnable onSent
+    ) {
+        if (statsStopped.get()) {
+            return;
+        }
+
+        if (this.previewSession) {
+            if (logger != null) {
+                logger.debug("Skipping sendStats during preview session.");
+            }
+            return;
+        }
+
+        String statsUrl = this.statsUrl;
+        if (statsUrl == null || statsUrl.isEmpty()) {
+            return;
+        }
+
+        JSONObject json;
+        try {
+            json = this.createInfoObject();
+            json.put("version_name", versionName);
+            json.put("old_version_name", oldVersionName);
+            json.put("action", action);
+            json.put("timestamp", System.currentTimeMillis());
+            if (metadata != null && !metadata.isEmpty()) {
+                json.put("metadata", new JSONObject(metadata));
+            }
+        } catch (JSONException e) {
+            if (logger != null) {
+                logger.error("Error preparing stats");
+                logger.debug("JSONException: " + e.getMessage());
+            }
+            return;
+        }
+
+        synchronized (statsQueue) {
+            if (statsStopped.get()) {
+                return;
+            }
+            while (statsQueue.size() >= MAX_PENDING_STATS) {
+                statsQueue.remove(0);
+            }
+            statsQueue.add(new QueuedStatsEvent(json, onSent));
+        }
+        ensureStatsTimerStarted();
+    }
+
+    public void restorePendingStats() {
+        File file = pendingStatsFile();
+        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 {
+            String raw = readFileUtf8(file);
+            JSONArray arr = new JSONArray(raw);
+            synchronized (statsQueue) {
+                for (int i = 0; i < arr.length(); i++) {
+                    if (statsQueue.size() >= MAX_PENDING_STATS) {
+                        break;
+                    }
+                    statsQueue.add(new QueuedStatsEvent(arr.getJSONObject(i), null));
+                }
+            }
+            if (backup.exists() && !backup.delete()) {
+                if (logger != null) {
+                    logger.error("Failed to delete stats backup");
+                }
+            }
+            if (!statsQueue.isEmpty()) {
+                if (logger != null) {
+                    logger.info("Restored " + statsQueue.size() + " pending stats events");
+                }
+                ensureStatsTimerStarted();
+            }
+        } catch (Exception e) {
+            if (logger != null) {
+                logger.error("Failed to restore pending stats");
+                logger.debug("Error: " + e.getMessage());
+            }
+        }
+    }
+
+    int pendingStatsCount() {
+        return statsQueue.size();
+    }
+
+    public void persistPendingStats() {
+        persistStatsQueue();
+    }
+
+    private File pendingStatsFile() {
+        final File dir = this.noBackupDir != null ? this.noBackupDir : this.documentsDir;
+        if (dir == null) {
+            return null;
+        }
+        return new File(dir, PENDING_STATS_FILE);
+    }
+
+    private void persistStatsQueue() {
+        persistStatsQueue(false);
+    }
+
+    private void persistStatsQueue(final boolean force) {
+        File file = pendingStatsFile();
+        if (file == null) {
+            return;
+        }
+        synchronized (pendingStatsPersistLock) {
+            if (statsStopped.get() && !force) {
+                return;
+            }
+            JSONArray arr = new JSONArray();
+            synchronized (statsQueue) {
+                final List<QueuedStatsEvent> combined = new ArrayList<>(statsInFlight.size() + statsQueue.size());
+                combined.addAll(statsInFlight);
+                combined.addAll(statsQueue);
+                final int start = Math.max(0, combined.size() - MAX_PENDING_STATS);
+                for (int i = start; i < combined.size(); i++) {
+                    arr.put(combined.get(i).event);
+                }
+            }
+            try {
+                if (arr.length() == 0) {
+                    writeFileAtomically(file, "[]".getBytes(StandardCharsets.UTF_8));
+                    File backup = new File(file.getAbsolutePath() + ".bak");
+                    if (backup.exists() && !backup.delete()) {
+                        if (logger != null) {
+                            logger.error("Failed to delete empty stats backup");
+                        }
+                    }
+                    return;
+                }
+                writeFileAtomically(file, arr.toString().getBytes(StandardCharsets.UTF_8));
+            } catch (Exception e) {
+                if (logger != null) {
+                    logger.error("Failed to persist stats queue");
+                    logger.debug("Error: " + e.getMessage());
+                }
+            }
+        }
+    }
+
+    private static String readFileUtf8(final File file) throws IOException {
+        final long length = file.length();
+        final byte[] buf = new byte[length > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) length];
+        try (FileInputStream in = new FileInputStream(file)) {
+            int offset = 0;
+            while (offset < buf.length) {
+                final int read = in.read(buf, offset, buf.length - offset);
+                if (read < 0) {
+                    break;
+                }
+                offset += read;
+            }
+            return new String(buf, 0, offset, StandardCharsets.UTF_8);
+        }
+    }
+
+    private void writeFileAtomically(final File file, final byte[] bytes) throws IOException {
+        final File tmp = new File(file.getAbsolutePath() + ".tmp");
+        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()) {
+                    if (logger != null) {
+                        logger.error("Failed to delete stats backup");
+                    }
+                }
+                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();
+            }
+        }
+    }
+
+    private synchronized void ensureStatsTimerStarted() {
+        if (statsStopped.get()) {
+            return;
+        }
+        if (statsFlushTask == null || statsFlushTask.isCancelled() || statsFlushTask.isDone()) {
+            statsFlushTask = statsScheduler.scheduleAtFixedRate(
+                this::flushStatsQueue,
+                STATS_FLUSH_INTERVAL_MS,
+                STATS_FLUSH_INTERVAL_MS,
+                TimeUnit.MILLISECONDS
+            );
+        }
+    }
+
+    private void flushStatsQueue() {
+        if (statsStopped.get()) {
+            return;
+        }
+        if (statsQueue.isEmpty()) {
+            return;
+        }
+
+        // While Retry-After is active, keep stats queued and skip the network call.
+        if (isRemoteBlocked()) {
+            logger.debug("Deferring stats flush until Retry-After expires.");
+            return;
+        }
+
+        String statsUrl = this.statsUrl;
+        if (statsUrl == null || statsUrl.isEmpty()) {
+            synchronized (statsQueue) {
+                statsQueue.clear();
+                statsInFlight.clear();
+            }
+            persistStatsQueue();
+            return;
+        }
+
+        if (!statsFlushInFlight.compareAndSet(false, true)) {
+            return;
+        }
+
+        final List<QueuedStatsEvent> eventsToSend;
+        synchronized (statsQueue) {
+            if (statsQueue.isEmpty()) {
+                statsFlushInFlight.set(false);
+                return;
+            }
+            eventsToSend = new ArrayList<>(statsQueue);
+            statsQueue.clear();
+            statsInFlight.clear();
+            statsInFlight.addAll(eventsToSend);
+        }
+        persistStatsQueue();
+
+        JSONArray jsonArray = new JSONArray();
+        for (QueuedStatsEvent queuedEvent : eventsToSend) {
+            jsonArray.put(queuedEvent.event);
+        }
+
+        Request request = new Request.Builder()
+            .url(statsUrl)
+            .post(RequestBody.create(jsonArray.toString(), MediaType.get("application/json")))
+            .build();
+
+        final int eventCount = eventsToSend.size();
+        DownloadService.sharedClient.newCall(request).enqueue(
+            new okhttp3.Callback() {
+                @Override
+                public void onFailure(@NonNull Call call, @NonNull IOException e) {
+                    if (abandonStoppedStatsFlush()) {
+                        return;
+                    }
+                    requeueStatsEvents(eventsToSend);
+                    if (logger != null) {
+                        logger.error("Failed to send stats batch");
+                        logger.debug("Error: " + e.getMessage());
+                    }
+                    statsFlushInFlight.set(false);
+                }
+
+                @Override
+                public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
+                    try (ResponseBody responseBody = response.body()) {
+                        if (abandonStoppedStatsFlush()) {
+                            return;
+                        }
+                        final String responseData = responseBody != null ? responseBody.string() : "";
+                        if (checkAndHandleRateLimitResponse(response, responseData).blocked) {
+                            requeueStatsEvents(eventsToSend);
+                            return;
+                        }
+
+                        if (response.isSuccessful()) {
+                            synchronized (statsQueue) {
+                                statsInFlight.clear();
+                            }
+                            persistStatsQueue();
+                            if (logger != null) {
+                                logger.info("Stats batch sent successfully");
+                                logger.debug("Sent " + eventCount + " events");
+                            }
+                            runStatsCallbacks(eventsToSend);
+                        } else if (isTransientStatsFailure(response.code())) {
+                            requeueStatsEvents(eventsToSend);
+                            if (logger != null) {
+                                logger.error("Error sending stats batch");
+                                logger.debug("Retrying later, response code: " + response.code());
+                            }
+                        } else {
+                            synchronized (statsQueue) {
+                                statsInFlight.clear();
+                            }
+                            persistStatsQueue();
+                            if (logger != null) {
+                                logger.error("Dropping stats batch after permanent error");
+                                logger.debug("Response code: " + response.code());
+                            }
+                        }
+                    } finally {
+                        statsFlushInFlight.set(false);
+                    }
+                }
+            }
+        );
+    }
+
+    private boolean abandonStoppedStatsFlush() {
+        if (!statsStopped.get()) {
+            return false;
+        }
+        statsFlushInFlight.set(false);
+        return true;
+    }
+
+    /**
+     * Only 429, request timeout and 5xx are worth retrying; other 4xx are permanent rejections.
+     */
+    private static boolean isTransientStatsFailure(final int statusCode) {
+        return statusCode == 429 || statusCode == 408 || statusCode >= 500;
+    }
+
+    private void requeueStatsEvents(final List<QueuedStatsEvent> events) {
+        if (statsStopped.get() || events == null || events.isEmpty()) {
+            return;
+        }
+        synchronized (statsQueue) {
+            statsInFlight.clear();
+            statsQueue.addAll(0, events);
+            while (statsQueue.size() > MAX_PENDING_STATS) {
+                statsQueue.remove(0);
+            }
+        }
+        persistStatsQueue();
+        ensureStatsTimerStarted();
+    }
+
+    private void runStatsCallbacks(final List<QueuedStatsEvent> sentEvents) {
+        for (final QueuedStatsEvent sentEvent : sentEvents) {
+            if (sentEvent.onSent == null) {
+                continue;
+            }
+
+            try {
+                sentEvent.onSent.run();
+            } catch (Exception e) {
+                if (logger != null) {
+                    logger.error("Error running stats sent callback");
+                    logger.debug("Error: " + e.getMessage());
+                }
+            }
+        }
+    }
+
+    public BundleInfo getBundleInfo(final String id) {
+        String trueId = BundleInfo.VERSION_UNKNOWN;
+        if (id != null) {
+            trueId = id;
+        }
+        BundleInfo result;
+        if (BundleInfo.ID_BUILTIN.equals(trueId)) {
+            result = new BundleInfo(
+                trueId,
+                this.versionBuild == null || this.versionBuild.isEmpty() ? null : this.versionBuild,
+                BundleStatus.SUCCESS,
+                "",
+                ""
+            );
+        } else if (BundleInfo.VERSION_UNKNOWN.equals(trueId)) {
+            result = new BundleInfo(trueId, null, BundleStatus.ERROR, "", "");
+        } else {
+            try {
+                String stored = this.prefs.getString(trueId + INFO_SUFFIX, "");
+                if (stored.isEmpty()) {
+                    result = new BundleInfo(trueId, null, BundleStatus.PENDING, "", "");
+                } else {
+                    result = BundleInfo.fromJSON(stored);
+                }
+            } catch (JSONException e) {
+                logger.error("Failed to parse bundle info");
+                logger.debug("Bundle ID: " + trueId + ", Error: " + e.getMessage());
+                // Clear corrupted data
+                this.editor.remove(trueId + INFO_SUFFIX);
+                this.editor.commit();
+                result = new BundleInfo(trueId, null, BundleStatus.ERROR, "", "");
+            }
+        }
+        return result;
+    }
+
+    public BundleInfo getBundleInfoByName(final String versionName) {
+        final List<BundleInfo> installed = this.list(false);
+        for (final BundleInfo i : installed) {
+            if (i.getVersionName().equals(versionName)) {
+                return i;
+            }
+        }
+        return null;
+    }
+
+    private void removeBundleInfo(final String id) {
+        this.saveBundleInfo(id, null);
+    }
+
+    public boolean saveBundleInfo(final String id, final BundleInfo info) {
+        if (id == null || (info != null && (info.isBuiltin() || info.isUnknown()))) {
+            logger.debug("Not saving info for bundle: [" + id + "] " + info);
+            return false;
+        }
+
+        if (info == null) {
+            logger.debug("Removing info for bundle [" + id + "]");
+            this.editor.remove(id + INFO_SUFFIX);
+        } else {
+            final BundleInfo update = info.setId(id);
+            String jsonString = update.toString();
+            logger.debug("Storing info for bundle [" + id + "] " + update.getClass().getName() + " -> " + jsonString);
+            this.editor.putString(id + INFO_SUFFIX, jsonString);
+        }
+        return this.editor.commit();
+    }
+
+    private void setBundleStatus(final String id, final BundleStatus status) {
+        if (id != null && status != null) {
+            BundleInfo info = this.getBundleInfo(id);
+            logger.debug("Setting status for bundle [" + id + "] to " + status);
+            this.saveBundleInfo(id, info.setStatus(status));
+        }
+    }
+
+    private String getCurrentBundleId() {
+        if (this.isUsingBuiltin()) {
+            return BundleInfo.ID_BUILTIN;
+        } else {
+            final String path = this.getCurrentBundlePath();
+            return path.substring(path.lastIndexOf('/') + 1);
+        }
+    }
+
+    public BundleInfo getCurrentBundle() {
+        return this.getBundleInfo(this.getCurrentBundleId());
+    }
+
+    public String getCurrentBundlePath() {
+        String path = this.prefs.getString(this.CAP_SERVER_PATH, "public");
+        if (path.trim().isEmpty()) {
+            return "public";
+        }
+        return path;
+    }
+
+    public Boolean isUsingBuiltin() {
+        return this.getCurrentBundlePath().equals("public");
+    }
+
+    public BundleInfo getFallbackBundle() {
+        final String id = this.prefs.getString(FALLBACK_VERSION, BundleInfo.ID_BUILTIN);
+        return this.getBundleInfo(id);
+    }
+
+    private void setFallbackBundle(final BundleInfo fallback) {
+        this.editor.putString(FALLBACK_VERSION, fallback == null ? BundleInfo.ID_BUILTIN : fallback.getId());
+        this.editor.commit();
+    }
+
+    public BundleInfo getNextBundle() {
+        final String id = this.prefs.getString(NEXT_VERSION, null);
+        if (id == null) return null;
+        return this.getBundleInfo(id);
+    }
+
+    public BundleInfo getPreviewFallbackBundle() {
+        final String id = this.prefs.getString(PREVIEW_FALLBACK_VERSION, null);
+        if (id == null) return null;
+        final BundleInfo bundle = this.getBundleInfo(id);
+        if (bundle.isErrorStatus() || (!bundle.isBuiltin() && !this.bundleExists(id))) {
+            this.setPreviewFallbackBundle(null);
+            return null;
+        }
+        return bundle;
+    }
+
+    public boolean setPreviewFallbackBundle(final String fallback) {
+        if (fallback == null) {
+            this.editor.remove(PREVIEW_FALLBACK_VERSION);
+        } else {
+            final BundleInfo newBundle = this.getBundleInfo(fallback);
+            if (newBundle.isErrorStatus() || (!newBundle.isBuiltin() && !this.bundleExists(fallback))) {
+                return false;
+            }
+            this.editor.putString(PREVIEW_FALLBACK_VERSION, fallback);
+        }
+        this.editor.commit();
+        return true;
+    }
+
+    public boolean setNextBundle(final String next) {
+        BundleInfo bundleToNotify = null;
+        if (next == null) {
+            this.editor.remove(NEXT_VERSION);
+        } else {
+            final BundleInfo newBundle = this.getBundleInfo(next);
+            if (!newBundle.isBuiltin() && !this.bundleExists(next)) {
+                return false;
+            }
+            this.editor.putString(NEXT_VERSION, next);
+            this.setBundleStatus(next, BundleStatus.PENDING);
+            bundleToNotify = newBundle;
+        }
+        this.editor.commit();
+        if (bundleToNotify != null) {
+            this.sendStats("set_next", bundleToNotify.getVersionName(), this.getCurrentBundle().getVersionName());
+            final Map<String, Object> payload = new HashMap<>();
+            payload.put("bundle", bundleToNotify.toJSONMap());
+            this.notifyListeners("setNext", payload);
+        }
+        return true;
+    }
+
+    /**
+     * Shuts down the stats scheduler and flushes any pending stats.
+     * Should be called when the plugin is destroyed to prevent resource leaks.
+     */
+    public void shutdown() {
+        statsStopped.set(true);
+        // Cancel the scheduled task
+        if (statsFlushTask != null) {
+            statsFlushTask.cancel(false);
+            statsFlushTask = null;
+        }
+
+        // Write once, then ignore later callbacks so they cannot delete a newer instance's file.
+        persistStatsQueue(true);
+
+        // Shutdown the scheduler
+        statsScheduler.shutdown();
+        try {
+            if (!statsScheduler.awaitTermination(2, TimeUnit.SECONDS)) {
+                statsScheduler.shutdownNow();
+            }
+        } catch (InterruptedException e) {
+            statsScheduler.shutdownNow();
+            Thread.currentThread().interrupt();
+        }
+    }
+}