@capgo/cordova-updater 8.1.1

package/src/android/app/capgo/cordova/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 app.capgo.cordova.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 = 16.0f; // Acceleration threshold for shake detection
+    private static final int SHAKE_TIMEOUT = 1000; // 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_UI);
+        }
+    }
+
+    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
+    }
+}

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

@@ -0,0 +1,39 @@
+/*
+ * 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;
+
+/**
+ * Cordova shake menu stub. Full preview/channel shake UI is planned for a follow-up release.
+ */
+public class ShakeMenu implements ShakeDetector.Listener, ThreeFingerPinchDetector.Listener {
+
+    private final Logger logger;
+
+    public ShakeMenu(CordovaUpdaterPlugin plugin, Activity activity, Logger logger, String gesture) {
+        this.logger = logger;
+        logger.debug("ShakeMenu: gesture " + gesture + " registered (Cordova stub)");
+    }
+
+    public boolean usesGesture(String gesture) {
+        return false;
+    }
+
+    public void stop() {
+        // no-op
+    }
+
+    @Override
+    public void onShakeDetected() {
+        logger.debug("ShakeMenu: shake detected (Cordova stub)");
+    }
+
+    @Override
+    public void onThreeFingerPinchDetected() {
+        logger.debug("ShakeMenu: three-finger pinch detected (Cordova stub)");
+    }
+}

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

@@ -0,0 +1,323 @@
+/*
+ * 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.view.ActionMode;
+import android.view.KeyEvent;
+import android.view.KeyboardShortcutGroup;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.SearchEvent;
+import android.view.View;
+import android.view.Window;
+import android.view.WindowManager;
+import android.view.accessibility.AccessibilityEvent;
+import android.app.Activity;
+import java.lang.ref.WeakReference;
+import java.util.List;
+
+public class ThreeFingerPinchDetector {
+
+    public interface Listener {
+        void onThreeFingerPinchDetected();
+    }
+
+    private static final int REQUIRED_POINTER_COUNT = 3;
+    private static final float MIN_SCALE_DELTA = 0.12f;
+    private static final long PINCH_TIMEOUT = 1000;
+
+    private final Listener listener;
+    private final Logger logger;
+    private Window targetWindow;
+    private Window.Callback previousWindowCallback;
+    private Window.Callback windowCallback;
+    private WeakReference<ThreeFingerPinchDetector> detectorReference;
+    private float initialSpan = 0;
+    private boolean tracking = false;
+    private boolean triggered = false;
+    private long lastPinchTime = 0;
+
+    public ThreeFingerPinchDetector(Listener listener, Logger logger) {
+        this.listener = listener;
+        this.logger = logger;
+    }
+
+    public void start(Activity activity) {
+        if (targetWindow != null) {
+            stop();
+        }
+
+        Window window = activity.getWindow();
+        if (window == null) {
+            logger.warn("Three finger pinch detector could not find a target window");
+            return;
+        }
+
+        this.targetWindow = window;
+        this.previousWindowCallback = window.getCallback();
+        this.detectorReference = new WeakReference<>(this);
+        this.windowCallback = new PinchWindowCallback(this.previousWindowCallback, this.detectorReference);
+        window.setCallback(this.windowCallback);
+        logger.info("Three finger pinch detector installed on activity window");
+    }
+
+    public void stop() {
+        if (targetWindow != null) {
+            if (windowCallback instanceof PinchWindowCallback) {
+                ((PinchWindowCallback) windowCallback).disable();
+            }
+            if (detectorReference != null) {
+                detectorReference.clear();
+            }
+            if (targetWindow.getCallback() == windowCallback) {
+                targetWindow.setCallback(previousWindowCallback);
+            }
+            targetWindow = null;
+            previousWindowCallback = null;
+            windowCallback = null;
+            detectorReference = null;
+        }
+        reset();
+    }
+
+    private void handleTouch(MotionEvent event) {
+        int action = event.getActionMasked();
+        if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_POINTER_UP) {
+            reset();
+            return;
+        }
+
+        if (event.getPointerCount() != REQUIRED_POINTER_COUNT) {
+            if (action == MotionEvent.ACTION_POINTER_DOWN) {
+                reset();
+            }
+            return;
+        }
+
+        float span = calculateSpan(event);
+        if (span <= 0) {
+            return;
+        }
+
+        if (!tracking || action == MotionEvent.ACTION_POINTER_DOWN) {
+            initialSpan = span;
+            tracking = true;
+            triggered = false;
+            logger.info("Three finger pinch tracking started");
+            return;
+        }
+
+        if (!triggered && Math.abs(span - initialSpan) / initialSpan >= MIN_SCALE_DELTA) {
+            long currentTime = System.currentTimeMillis();
+            if (currentTime - lastPinchTime > PINCH_TIMEOUT) {
+                triggered = true;
+                lastPinchTime = currentTime;
+                logger.info("Three finger pinch threshold reached");
+                if (listener != null) {
+                    listener.onThreeFingerPinchDetected();
+                }
+            }
+        }
+    }
+
+    private float calculateSpan(MotionEvent event) {
+        float centerX = 0;
+        float centerY = 0;
+        for (int i = 0; i < REQUIRED_POINTER_COUNT; i++) {
+            centerX += event.getX(i);
+            centerY += event.getY(i);
+        }
+        centerX /= REQUIRED_POINTER_COUNT;
+        centerY /= REQUIRED_POINTER_COUNT;
+
+        float totalDistance = 0;
+        for (int i = 0; i < REQUIRED_POINTER_COUNT; i++) {
+            float dx = event.getX(i) - centerX;
+            float dy = event.getY(i) - centerY;
+            totalDistance += Math.sqrt(dx * dx + dy * dy);
+        }
+        return totalDistance / REQUIRED_POINTER_COUNT;
+    }
+
+    private void reset() {
+        initialSpan = 0;
+        tracking = false;
+        triggered = false;
+    }
+
+    private static class PinchWindowCallback implements Window.Callback {
+
+        private final Window.Callback delegate;
+        private final WeakReference<ThreeFingerPinchDetector> detectorReference;
+        private boolean enabled = true;
+
+        PinchWindowCallback(Window.Callback delegate, WeakReference<ThreeFingerPinchDetector> detectorReference) {
+            this.delegate = delegate;
+            this.detectorReference = detectorReference;
+        }
+
+        void disable() {
+            enabled = false;
+            if (detectorReference != null) {
+                detectorReference.clear();
+            }
+        }
+
+        @Override
+        public boolean dispatchKeyEvent(KeyEvent event) {
+            return delegate != null && delegate.dispatchKeyEvent(event);
+        }
+
+        @Override
+        public boolean dispatchKeyShortcutEvent(KeyEvent event) {
+            return delegate != null && delegate.dispatchKeyShortcutEvent(event);
+        }
+
+        @Override
+        public boolean dispatchTouchEvent(MotionEvent event) {
+            boolean handled = delegate != null && delegate.dispatchTouchEvent(event);
+            if (enabled) {
+                ThreeFingerPinchDetector detector = detectorReference == null ? null : detectorReference.get();
+                if (detector != null) {
+                    detector.handleTouch(event);
+                }
+            }
+            return handled;
+        }
+
+        @Override
+        public boolean dispatchTrackballEvent(MotionEvent event) {
+            return delegate != null && delegate.dispatchTrackballEvent(event);
+        }
+
+        @Override
+        public boolean dispatchGenericMotionEvent(MotionEvent event) {
+            return delegate != null && delegate.dispatchGenericMotionEvent(event);
+        }
+
+        @Override
+        public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
+            return delegate != null && delegate.dispatchPopulateAccessibilityEvent(event);
+        }
+
+        @Override
+        public View onCreatePanelView(int featureId) {
+            return delegate == null ? null : delegate.onCreatePanelView(featureId);
+        }
+
+        @Override
+        public boolean onCreatePanelMenu(int featureId, Menu menu) {
+            return delegate != null && delegate.onCreatePanelMenu(featureId, menu);
+        }
+
+        @Override
+        public boolean onPreparePanel(int featureId, View view, Menu menu) {
+            return delegate != null && delegate.onPreparePanel(featureId, view, menu);
+        }
+
+        @Override
+        public boolean onMenuOpened(int featureId, Menu menu) {
+            return delegate != null && delegate.onMenuOpened(featureId, menu);
+        }
+
+        @Override
+        public boolean onMenuItemSelected(int featureId, MenuItem item) {
+            return delegate != null && delegate.onMenuItemSelected(featureId, item);
+        }
+
+        @Override
+        public void onWindowAttributesChanged(WindowManager.LayoutParams attrs) {
+            if (delegate != null) {
+                delegate.onWindowAttributesChanged(attrs);
+            }
+        }
+
+        @Override
+        public void onContentChanged() {
+            if (delegate != null) {
+                delegate.onContentChanged();
+            }
+        }
+
+        @Override
+        public void onWindowFocusChanged(boolean hasFocus) {
+            if (delegate != null) {
+                delegate.onWindowFocusChanged(hasFocus);
+            }
+        }
+
+        @Override
+        public void onAttachedToWindow() {
+            if (delegate != null) {
+                delegate.onAttachedToWindow();
+            }
+        }
+
+        @Override
+        public void onDetachedFromWindow() {
+            if (delegate != null) {
+                delegate.onDetachedFromWindow();
+            }
+        }
+
+        @Override
+        public void onPanelClosed(int featureId, Menu menu) {
+            if (delegate != null) {
+                delegate.onPanelClosed(featureId, menu);
+            }
+        }
+
+        @Override
+        public boolean onSearchRequested() {
+            return delegate != null && delegate.onSearchRequested();
+        }
+
+        @Override
+        public boolean onSearchRequested(SearchEvent searchEvent) {
+            return delegate != null && delegate.onSearchRequested(searchEvent);
+        }
+
+        @Override
+        public ActionMode onWindowStartingActionMode(ActionMode.Callback callback) {
+            return delegate == null ? null : delegate.onWindowStartingActionMode(callback);
+        }
+
+        @Override
+        public ActionMode onWindowStartingActionMode(ActionMode.Callback callback, int type) {
+            return delegate == null ? null : delegate.onWindowStartingActionMode(callback, type);
+        }
+
+        @Override
+        public void onActionModeStarted(ActionMode mode) {
+            if (delegate != null) {
+                delegate.onActionModeStarted(mode);
+            }
+        }
+
+        @Override
+        public void onActionModeFinished(ActionMode mode) {
+            if (delegate != null) {
+                delegate.onActionModeFinished(mode);
+            }
+        }
+
+        @Override
+        public void onProvideKeyboardShortcuts(List<KeyboardShortcutGroup> data, Menu menu, int deviceId) {
+            if (delegate != null) {
+                delegate.onProvideKeyboardShortcuts(data, menu, deviceId);
+            }
+        }
+
+        @Override
+        public void onPointerCaptureChanged(boolean hasCapture) {
+            if (delegate != null) {
+                delegate.onPointerCaptureChanged(hasCapture);
+            }
+        }
+    }
+}

package/src/android/app/capgo/cordova/updater/compat/JSArray.java

@@ -0,0 +1,9 @@
+package app.capgo.cordova.updater.compat;
+
+import org.json.JSONArray;
+
+public class JSArray extends JSONArray {
+    public JSArray() {
+        super();
+    }
+}

package/src/android/app/capgo/cordova/updater/compat/JSObject.java

@@ -0,0 +1,83 @@
+package app.capgo.cordova.updater.compat;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class JSObject extends JSONObject {
+    public JSObject() {
+        super();
+    }
+
+    public JSObject(JSONObject copy, String[] names) {
+        super();
+        for (String name : names) {
+            if (copy != null && copy.has(name)) {
+                try {
+                    put(name, copy.get(name));
+                } catch (org.json.JSONException ignored) {
+                }
+            }
+        }
+    }
+
+    public JSObject(String json) throws JSONException {
+        super(json);
+    }
+
+    @Override
+    public JSObject put(String key, boolean value) {
+        try {
+            super.put(key, value);
+        } catch (JSONException ignored) {
+        }
+        return this;
+    }
+
+    @Override
+    public JSObject put(String key, int value) {
+        try {
+            super.put(key, value);
+        } catch (JSONException ignored) {
+        }
+        return this;
+    }
+
+    @Override
+    public JSObject put(String key, long value) {
+        try {
+            super.put(key, value);
+        } catch (JSONException ignored) {
+        }
+        return this;
+    }
+
+    @Override
+    public JSObject put(String key, double value) {
+        try {
+            super.put(key, value);
+        } catch (JSONException ignored) {
+        }
+        return this;
+    }
+
+    @Override
+    public JSObject put(String key, Object value) {
+        try {
+            super.put(key, value);
+        } catch (JSONException ignored) {
+        }
+        return this;
+    }
+
+    public String getString(String key) {
+        try {
+            return super.getString(key);
+        } catch (JSONException e) {
+            return null;
+        }
+    }
+
+    public boolean has(String key) {
+        return super.has(key);
+    }
+}

package/src/android/app/capgo/cordova/updater/compat/PluginCall.java

@@ -0,0 +1,165 @@
+package app.capgo.cordova.updater.compat;
+
+import androidx.annotation.Nullable;
+import org.apache.cordova.CallbackContext;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+public class PluginCall {
+    private final CallbackContext callbackContext;
+    private final JSONArray args;
+    private final CordovaPluginShim plugin;
+
+    public interface CordovaPluginShim {
+        void reject(PluginCall call, String message, @Nullable Exception exception);
+    }
+
+    public PluginCall(CallbackContext callbackContext, JSONArray args, CordovaPluginShim plugin) {
+        this.callbackContext = callbackContext;
+        this.args = args == null ? new JSONArray() : args;
+        this.plugin = plugin;
+    }
+
+    public CallbackContext getCallbackContext() {
+        return callbackContext;
+    }
+
+    @Nullable
+    public String getString(String key) {
+        return getString(key, null);
+    }
+
+    @Nullable
+    public String getString(String key, @Nullable String defaultValue) {
+        JSONObject obj = firstObject();
+        if (obj == null || !obj.has(key) || obj.isNull(key)) {
+            return defaultValue;
+        }
+        return obj.optString(key, defaultValue);
+    }
+
+    @Nullable
+    public Boolean getBoolean(String key) {
+        JSONObject obj = firstObject();
+        if (obj == null || !obj.has(key) || obj.isNull(key)) {
+            return null;
+        }
+        return obj.optBoolean(key);
+    }
+
+    public boolean getBoolean(String key, boolean defaultValue) {
+        JSONObject obj = firstObject();
+        if (obj == null || !obj.has(key) || obj.isNull(key)) {
+            return defaultValue;
+        }
+        return obj.optBoolean(key, defaultValue);
+    }
+
+    public int getInt(String key, int defaultValue) {
+        JSONObject obj = firstObject();
+        if (obj == null || !obj.has(key) || obj.isNull(key)) {
+            return defaultValue;
+        }
+        return obj.optInt(key, defaultValue);
+    }
+
+    public double getDouble(String key, double defaultValue) {
+        JSONObject obj = firstObject();
+        if (obj == null || !obj.has(key) || obj.isNull(key)) {
+            return defaultValue;
+        }
+        return obj.optDouble(key, defaultValue);
+    }
+
+    @Nullable
+    public JSObject getObject(String key) {
+        JSONObject obj = firstObject();
+        if (obj == null || !obj.has(key) || obj.isNull(key)) {
+            return null;
+        }
+        Object value = obj.opt(key);
+        if (value instanceof JSONObject) {
+            JSObject copy = new JSObject();
+            JSONObject source = (JSONObject) value;
+            JSONArray names = source.names();
+            if (names != null) {
+                for (int i = 0; i < names.length(); i++) {
+                    String name = names.optString(i);
+                    copy.put(name, source.opt(name));
+                }
+            }
+            return copy;
+        }
+        return null;
+    }
+
+    @Nullable
+    public JSONArray getArray(String key) {
+        JSONObject obj = firstObject();
+        if (obj == null || !obj.has(key) || obj.isNull(key)) {
+            return null;
+        }
+        return obj.optJSONArray(key);
+    }
+
+    @Nullable
+    private JSONObject firstObject() {
+        if (args.length() == 0) {
+            return null;
+        }
+        Object first = args.opt(0);
+        if (first instanceof JSONObject) {
+            return (JSONObject) first;
+        }
+        return null;
+    }
+
+    public void resolve() {
+        callbackContext.success();
+    }
+
+    public void resolve(JSObject data) {
+        callbackContext.success(data);
+    }
+
+    public void resolve(String data) {
+        callbackContext.success(data);
+    }
+
+    public void reject(String message) {
+        plugin.reject(this, message, null);
+    }
+
+
+    public JSObject getData() {
+        JSONObject obj = firstObject();
+        if (obj == null) {
+            return new JSObject();
+        }
+        JSObject copy = new JSObject();
+        JSONArray names = obj.names();
+        if (names != null) {
+            for (int i = 0; i < names.length(); i++) {
+                String name = names.optString(i);
+                copy.put(name, obj.opt(name));
+            }
+        }
+        return copy;
+    }
+
+    public void reject(String message, String code) {
+        plugin.reject(this, message, null);
+    }
+
+    public void reject(String message, String code, @Nullable Exception exception, JSObject data) {
+        plugin.reject(this, message, exception);
+    }
+
+    public void reject(String message, String code, @Nullable Exception exception) {
+        plugin.reject(this, message, exception);
+    }
+
+    public void reject(String message, @Nullable Exception exception) {
+        plugin.reject(this, message, exception);
+    }
+}