@capgo/capacitor-updater 7.43.3 → 7.50.1

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

@@ -19,42 +19,78 @@ import android.widget.ListView;
 import android.widget.ProgressBar;
 import com.getcapacitor.Bridge;
 import com.getcapacitor.BridgeActivity;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import org.json.JSONArray;
+import org.json.JSONObject;
 
-public class ShakeMenu implements ShakeDetector.Listener {
+public class ShakeMenu implements ShakeDetector.Listener, ThreeFingerPinchDetector.Listener {
+
+    private interface PreviewMenuAction {
+        boolean run();
+    }
 
     private CapacitorUpdaterPlugin plugin;
     private BridgeActivity activity;
     private ShakeDetector shakeDetector;
+    private ThreeFingerPinchDetector pinchDetector;
     private boolean isShowing = false;
     private Logger logger;
+    private String gesture;
 
-    public ShakeMenu(CapacitorUpdaterPlugin plugin, BridgeActivity activity, Logger logger) {
+    public ShakeMenu(CapacitorUpdaterPlugin plugin, BridgeActivity activity, Logger logger, String gesture) {
         this.plugin = plugin;
         this.activity = activity;
         this.logger = logger;
+        this.gesture = gesture;
+
+        if (CapacitorUpdaterPlugin.SHAKE_MENU_GESTURE_THREE_FINGER_PINCH.equals(gesture)) {
+            this.pinchDetector = new ThreeFingerPinchDetector(this, logger);
+            this.pinchDetector.start(activity);
+        } else {
+            SensorManager sensorManager = (SensorManager) activity.getSystemService(Activity.SENSOR_SERVICE);
+            this.shakeDetector = new ShakeDetector(this);
+            this.shakeDetector.start(sensorManager);
+        }
+    }
 
-        SensorManager sensorManager = (SensorManager) activity.getSystemService(Activity.SENSOR_SERVICE);
-        this.shakeDetector = new ShakeDetector(this);
-        this.shakeDetector.start(sensorManager);
+    public boolean usesGesture(String gesture) {
+        return this.gesture != null && this.gesture.equals(gesture);
     }
 
     public void stop() {
         if (shakeDetector != null) {
             shakeDetector.stop();
         }
+        if (pinchDetector != null) {
+            pinchDetector.stop();
+        }
     }
 
     @Override
     public void onShakeDetected() {
-        logger.info("Shake detected");
+        onMenuGestureDetected("Shake");
+    }
+
+    @Override
+    public void onThreeFingerPinchDetected() {
+        onMenuGestureDetected("Three finger pinch");
+    }
+
+    private void onMenuGestureDetected(String gestureName) {
+        logger.info(gestureName + " detected");
 
-        // Check if shake menu is enabled
-        if (!plugin.shakeMenuEnabled) {
-            logger.info("Shake menu is disabled");
+        boolean canShowPreviewMenu = Boolean.TRUE.equals(plugin.shakeMenuEnabled) && plugin.hasActivePreviewSession();
+        boolean canShowChannelSelector = Boolean.TRUE.equals(plugin.shakeChannelSelectorEnabled);
+        if (!canShowPreviewMenu && !canShowChannelSelector) {
+            if (Boolean.TRUE.equals(plugin.shakeMenuEnabled)) {
+                logger.info("Shake preview menu ignored because no preview session is active");
+            } else {
+                logger.info("Shake menu is disabled");
+            }
             return;
         }
 
@@ -66,15 +102,313 @@ public class ShakeMenu implements ShakeDetector.Listener {
 
         isShowing = true;
 
-        // Check if channel selector mode is enabled
-        if (plugin.shakeChannelSelectorEnabled) {
-            showChannelSelector();
-        } else {
+        if (canShowPreviewMenu) {
             showDefaultMenu();
+        } else {
+            showChannelSelector();
         }
     }
 
     private void showDefaultMenu() {
+        activity.runOnUiThread(() -> {
+            try {
+                if (!plugin.hasActivePreviewSession()) {
+                    logger.info("Shake preview menu ignored because no preview session is active");
+                    isShowing = false;
+                    return;
+                }
+                if (Boolean.TRUE.equals(plugin.shakeChannelSelectorEnabled)) {
+                    showCombinedPreviewMenu();
+                    return;
+                }
+                String appName = activity.getPackageManager().getApplicationLabel(activity.getApplicationInfo()).toString();
+                String title = "Preview " + appName + " Menu";
+                String message = "Reload, switch, or leave the current preview.";
+                List<String> actions = new ArrayList<>();
+                actions.add("Reload preview");
+                if (plugin.previewMenuPreviews().length() > 0) {
+                    actions.add("Switch preview");
+                }
+                actions.add("Leave test app");
+                final boolean[] openingNestedSelector = { false };
+                final boolean[] previewActionRunning = { false };
+
+                AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+                builder.setTitle(title);
+                builder.setMessage(message);
+                builder.setItems(actions.toArray(new String[0]), (dialogInterface, which) -> {
+                    AlertDialog dialog = (AlertDialog) dialogInterface;
+                    String action = actions.get(which);
+                    if ("Reload preview".equals(action)) {
+                        previewActionRunning[0] = true;
+                        logger.info("Reloading webview");
+                        runPreviewMenuAction(dialog, "Could not reload the test app.", "Error reloading test app: ", () ->
+                            plugin.reloadPreviewSessionFromShakeMenu()
+                        );
+                    } else if ("Switch preview".equals(action)) {
+                        openingNestedSelector[0] = true;
+                        dialog.dismiss();
+                        showPreviewSelector();
+                    } else {
+                        previewActionRunning[0] = true;
+                        runPreviewMenuAction(dialog, "Could not leave the test app.", "Error leaving test app: ", () ->
+                            plugin.leavePreviewSessionFromShakeMenu()
+                        );
+                    }
+                });
+
+                // Cancel button
+                builder.setNegativeButton(
+                    "Close menu",
+                    new DialogInterface.OnClickListener() {
+                        public void onClick(DialogInterface dialog, int id) {
+                            logger.info("Shake menu cancelled");
+                            dialog.dismiss();
+                            isShowing = false;
+                        }
+                    }
+                );
+
+                AlertDialog dialog = builder.create();
+                dialog.setOnDismissListener((dialogInterface) -> {
+                    if (!openingNestedSelector[0] && !previewActionRunning[0]) {
+                        isShowing = false;
+                    }
+                });
+                dialog.show();
+            } catch (Exception e) {
+                logger.error("Error showing shake menu: " + e.getMessage());
+                isShowing = false;
+            }
+        });
+    }
+
+    private void showCombinedPreviewMenu() {
+        try {
+            String appName = activity.getPackageManager().getApplicationLabel(activity.getApplicationInfo()).toString();
+            String title = "Preview " + appName + " Menu";
+            String message = "Reload, switch, or leave the current preview.";
+            List<String> actions = new ArrayList<>();
+            actions.add("Reload preview");
+            if (plugin.previewMenuPreviews().length() > 0) {
+                actions.add("Switch preview");
+            }
+            actions.add("Leave test app");
+            actions.add("Switch channel");
+            final boolean[] openingNestedSelector = { false };
+            final boolean[] previewActionRunning = { false };
+
+            AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+            builder.setTitle(title);
+            builder.setMessage(message);
+            builder.setItems(actions.toArray(new String[0]), (dialogInterface, which) -> {
+                AlertDialog dialog = (AlertDialog) dialogInterface;
+                String action = actions.get(which);
+                if ("Reload preview".equals(action)) {
+                    previewActionRunning[0] = true;
+                    logger.info("Reloading webview");
+                    runPreviewMenuAction(dialog, "Could not reload the test app.", "Error reloading test app: ", () ->
+                        plugin.reloadPreviewSessionFromShakeMenu()
+                    );
+                } else if ("Leave test app".equals(action)) {
+                    previewActionRunning[0] = true;
+                    runPreviewMenuAction(dialog, "Could not leave the test app.", "Error leaving test app: ", () ->
+                        plugin.leavePreviewSessionFromShakeMenu()
+                    );
+                } else if ("Switch preview".equals(action)) {
+                    openingNestedSelector[0] = true;
+                    dialog.dismiss();
+                    showPreviewSelector();
+                } else {
+                    openingNestedSelector[0] = true;
+                    dialog.dismiss();
+                    showChannelSelector();
+                }
+            });
+            builder.setNegativeButton("Close menu", (dialog, id) -> {
+                logger.info("Shake menu cancelled");
+                dialog.dismiss();
+                isShowing = false;
+            });
+
+            AlertDialog dialog = builder.create();
+            dialog.setOnDismissListener((dialogInterface) -> {
+                if (!openingNestedSelector[0] && !previewActionRunning[0]) {
+                    isShowing = false;
+                }
+            });
+            dialog.show();
+        } catch (Exception e) {
+            logger.error("Error showing combined shake menu: " + e.getMessage());
+            isShowing = false;
+        }
+    }
+
+    private void runPreviewMenuAction(AlertDialog dialog, String failureMessage, String errorPrefix, PreviewMenuAction action) {
+        new Thread(() -> {
+            try {
+                if (!action.run()) {
+                    activity.runOnUiThread(() -> showError(failureMessage));
+                }
+            } catch (Exception e) {
+                logger.error(errorPrefix + e.getMessage());
+                activity.runOnUiThread(() -> showError(errorPrefix + e.getMessage()));
+            } finally {
+                activity.runOnUiThread(() -> {
+                    dialog.dismiss();
+                    isShowing = false;
+                });
+            }
+        }).start();
+    }
+
+    private void setPreviewMenuButtonsEnabled(AlertDialog dialog, boolean enabled) {
+        dialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(enabled);
+        dialog.getButton(AlertDialog.BUTTON_NEUTRAL).setEnabled(enabled);
+        dialog.getButton(AlertDialog.BUTTON_NEGATIVE).setEnabled(enabled);
+    }
+
+    private void showPreviewSelector() {
+        activity.runOnUiThread(() -> {
+            try {
+                JSArray previewsRaw = plugin.previewMenuPreviews();
+                List<JSObject> previews = new ArrayList<>();
+                for (int i = 0; i < previewsRaw.length(); i++) {
+                    Object raw = previewsRaw.opt(i);
+                    if (raw instanceof JSObject preview) {
+                        previews.add(preview);
+                    } else if (raw instanceof JSONObject json) {
+                        previews.add(JSObject.fromJSONObject(json));
+                    }
+                }
+
+                if (previews.isEmpty()) {
+                    showError("No saved previews available on this device.");
+                    return;
+                }
+
+                presentPreviewPicker(previews);
+            } catch (Exception e) {
+                logger.error("Error showing preview selector: " + e.getMessage());
+                isShowing = false;
+            }
+        });
+    }
+
+    private String previewLabel(JSObject preview) {
+        String name = preview.optString("name", "");
+        JSObject bundle = preview.getJSObject("bundle");
+        String version = bundle == null ? "" : bundle.optString("version", "");
+        String label = !name.isEmpty() ? name : (!version.isEmpty() ? version : preview.optString("id", "Preview"));
+        if (preview.optBoolean("isActive", false)) {
+            label += " (current)";
+        }
+        return label;
+    }
+
+    private void presentPreviewPicker(List<JSObject> previews) {
+        try {
+            AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+            builder.setTitle("Select Preview");
+
+            LinearLayout layout = new LinearLayout(activity);
+            layout.setOrientation(LinearLayout.VERTICAL);
+            int padding = dpToPx(16);
+            layout.setPadding(padding, padding, padding, padding);
+
+            EditText searchField = new EditText(activity);
+            searchField.setHint("Search previews...");
+            searchField.setSingleLine(true);
+            layout.addView(searchField);
+
+            final List<JSObject> displayedPreviews = new ArrayList<>();
+            displayedPreviews.addAll(previews.subList(0, Math.min(5, previews.size())));
+            final ArrayAdapter<String> adapter = new ArrayAdapter<>(
+                activity,
+                android.R.layout.simple_list_item_1,
+                previewLabels(displayedPreviews)
+            );
+
+            ListView listView = new ListView(activity);
+            listView.setAdapter(adapter);
+            LinearLayout.LayoutParams listParams = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, dpToPx(250));
+            listView.setLayoutParams(listParams);
+            layout.addView(listView);
+
+            builder.setView(layout);
+            builder.setNegativeButton("Cancel", (dialog, which) -> {
+                dialog.dismiss();
+                isShowing = false;
+            });
+
+            AlertDialog dialog = builder.create();
+            dialog.setOnDismissListener((d) -> isShowing = false);
+
+            searchField.addTextChangedListener(
+                new TextWatcher() {
+                    @Override
+                    public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
+
+                    @Override
+                    public void onTextChanged(CharSequence s, int start, int before, int count) {}
+
+                    @Override
+                    public void afterTextChanged(Editable s) {
+                        String query = s.toString().toLowerCase();
+                        displayedPreviews.clear();
+
+                        for (JSObject preview : previews) {
+                            if (previewLabel(preview).toLowerCase().contains(query)) {
+                                displayedPreviews.add(preview);
+                                if (displayedPreviews.size() >= 5) break;
+                            }
+                        }
+
+                        adapter.clear();
+                        adapter.addAll(previewLabels(displayedPreviews));
+                        adapter.notifyDataSetChanged();
+                    }
+                }
+            );
+
+            listView.setOnItemClickListener((parent, view, position, id) -> {
+                JSObject selectedPreview = displayedPreviews.get(position);
+                String previewId = selectedPreview.optString("id", "");
+                dialog.dismiss();
+                selectPreview(previewId);
+            });
+
+            dialog.show();
+        } catch (Exception e) {
+            logger.error("Error presenting preview picker: " + e.getMessage());
+            isShowing = false;
+        }
+    }
+
+    private List<String> previewLabels(List<JSObject> previews) {
+        List<String> labels = new ArrayList<>();
+        for (JSObject preview : previews) {
+            labels.add(previewLabel(preview));
+        }
+        return labels;
+    }
+
+    private void selectPreview(String previewId) {
+        new Thread(() -> {
+            try {
+                if (!plugin.setPreviewFromShakeMenu(previewId)) {
+                    activity.runOnUiThread(() -> showError("Could not switch preview."));
+                }
+            } catch (Exception e) {
+                logger.error("Error switching preview: " + e.getMessage());
+                activity.runOnUiThread(() -> showError("Error switching preview: " + e.getMessage()));
+            } finally {
+                isShowing = false;
+            }
+        }).start();
+    }
+
+    private void showConfiguredDefaultMenu() {
         activity.runOnUiThread(() -> {
             try {
                 String appName = activity.getPackageManager().getApplicationLabel(activity.getApplicationInfo()).toString();
@@ -120,7 +454,6 @@ public class ShakeMenu implements ShakeDetector.Listener {
                                     bridge.setServerAssetPath(path);
                                 }
 
-                                // Try to delete the current bundle
                                 try {
                                     updater.delete(current.getId());
                                 } catch (Exception err) {
@@ -249,12 +582,7 @@ public class ShakeMenu implements ShakeDetector.Listener {
                             }
 
                             List<?> channelsRaw = (List<?>) channelsObj;
-                            List<Map<String, Object>> channels = new ArrayList<>();
-                            for (Object item : channelsRaw) {
-                                if (item instanceof Map) {
-                                    channels.add((Map<String, Object>) item);
-                                }
-                            }
+                            List<Map<String, Object>> channels = toChannelList(channelsRaw);
 
                             if (channels.isEmpty()) {
                                 showError("No channels available for self-assignment");
@@ -264,8 +592,7 @@ public class ShakeMenu implements ShakeDetector.Listener {
                             presentChannelPicker(channels);
                         });
                     });
-                })
-                    .start();
+                }).start();
             } catch (Exception e) {
                 logger.error("Error showing channel selector: " + e.getMessage());
                 isShowing = false;
@@ -273,6 +600,27 @@ public class ShakeMenu implements ShakeDetector.Listener {
         });
     }
 
+    private List<Map<String, Object>> toChannelList(List<?> channelsRaw) {
+        List<Map<String, Object>> channels = new ArrayList<>();
+        for (Object item : channelsRaw) {
+            if (!(item instanceof Map<?, ?> rawMap)) {
+                continue;
+            }
+
+            Map<String, Object> channel = new java.util.HashMap<>();
+            for (Map.Entry<?, ?> entry : rawMap.entrySet()) {
+                if (entry.getKey() instanceof String key) {
+                    channel.put(key, entry.getValue());
+                }
+            }
+
+            if (!channel.isEmpty()) {
+                channels.add(channel);
+            }
+        }
+        return channels;
+    }
+
     private void presentChannelPicker(List<Map<String, Object>> channels) {
         try {
             AlertDialog.Builder builder = new AlertDialog.Builder(activity);
@@ -385,6 +733,7 @@ public class ShakeMenu implements ShakeDetector.Listener {
                 new Thread(() -> {
                     final CapgoUpdater updater = plugin.implementation;
                     final Bridge bridge = activity.getBridge();
+                    final String configDefaultChannel = plugin.getConfig().getString("defaultChannel", "");
 
                     // Set the channel - respect plugin's allowSetDefaultChannel config
                     updater.setChannel(
@@ -392,6 +741,7 @@ public class ShakeMenu implements ShakeDetector.Listener {
                         updater.editor,
                         "CapacitorUpdater.defaultChannel",
                         plugin.allowSetDefaultChannel,
+                        configDefaultChannel,
                         (setRes) -> {
                             if (setRes == null) {
                                 activity.runOnUiThread(() -> {
@@ -432,12 +782,37 @@ public class ShakeMenu implements ShakeDetector.Listener {
                                 }
 
                                 String latestError = getString(latestRes, "error");
+                                String latestKind = getString(latestRes, "kind");
+                                String latestMessage = getString(latestRes, "message");
+
+                                String detail =
+                                    latestMessage != null && !latestMessage.isEmpty()
+                                        ? latestMessage
+                                        : latestError != null && !latestError.isEmpty()
+                                            ? latestError
+                                            : latestKind != null && !latestKind.isEmpty()
+                                                ? latestKind
+                                                : "server did not provide a message";
 
                                 // Handle update errors first (before "no new version" check)
-                                if (latestError != null && !latestError.isEmpty() && !"no_new_version_available".equals(latestError)) {
+                                if (
+                                    "failed".equals(latestKind) ||
+                                    (latestError != null &&
+                                        !latestError.isEmpty() &&
+                                        !"up_to_date".equals(latestKind) &&
+                                        !"blocked".equals(latestKind))
+                                ) {
+                                    activity.runOnUiThread(() -> {
+                                        progressDialog.dismiss();
+                                        showError("Channel set to " + channelName + ". Update check failed: " + detail);
+                                    });
+                                    return;
+                                }
+
+                                if ("blocked".equals(latestKind)) {
                                     activity.runOnUiThread(() -> {
                                         progressDialog.dismiss();
-                                        showError("Channel set to " + channelName + ". Update check failed: " + latestError);
+                                        showError("Channel set to " + channelName + ". Update check blocked: " + detail);
                                     });
                                     return;
                                 }
@@ -445,7 +820,7 @@ public class ShakeMenu implements ShakeDetector.Listener {
                                 String latestUrl = getString(latestRes, "url");
 
                                 // Check if there's an actual update available
-                                if ("no_new_version_available".equals(latestError) || latestUrl == null || latestUrl.isEmpty()) {
+                                if ("up_to_date".equals(latestKind) || latestUrl == null || latestUrl.isEmpty()) {
                                     activity.runOnUiThread(() -> {
                                         progressDialog.dismiss();
                                         showSuccess("Channel set to " + channelName + ". Already on latest version.");
@@ -536,8 +911,7 @@ public class ShakeMenu implements ShakeDetector.Listener {
                             });
                         }
                     );
-                })
-                    .start();
+                }).start();
             } catch (Exception e) {
                 logger.error("Error selecting channel: " + e.getMessage());
                 isShowing = false;