@capgo/capacitor-updater 4.41.0 → 4.43.5

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

@@ -0,0 +1,156 @@
+package ee.forgr.capacitor_updater;
+
+import android.content.Context;
+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.WorkManager;
+import androidx.work.WorkRequest;
+import java.util.concurrent.TimeUnit;
+
+public class DownloadWorkerManager {
+
+    private static Logger logger;
+
+    public static void setLogger(Logger loggerInstance) {
+        logger = loggerInstance;
+    }
+
+    private static volatile boolean isInitialized = false;
+
+    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 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.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");
+
+        // 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());
+        WorkManager.getInstance(context).cancelAllWorkByTag(version);
+    }
+
+    public static void cancelBundleDownload(Context context, String id, String version) {
+        String uniqueWorkName = "bundle_" + id + "_" + version;
+        initializeIfNeeded(context.getApplicationContext());
+        WorkManager.getInstance(context).cancelUniqueWork(uniqueWorkName);
+    }
+
+    public static void cancelAllDownloads(Context context) {
+        initializeIfNeeded(context.getApplicationContext());
+        WorkManager.getInstance(context).cancelAllWorkByTag("capacitor_updater_download");
+    }
+}

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

@@ -0,0 +1,45 @@
+package ee.forgr.capacitor_updater;
+
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import com.getcapacitor.JSObject;
+import java.util.Map;
+
+public class InternalUtils {
+
+    /**
+     * Converts a Map to JSObject 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 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/android/src/main/java/ee/forgr/capacitor_updater/Logger.java

@@ -0,0 +1,360 @@
+package ee.forgr.capacitor_updater;
+
+import android.util.ArrayMap;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.*;
+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 {
+
+    private Bridge bridge;
+
+    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 void setBridge(Bridge bridge) {
+        this.bridge = bridge;
+    }
+
+    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;
+            }
+        }
+
+        // Send to JavaScript if webView is available
+        if (bridge != null && bridge.getWebView() != null) {
+            bridge.eval(
+                "console." + level.name() + "(\"[" + tag.replace("\"", "\\\"") + "] " + formattedMessage.replace("\"", "\\\"") + "\")",
+                null
+            );
+        }
+    }
+
+    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));
+    }
+}

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

@@ -0,0 +1,72 @@
+/*
+ * 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 ee.forgr.capacitor_updater;
+
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+
+public class ShakeDetector implements SensorEventListener {
+
+    public interface Listener {
+        void onShakeDetected();
+    }
+
+    private static final float SHAKE_THRESHOLD = 12.0f; // Acceleration threshold for shake detection
+    private static final int SHAKE_TIMEOUT = 500; // Minimum time between shake events (ms)
+
+    private Listener listener;
+    private SensorManager sensorManager;
+    private Sensor accelerometer;
+    private long lastShakeTime = 0;
+
+    public ShakeDetector(Listener listener) {
+        this.listener = listener;
+    }
+
+    public void start(SensorManager sensorManager) {
+        this.sensorManager = sensorManager;
+        this.accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
+
+        if (accelerometer != null) {
+            sensorManager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_GAME);
+        }
+    }
+
+    public void stop() {
+        if (sensorManager != null) {
+            sensorManager.unregisterListener(this);
+        }
+    }
+
+    @Override
+    public void onSensorChanged(SensorEvent event) {
+        if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
+            float x = event.values[0];
+            float y = event.values[1];
+            float z = event.values[2];
+
+            // Calculate the acceleration magnitude (excluding gravity)
+            float acceleration = (float) Math.sqrt(x * x + y * y + z * z) - SensorManager.GRAVITY_EARTH;
+
+            // Check if acceleration exceeds threshold and enough time has passed
+            long currentTime = System.currentTimeMillis();
+            if (Math.abs(acceleration) > SHAKE_THRESHOLD && currentTime - lastShakeTime > SHAKE_TIMEOUT) {
+                lastShakeTime = currentTime;
+                if (listener != null) {
+                    listener.onShakeDetected();
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onAccuracyChanged(Sensor sensor, int accuracy) {
+        // Not needed for shake detection
+    }
+}