@capgo/capacitor-updater 8.0.1 → 8.2.0

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

@@ -1,24 +1,26 @@
 package ee.forgr.capacitor_updater;
 
 import android.content.Context;
-import android.util.Log;
 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.HashSet;
-import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
 public class DownloadWorkerManager {
 
-    private static final String TAG = "DownloadWorkerManager";
+    private static Logger logger;
+
+    public static void setLogger(Logger loggerInstance) {
+        logger = loggerInstance;
+    }
+
     private static volatile boolean isInitialized = false;
-    private static final Set<String> activeVersions = new HashSet<>();
 
     private static synchronized void initializeIfNeeded(Context context) {
         if (!isInitialized) {
@@ -32,8 +34,18 @@ public class DownloadWorkerManager {
         }
     }
 
-    public static synchronized boolean isVersionDownloading(String version) {
-        return activeVersions.contains(version);
+    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(
@@ -46,16 +58,23 @@ public class DownloadWorkerManager {
         String sessionKey,
         String checksum,
         String publicKey,
-        boolean isManifest
+        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());
 
-        // If version is already downloading, don't start another one
-        if (isVersionDownloading(version)) {
-            Log.i(TAG, "Version " + version + " is already downloading");
-            return;
-        }
-        activeVersions.add(version);
+        // Use unique work name for this bundle to prevent duplicates
+        String uniqueWorkName = "bundle_" + id + "_" + version;
 
         // Create input data
         Data inputData = new Data.Builder()
@@ -68,34 +87,70 @@ public class DownloadWorkerManager {
             .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
-        Constraints constraints = new Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).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 workRequest = new OneTimeWorkRequest.Builder(DownloadService.class)
+        OneTimeWorkRequest.Builder workRequestBuilder = new OneTimeWorkRequest.Builder(DownloadService.class)
             .setConstraints(constraints)
             .setInputData(inputData)
             .addTag(id)
-            .addTag(version) // Add version tag for tracking
-            .addTag("capacitor_updater_download")
-            .setBackoffCriteria(BackoffPolicy.LINEAR, WorkRequest.MIN_BACKOFF_MILLIS, TimeUnit.MILLISECONDS)
-            .build();
+            .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();
 
-        // Enqueue work
-        WorkManager.getInstance(context).enqueue(workRequest);
+        // 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);
-        activeVersions.remove(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");
-        activeVersions.clear();
     }
 }

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

@@ -0,0 +1,338 @@
+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;
+
+        Options() {
+            level = LogLevel.info;
+            labels = null;
+        }
+
+        Options(@NonNull Options other) {
+            level = other.level;
+            labels = other.labels;
+        }
+
+        Options(LogLevel level) {
+            this.level = level;
+            this.labels = null;
+        }
+
+        Options(Map<String, String> labels) {
+            this.level = LogLevel.info;
+            this.labels = labels;
+        }
+
+        Options(LogLevel level, Map<String, String> labels) {
+            this.level = level;
+            this.labels = labels;
+        }
+    }
+
+    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";
+
+    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.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;
+        }
+
+        // Always log to Android system log
+        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
+    }
+}