@capgo/cordova-updater 8.1.1

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

@@ -0,0 +1,260 @@
+package app.capgo.cordova.updater;
+
+import android.content.Context;
+import android.os.Build;
+import androidx.work.BackoffPolicy;
+import androidx.work.Configuration;
+import androidx.work.Constraints;
+import androidx.work.Data;
+import androidx.work.ExistingWorkPolicy;
+import androidx.work.NetworkType;
+import androidx.work.OneTimeWorkRequest;
+import androidx.work.OutOfQuotaPolicy;
+import androidx.work.WorkInfo;
+import androidx.work.WorkManager;
+import androidx.work.WorkRequest;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+public class DownloadWorkerManager {
+
+    private static Logger logger;
+
+    public static void setLogger(Logger loggerInstance) {
+        logger = loggerInstance;
+    }
+
+    private static volatile boolean isInitialized = false;
+    private static final ExecutorService cancelExecutor = Executors.newSingleThreadExecutor();
+
+    private static synchronized void initializeIfNeeded(Context context) {
+        if (!isInitialized) {
+            try {
+                Configuration config = new Configuration.Builder().setMinimumLoggingLevel(android.util.Log.INFO).build();
+                WorkManager.initialize(context, config);
+                isInitialized = true;
+            } catch (IllegalStateException e) {
+                // WorkManager was already initialized, ignore
+            }
+        }
+    }
+
+    public static boolean isVersionDownloading(Context context, String version) {
+        initializeIfNeeded(context.getApplicationContext());
+        try {
+            return WorkManager.getInstance(context)
+                .getWorkInfosByTag(version)
+                .get()
+                .stream()
+                .anyMatch((workInfo) -> !workInfo.getState().isFinished());
+        } catch (Exception e) {
+            logger.error("Error checking download status: " + e.getMessage());
+            return false;
+        }
+    }
+
+    public static void enqueueDownload(
+        Context context,
+        String url,
+        String id,
+        String documentsDir,
+        String dest,
+        String version,
+        String sessionKey,
+        String checksum,
+        String publicKey,
+        boolean isManifest,
+        boolean isEmulator,
+        String appId,
+        String pluginVersion,
+        boolean isProd,
+        String installSource,
+        String statsUrl,
+        String deviceId,
+        String versionBuild,
+        String versionCode,
+        String versionOs,
+        String customId,
+        String defaultChannel
+    ) {
+        initializeIfNeeded(context.getApplicationContext());
+
+        // Use unique work name for this bundle to prevent duplicates
+        String uniqueWorkName = "bundle_" + id + "_" + version;
+
+        // Create input data
+        Data inputData = new Data.Builder()
+            .putString(DownloadService.URL, url)
+            .putString(DownloadService.ID, id)
+            .putString(DownloadService.DOCDIR, documentsDir)
+            .putString(DownloadService.FILEDEST, dest)
+            .putString(DownloadService.VERSION, version)
+            .putString(DownloadService.SESSIONKEY, sessionKey)
+            .putString(DownloadService.CHECKSUM, checksum)
+            .putBoolean(DownloadService.IS_MANIFEST, isManifest)
+            .putString(DownloadService.PUBLIC_KEY, publicKey)
+            .putString(DownloadService.APP_ID, appId)
+            .putString(DownloadService.pluginVersion, pluginVersion)
+            .putString(DownloadService.INSTALL_SOURCE, installSource)
+            .putString(DownloadService.STATS_URL, statsUrl)
+            .putString(DownloadService.DEVICE_ID, deviceId)
+            .putString(DownloadService.VERSION_BUILD, versionBuild)
+            .putString(DownloadService.VERSION_CODE, versionCode)
+            .putString(DownloadService.VERSION_OS, versionOs)
+            .putString(DownloadService.CUSTOM_ID, customId)
+            .putString(DownloadService.DEFAULT_CHANNEL, defaultChannel)
+            .putBoolean(DownloadService.IS_PROD, isProd)
+            .putBoolean(DownloadService.IS_EMULATOR, isEmulator)
+            .build();
+
+        // Create network constraints - be more lenient on emulators
+        Constraints.Builder constraintsBuilder = new Constraints.Builder();
+        if (isEmulator) {
+            logger.info("Emulator detected - using lenient network constraints");
+            // On emulators, use NOT_REQUIRED to avoid background network issues
+            constraintsBuilder.setRequiredNetworkType(NetworkType.NOT_REQUIRED);
+        } else {
+            constraintsBuilder.setRequiredNetworkType(NetworkType.CONNECTED);
+        }
+        Constraints constraints = constraintsBuilder.build();
+
+        // Create work request with tags for tracking
+        OneTimeWorkRequest.Builder workRequestBuilder = new OneTimeWorkRequest.Builder(DownloadService.class)
+            .setConstraints(constraints)
+            .setInputData(inputData)
+            .addTag(id)
+            .addTag(version)
+            .addTag("capacitor_updater_download");
+        // Android 12+ expedited jobs skip the WorkManager delay without a
+        // foreground service. Older APIs require getForegroundInfo().
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            workRequestBuilder.setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST);
+        }
+
+        // More aggressive retry policy for emulators
+        if (isEmulator) {
+            workRequestBuilder.setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS);
+        } else {
+            workRequestBuilder.setBackoffCriteria(BackoffPolicy.LINEAR, WorkRequest.MIN_BACKOFF_MILLIS, TimeUnit.MILLISECONDS);
+        }
+
+        OneTimeWorkRequest workRequest = workRequestBuilder.build();
+
+        // Use beginUniqueWork to prevent duplicate downloads
+        WorkManager.getInstance(context)
+            .beginUniqueWork(
+                uniqueWorkName,
+                ExistingWorkPolicy.KEEP, // Don't start if already running
+                workRequest
+            )
+            .enqueue();
+    }
+
+    public static void cancelVersionDownload(Context context, String version) {
+        initializeIfNeeded(context.getApplicationContext());
+        cancelExecutor.execute(() -> cancelVersionDownloadInternal(context, version, false));
+    }
+
+    public static boolean cancelVersionDownloadAndAwait(Context context, String version) {
+        initializeIfNeeded(context.getApplicationContext());
+        Future<?> future = cancelExecutor.submit(() -> cancelVersionDownloadInternal(context, version, true));
+        try {
+            future.get(10, TimeUnit.SECONDS);
+            return true;
+        } catch (TimeoutException e) {
+            future.cancel(true);
+            logger.error("Timed out awaiting version download cancel");
+            return false;
+        } catch (Exception e) {
+            logger.error("Error awaiting version download cancel: " + e.getMessage());
+            return false;
+        }
+    }
+
+    private static Set<String> collectManifestIdsForVersion(WorkManager workManager, String version) {
+        Set<String> downloadIds = new HashSet<>();
+        try {
+            List<WorkInfo> workInfos = workManager.getWorkInfosByTag(version).get(5, TimeUnit.SECONDS);
+            for (WorkInfo workInfo : workInfos) {
+                for (String tag : workInfo.getTags()) {
+                    if (!"capacitor_updater_download".equals(tag) && !version.equals(tag)) {
+                        downloadIds.add(tag);
+                    }
+                }
+            }
+        } catch (TimeoutException e) {
+            logger.error("Timed out collecting manifest ids before version cancel");
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new IllegalStateException("Interrupted while collecting manifest ids before version cancel", e);
+        } catch (Exception e) {
+            logger.error("Error collecting manifest ids before version cancel: " + e.getMessage());
+        }
+        return downloadIds;
+    }
+
+    private static void clearManifestIds(Set<String> downloadIds) {
+        for (String downloadId : downloadIds) {
+            DataManager.getInstance().clearManifest(downloadId);
+        }
+    }
+
+    private static void cancelVersionDownloadInternal(Context context, String version, boolean awaitFinished) {
+        if (Thread.currentThread().isInterrupted()) {
+            return;
+        }
+        WorkManager workManager = WorkManager.getInstance(context);
+        Set<String> downloadIds = collectManifestIdsForVersion(workManager, version);
+        workManager.cancelAllWorkByTag(version);
+        clearManifestIds(downloadIds);
+        if (awaitFinished) {
+            awaitVersionWorkFinished(workManager, version);
+        }
+    }
+
+    private static void awaitVersionWorkFinished(WorkManager workManager, String version) {
+        for (int i = 0; i < 100; i++) {
+            if (Thread.currentThread().isInterrupted()) {
+                throw new IllegalStateException("Interrupted while waiting for version download cancel");
+            }
+            try {
+                boolean anyActive = workManager
+                    .getWorkInfosByTag(version)
+                    .get()
+                    .stream()
+                    .anyMatch((workInfo) -> !workInfo.getState().isFinished());
+                if (!anyActive) {
+                    return;
+                }
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                throw new IllegalStateException("Interrupted while waiting for download cancel", e);
+            } catch (Exception e) {
+                throw new IllegalStateException("Error waiting for download cancel: " + e.getMessage(), e);
+            }
+        }
+        throw new IllegalStateException("Timed out waiting for version download cancel: " + version);
+    }
+
+    public static void cancelBundleDownload(Context context, String id, String version) {
+        String uniqueWorkName = "bundle_" + id + "_" + version;
+        initializeIfNeeded(context.getApplicationContext());
+        WorkManager workManager = WorkManager.getInstance(context);
+        workManager.cancelUniqueWork(uniqueWorkName);
+        DataManager.getInstance().clearManifest(id);
+    }
+
+    public static void cancelAllDownloads(Context context) {
+        initializeIfNeeded(context.getApplicationContext());
+        WorkManager workManager = WorkManager.getInstance(context);
+        workManager.cancelAllWorkByTag("capacitor_updater_download");
+        DataManager.getInstance().clearAllManifests();
+    }
+}

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

@@ -0,0 +1,54 @@
+package app.capgo.cordova.updater;
+
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import app.capgo.cordova.updater.compat.JSObject;
+import org.json.JSONObject;
+import java.util.Map;
+
+public class InternalUtils {
+
+    /**
+     * Converts a Map to JSONObject for proper bridge serialization.
+     */
+    public static JSObject mapToJSObject(Map<String, Object> map) {
+        JSObject jsObject = new JSObject();
+        for (Map.Entry<String, Object> entry : map.entrySet()) {
+            jsObject.put(entry.getKey(), entry.getValue());
+        }
+        return jsObject;
+    }
+
+    public static JSONObject mapToJSONObject(Map<String, Object> map) {
+        JSONObject jsObject = new JSONObject();
+        for (Map.Entry<String, Object> entry : map.entrySet()) {
+            try { jsObject.put(entry.getKey(), entry.getValue()); } catch (org.json.JSONException ignored) {}
+        }
+        return jsObject;
+    }
+
+    public static String getPackageName(PackageManager pm, String packageName) {
+        try {
+            PackageInfo pInfo = getPackageInfoInternal(pm, packageName);
+            return (pInfo != null) ? pInfo.packageName : null;
+        } catch (PackageManager.NameNotFoundException e) {
+            // Exception is handled internally, and null is returned to indicate the package name could not be retrieved
+            return null;
+        }
+    }
+
+    private static PackageInfo getPackageInfoInternal(PackageManager pm, String packageName) throws PackageManager.NameNotFoundException {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            return pm.getPackageInfo(packageName, PackageManager.PackageInfoFlags.of(0));
+        } else {
+            return getPackageInfoLegacy(pm, packageName, (int) (long) 0);
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+    private static PackageInfo getPackageInfoLegacy(PackageManager pm, String packageName, int flags)
+        throws PackageManager.NameNotFoundException {
+        return pm.getPackageInfo(packageName, flags);
+    }
+}

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

@@ -0,0 +1,345 @@
+package app.capgo.cordova.updater;
+
+import android.util.ArrayMap;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.Locale;
+import java.util.Map;
+import org.jetbrains.annotations.Contract;
+
+public class Logger {
+
+    public enum LogLevel {
+        silent,
+        error,
+        warn,
+        info,
+        debug
+    }
+
+    public static class Options {
+
+        LogLevel level;
+        Map<String, String> labels;
+        boolean useSystemLog;
+
+        Options() {
+            level = LogLevel.info;
+            labels = null;
+            useSystemLog = true; // Default to true for backward compatibility
+        }
+
+        Options(@NonNull Options other) {
+            level = other.level;
+            labels = other.labels;
+            useSystemLog = other.useSystemLog;
+        }
+
+        Options(LogLevel level) {
+            this.level = level;
+            this.labels = null;
+            useSystemLog = true;
+        }
+
+        Options(Map<String, String> labels) {
+            this.level = LogLevel.info;
+            this.labels = labels;
+            useSystemLog = true;
+        }
+
+        Options(LogLevel level, Map<String, String> labels) {
+            this.level = level;
+            this.labels = labels;
+            useSystemLog = true;
+        }
+
+        Options(LogLevel level, Map<String, String> labels, boolean useSystemLog) {
+            this.level = level;
+            this.labels = labels;
+            this.useSystemLog = useSystemLog;
+        }
+
+        Options(boolean useSystemLog) {
+            this.level = LogLevel.info;
+            this.labels = null;
+            this.useSystemLog = useSystemLog;
+        }
+    }
+
+    public LogLevel level;
+    private final Map<LogLevel, String> labels = new ArrayMap<>();
+    private String tag;
+    private final ArrayMap<String, Long> timers = new ArrayMap<>();
+    private final String kDefaultTimerLabel = "default";
+    private boolean useSystemLog;
+
+    public Logger(String tag) {
+        super();
+        init(tag, new Options());
+    }
+
+    public Logger(String tag, Options options) {
+        super();
+        init(tag, options);
+    }
+
+    private void init(String tag, @NonNull Options options) {
+        this.level = options.level;
+        this.useSystemLog = options.useSystemLog;
+        this.labels.putAll(
+            Map.of(LogLevel.silent, "", LogLevel.error, "🔴", LogLevel.warn, "🟠", LogLevel.info, "🟢", LogLevel.debug, "\uD83D\uDD0E")
+        );
+
+        if (options.labels != null) {
+            setLabels(options.labels);
+        }
+
+        this.tag = tag;
+    }
+
+    @Nullable
+    public Object getLevelWithName(String name) {
+        try {
+            return LogLevel.valueOf(name);
+        } catch (IllegalArgumentException ex) {
+            return null;
+        }
+    }
+
+    public String getLevelName() {
+        return level.name();
+    }
+
+    public void setLevelName(String name) {
+        try {
+            level = LogLevel.valueOf(name);
+        } catch (IllegalArgumentException e) {
+            // Ignore it
+        }
+    }
+
+    public Map<String, String> getLabels() {
+        ArrayMap<String, String> result = new ArrayMap<>();
+
+        for (Map.Entry<LogLevel, String> entry : labels.entrySet()) {
+            result.put(entry.getKey().name(), entry.getValue());
+        }
+
+        return result;
+    }
+
+    public void setLabels(@NonNull Map<String, String> labels) {
+        for (Map.Entry<String, String> entry : labels.entrySet()) {
+            Object level = getLevelWithName(entry.getKey());
+
+            if (level != null) {
+                this.labels.put((LogLevel) level, entry.getValue());
+            }
+        }
+    }
+
+    public String getTag() {
+        return tag;
+    }
+
+    public void setTag(@NonNull String tag) {
+        if (!tag.isEmpty()) {
+            this.tag = tag;
+        }
+    }
+
+    public void error(String message) {
+        logWithTagAtLevel(LogLevel.error, "", tag, message);
+    }
+
+    public void warn(String message) {
+        logWithTagAtLevel(LogLevel.warn, "", tag, message);
+    }
+
+    public void info(String message) {
+        logWithTagAtLevel(LogLevel.info, "", tag, message);
+    }
+
+    public void log(String message) {
+        info(message);
+    }
+
+    public void debug(String message) {
+        logWithTagAtLevel(LogLevel.debug, "", tag, message);
+    }
+
+    public void logAtLevel(LogLevel level, String message) {
+        logWithTagAtLevel(level, "", tag, message);
+    }
+
+    public void logAtLevel(String level, String message) {
+        logWithTagAtLevel(resolveLevelName(level), "", tag, message);
+    }
+
+    public void logWithTagAtLevel(LogLevel level, String tag, String message) {
+        logWithTagAtLevel(level, "", tag, message);
+    }
+
+    public void logWithTagAtLevel(String level, String tag, String message) {
+        logWithTagAtLevel(resolveLevelName(level), "", tag, message);
+    }
+
+    private LogLevel resolveLevelName(String name) {
+        Object level = getLevelWithName(name);
+
+        if (level != null) {
+            return (LogLevel) level;
+        }
+
+        return LogLevel.info;
+    }
+
+    public void logWithTagAtLevel(LogLevel level, String label, String tag, String message) {
+        if (this.level.compareTo(level) < 0) {
+            return;
+        }
+
+        if (label.isEmpty()) {
+            label = labels.get(level);
+        }
+
+        // If the label is ASCII, surround it with []
+        String format;
+
+        if (label != null) {
+            format = label.charAt(0) <= 127 ? "[%s]: %s" : "%s %s";
+        } else {
+            label = "";
+            format = "%s%s";
+        }
+
+        String formattedMessage = String.format(format, label, message);
+
+        if (tag.isEmpty()) {
+            tag = this.tag;
+        }
+
+        // Log to Android system log if enabled
+        if (useSystemLog) {
+            switch (level) {
+                case error:
+                    Log.e(tag, formattedMessage);
+                    break;
+                case warn:
+                    Log.w(tag, formattedMessage);
+                    break;
+                case info:
+                    Log.i(tag, formattedMessage);
+                    break;
+                case debug:
+                    Log.d(tag, formattedMessage);
+                    break;
+            }
+        }
+    }
+
+    public void dir(Object value) {
+        String message;
+
+        if (value != null) {
+            if (value.getClass().isArray()) {
+                Object[] arr = (Object[]) value;
+                message = Arrays.deepToString(arr);
+            } else {
+                try {
+                    message = value.toString();
+                } catch (Exception ex) {
+                    message = String.format("<%s>", ex.getMessage());
+                }
+            }
+        } else {
+            message = "null";
+        }
+
+        info(message);
+    }
+
+    public void time() {
+        time(kDefaultTimerLabel);
+    }
+
+    public void time(String label) {
+        timers.put(label, new Date().getTime());
+    }
+
+    public void timeLog() {
+        timeLog(kDefaultTimerLabel);
+    }
+
+    public void timeLog(String label) {
+        label = resolveTimerLabel(label);
+
+        if (timers.containsKey(label)) {
+            Long start = timers.get(label);
+
+            // This will always be true
+            if (start != null) {
+                long now = new Date().getTime();
+                long diff = now - start;
+                info(String.format(Locale.getDefault(), "%s: %s", label, formatMilliseconds(diff)));
+            }
+        } else {
+            warn(String.format("timer '%s' does not exist", label));
+        }
+    }
+
+    public void timeEnd() {
+        timeEnd(kDefaultTimerLabel);
+    }
+
+    public void timeEnd(String label) {
+        label = resolveTimerLabel(label);
+        timeLog(label);
+        timers.remove(label);
+    }
+
+    @Contract(pure = true)
+    private String resolveTimerLabel(@NonNull String label) {
+        return label.isEmpty() ? kDefaultTimerLabel : label;
+    }
+
+    @NonNull
+    private String formatMilliseconds(long milliseconds) {
+        long seconds = Math.floorDiv(milliseconds, 1000);
+        long minutes = Math.floorDiv(seconds, 60);
+        long hours = Math.floorDiv(minutes, 60);
+        long millis = milliseconds % 1000;
+
+        if (seconds < 1) {
+            return String.format(Locale.getDefault(), "%dms", milliseconds);
+        }
+
+        if (minutes < 1) {
+            return String.format(Locale.getDefault(), "%d.%ds", seconds, millis);
+        }
+
+        seconds = seconds % 60;
+
+        if (hours < 1) {
+            return String.format(Locale.getDefault(), "%d:%02d.%03d (min:sec.ms)", minutes, seconds, millis);
+        }
+
+        minutes = minutes % 60;
+        return String.format(Locale.getDefault(), "%d:%02d:%02d (hr:min:sec)", hours, minutes, seconds);
+    }
+
+    public void trace() {
+        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
+        ArrayList<String> stack = new ArrayList<>();
+
+        for (StackTraceElement element : stackTrace) {
+            stack.add(element.toString());
+        }
+
+        info("trace\n" + String.join("\n", stack));
+    }
+}