@capgo/capacitor-updater 7.42.9 → 7.43.3

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

@@ -10,8 +10,19 @@ import android.app.Activity;
 import android.app.AlertDialog;
 import android.content.DialogInterface;
 import android.hardware.SensorManager;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.widget.ArrayAdapter;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+import android.widget.ListView;
+import android.widget.ProgressBar;
 import com.getcapacitor.Bridge;
 import com.getcapacitor.BridgeActivity;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import org.json.JSONArray;
 
 public class ShakeMenu implements ShakeDetector.Listener {
 
@@ -54,10 +65,16 @@ public class ShakeMenu implements ShakeDetector.Listener {
         }
 
         isShowing = true;
-        showShakeMenu();
+
+        // Check if channel selector mode is enabled
+        if (plugin.shakeChannelSelectorEnabled) {
+            showChannelSelector();
+        } else {
+            showDefaultMenu();
+        }
     }
 
-    private void showShakeMenu() {
+    private void showDefaultMenu() {
         activity.runOnUiThread(() -> {
             try {
                 String appName = activity.getPackageManager().getApplicationLabel(activity.getApplicationInfo()).toString();
@@ -166,4 +183,421 @@ public class ShakeMenu implements ShakeDetector.Listener {
             }
         });
     }
+
+    private void showChannelSelector() {
+        activity.runOnUiThread(() -> {
+            try {
+                // Show loading dialog
+                AlertDialog.Builder loadingBuilder = new AlertDialog.Builder(activity);
+                loadingBuilder.setTitle("Loading Channels...");
+                loadingBuilder.setCancelable(true);
+
+                ProgressBar progressBar = new ProgressBar(activity);
+                progressBar.setIndeterminate(true);
+                int padding = dpToPx(20);
+                progressBar.setPadding(padding, padding, padding, padding);
+                loadingBuilder.setView(progressBar);
+
+                final boolean[] didCancel = { false };
+
+                loadingBuilder.setNegativeButton("Cancel", (dialog, which) -> {
+                    didCancel[0] = true;
+                    dialog.dismiss();
+                    isShowing = false;
+                });
+
+                AlertDialog loadingDialog = loadingBuilder.create();
+                loadingDialog.setOnCancelListener((d) -> {
+                    didCancel[0] = true;
+                    isShowing = false;
+                });
+                loadingDialog.setOnDismissListener((d) -> {
+                    if (didCancel[0]) {
+                        isShowing = false;
+                    }
+                });
+                loadingDialog.show();
+
+                // Fetch channels in background
+                new Thread(() -> {
+                    final CapgoUpdater updater = plugin.implementation;
+                    updater.listChannels((res) -> {
+                        activity.runOnUiThread(() -> {
+                            loadingDialog.dismiss();
+
+                            if (didCancel[0]) {
+                                return;
+                            }
+
+                            if (res == null) {
+                                showError("Failed to load channels: unknown error");
+                                return;
+                            }
+
+                            Object errorObj = res.get("error");
+                            if (errorObj != null) {
+                                Object messageObj = res.get("message");
+                                String message = messageObj != null ? messageObj.toString() : errorObj.toString();
+                                showError("Failed to load channels: " + message);
+                                return;
+                            }
+
+                            Object channelsObj = res.get("channels");
+                            if (!(channelsObj instanceof List)) {
+                                showError("No channels available for self-assignment");
+                                return;
+                            }
+
+                            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);
+                                }
+                            }
+
+                            if (channels.isEmpty()) {
+                                showError("No channels available for self-assignment");
+                                return;
+                            }
+
+                            presentChannelPicker(channels);
+                        });
+                    });
+                })
+                    .start();
+            } catch (Exception e) {
+                logger.error("Error showing channel selector: " + e.getMessage());
+                isShowing = false;
+            }
+        });
+    }
+
+    private void presentChannelPicker(List<Map<String, Object>> channels) {
+        try {
+            AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+            builder.setTitle("Select Channel");
+
+            // Create custom layout with search and channel list
+            LinearLayout layout = new LinearLayout(activity);
+            layout.setOrientation(LinearLayout.VERTICAL);
+            int padding = dpToPx(16);
+            layout.setPadding(padding, padding, padding, padding);
+
+            // Search field
+            EditText searchField = new EditText(activity);
+            searchField.setHint("Search channels...");
+            searchField.setSingleLine(true);
+            layout.addView(searchField);
+
+            // Create list of channel names
+            List<String> allChannelNames = new ArrayList<>();
+            for (Map<String, Object> channel : channels) {
+                Object nameObj = channel.get("name");
+                if (nameObj instanceof String) {
+                    allChannelNames.add((String) nameObj);
+                }
+            }
+
+            // Displayed channels (first 5 by default)
+            final List<String> displayedChannels = new ArrayList<>();
+            displayedChannels.addAll(allChannelNames.subList(0, Math.min(5, allChannelNames.size())));
+
+            final ArrayAdapter<String> adapter = new ArrayAdapter<>(activity, android.R.layout.simple_list_item_1, displayedChannels);
+
+            ListView listView = new ListView(activity);
+            listView.setAdapter(adapter);
+
+            // Set fixed height for list (about 5 items)
+            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);
+
+            // Search filter
+            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();
+                        displayedChannels.clear();
+
+                        int count = 0;
+                        for (String name : allChannelNames) {
+                            if (name.toLowerCase().contains(query)) {
+                                displayedChannels.add(name);
+                                count++;
+                                if (count >= 5) break;
+                            }
+                        }
+
+                        adapter.notifyDataSetChanged();
+                    }
+                }
+            );
+
+            // Channel selection
+            listView.setOnItemClickListener((parent, view, position, id) -> {
+                String selectedChannel = displayedChannels.get(position);
+                dialog.dismiss();
+                selectChannel(selectedChannel);
+            });
+
+            dialog.show();
+        } catch (Exception e) {
+            logger.error("Error presenting channel picker: " + e.getMessage());
+            isShowing = false;
+        }
+    }
+
+    private void selectChannel(String channelName) {
+        activity.runOnUiThread(() -> {
+            try {
+                // Show progress dialog
+                AlertDialog.Builder progressBuilder = new AlertDialog.Builder(activity);
+                progressBuilder.setTitle("Switching to " + channelName);
+                progressBuilder.setMessage("Setting channel...");
+                progressBuilder.setCancelable(false);
+
+                ProgressBar progressBar = new ProgressBar(activity);
+                progressBar.setIndeterminate(true);
+                int padding = dpToPx(20);
+                progressBar.setPadding(padding, padding, padding, padding);
+                progressBuilder.setView(progressBar);
+
+                AlertDialog progressDialog = progressBuilder.create();
+                progressDialog.show();
+
+                new Thread(() -> {
+                    final CapgoUpdater updater = plugin.implementation;
+                    final Bridge bridge = activity.getBridge();
+
+                    // Set the channel - respect plugin's allowSetDefaultChannel config
+                    updater.setChannel(
+                        channelName,
+                        updater.editor,
+                        "CapacitorUpdater.defaultChannel",
+                        plugin.allowSetDefaultChannel,
+                        (setRes) -> {
+                            if (setRes == null) {
+                                activity.runOnUiThread(() -> {
+                                    progressDialog.dismiss();
+                                    showError("Failed to set channel: unknown error");
+                                });
+                                return;
+                            }
+
+                            Object errorObj = setRes.get("error");
+                            if (errorObj != null) {
+                                Object messageObj = setRes.get("message");
+                                String message = messageObj != null ? messageObj.toString() : errorObj.toString();
+                                activity.runOnUiThread(() -> {
+                                    progressDialog.dismiss();
+                                    showError("Failed to set channel: " + message);
+                                });
+                                return;
+                            }
+
+                            // Update progress message
+                            activity.runOnUiThread(() -> progressDialog.setMessage("Checking for updates..."));
+
+                            // Check for updates
+                            String updateUrlStr = plugin.getUpdateUrl();
+                            if (updateUrlStr == null || updateUrlStr.isEmpty()) {
+                                updateUrlStr = "https://plugin.capgo.app/updates";
+                            }
+
+                            final String finalUpdateUrlStr = updateUrlStr;
+                            updater.getLatest(finalUpdateUrlStr, channelName, (latestRes) -> {
+                                if (latestRes == null) {
+                                    activity.runOnUiThread(() -> {
+                                        progressDialog.dismiss();
+                                        showSuccess("Channel set to " + channelName + ". Could not check for updates.");
+                                    });
+                                    return;
+                                }
+
+                                String latestError = getString(latestRes, "error");
+
+                                // Handle update errors first (before "no new version" check)
+                                if (latestError != null && !latestError.isEmpty() && !"no_new_version_available".equals(latestError)) {
+                                    activity.runOnUiThread(() -> {
+                                        progressDialog.dismiss();
+                                        showError("Channel set to " + channelName + ". Update check failed: " + latestError);
+                                    });
+                                    return;
+                                }
+
+                                String latestUrl = getString(latestRes, "url");
+
+                                // Check if there's an actual update available
+                                if ("no_new_version_available".equals(latestError) || latestUrl == null || latestUrl.isEmpty()) {
+                                    activity.runOnUiThread(() -> {
+                                        progressDialog.dismiss();
+                                        showSuccess("Channel set to " + channelName + ". Already on latest version.");
+                                    });
+                                    return;
+                                }
+
+                                String version = getString(latestRes, "version");
+                                if (version == null || version.isEmpty()) {
+                                    activity.runOnUiThread(() -> {
+                                        progressDialog.dismiss();
+                                        showError("Channel set to " + channelName + ". Update check failed: missing version.");
+                                    });
+                                    return;
+                                }
+
+                                // Update message
+                                final String versionForUi = version;
+                                activity.runOnUiThread(() -> progressDialog.setMessage("Downloading update " + versionForUi + "..."));
+
+                                String sessionKey = getString(latestRes, "sessionKey");
+                                String checksum = getString(latestRes, "checksum");
+                                Object manifestObj = latestRes.get("manifest");
+
+                                // Download the update
+                                try {
+                                    BundleInfo bundle;
+                                    if (manifestObj != null) {
+                                        JSONArray manifestArray = null;
+                                        if (manifestObj instanceof JSONArray) {
+                                            manifestArray = (JSONArray) manifestObj;
+                                        } else if (manifestObj instanceof List) {
+                                            manifestArray = new JSONArray((List<?>) manifestObj);
+                                        }
+
+                                        if (manifestArray == null) {
+                                            throw new IllegalArgumentException("Invalid manifest format");
+                                        }
+
+                                        bundle = updater.downloadManifest(
+                                            latestUrl,
+                                            versionForUi,
+                                            sessionKey != null ? sessionKey : "",
+                                            checksum != null ? checksum : "",
+                                            manifestArray
+                                        );
+                                    } else {
+                                        bundle = updater.download(
+                                            latestUrl,
+                                            versionForUi,
+                                            sessionKey != null ? sessionKey : "",
+                                            checksum != null ? checksum : ""
+                                        );
+                                    }
+
+                                    // Set as next bundle
+                                    updater.setNextBundle(bundle.getId());
+
+                                    activity.runOnUiThread(() -> {
+                                        progressDialog.dismiss();
+                                        showSuccessWithReload("Update downloaded! Reload to apply version " + versionForUi + "?", () -> {
+                                            try {
+                                                if (bridge == null) {
+                                                    logger.warn("Bridge is null, cannot reload app");
+                                                    return;
+                                                }
+                                                updater.set(bundle);
+                                                String path = updater.getCurrentBundlePath();
+                                                if (updater.isUsingBuiltin()) {
+                                                    bridge.setServerAssetPath(path);
+                                                } else {
+                                                    bridge.setServerBasePath(path);
+                                                }
+                                                if (bridge.getWebView() != null) {
+                                                    bridge.getWebView().reload();
+                                                }
+                                            } catch (Exception e) {
+                                                logger.error("Error applying bundle before reload: " + e.getMessage());
+                                            }
+                                        });
+                                    });
+                                } catch (Exception e) {
+                                    activity.runOnUiThread(() -> {
+                                        progressDialog.dismiss();
+                                        showError("Failed to download update: " + e.getMessage());
+                                    });
+                                }
+                            });
+                        }
+                    );
+                })
+                    .start();
+            } catch (Exception e) {
+                logger.error("Error selecting channel: " + e.getMessage());
+                isShowing = false;
+            }
+        });
+    }
+
+    private void showError(String message) {
+        logger.error(message);
+        new AlertDialog.Builder(activity)
+            .setTitle("Error")
+            .setMessage(message)
+            .setPositiveButton("OK", (d, w) -> {
+                d.dismiss();
+                isShowing = false;
+            })
+            .setOnDismissListener((d) -> isShowing = false)
+            .show();
+    }
+
+    private void showSuccess(String message) {
+        logger.info(message);
+        new AlertDialog.Builder(activity)
+            .setTitle("Success")
+            .setMessage(message)
+            .setPositiveButton("OK", (d, w) -> {
+                d.dismiss();
+                isShowing = false;
+            })
+            .setOnDismissListener((d) -> isShowing = false)
+            .show();
+    }
+
+    private void showSuccessWithReload(String message, Runnable onReload) {
+        logger.info(message);
+        new AlertDialog.Builder(activity)
+            .setTitle("Update Ready")
+            .setMessage(message)
+            .setPositiveButton("Reload Now", (d, w) -> {
+                d.dismiss();
+                isShowing = false;
+                if (onReload != null) {
+                    onReload.run();
+                }
+            })
+            .setNegativeButton("Later", (d, w) -> {
+                d.dismiss();
+                isShowing = false;
+            })
+            .setOnDismissListener((d) -> isShowing = false)
+            .show();
+    }
+
+    private String getString(Map<String, Object> map, String key) {
+        Object value = map.get(key);
+        return value != null ? value.toString() : null;
+    }
+
+    private int dpToPx(int dp) {
+        float density = activity.getResources().getDisplayMetrics().density;
+        return Math.round(dp * density);
+    }
 }

package/dist/docs.json

@@ -1255,6 +1255,70 @@
         ],
         "slug": "isshakemenuenabled"
       },
+      {
+        "name": "setShakeChannelSelector",
+        "signature": "(options: SetShakeChannelSelectorOptions) => Promise<void>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "SetShakeChannelSelectorOptions"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [
+          {
+            "name": "param",
+            "text": "options"
+          },
+          {
+            "name": "link",
+            "text": "SetShakeChannelSelectorOptions} with `enabled: true` to enable or `enabled: false` to disable."
+          },
+          {
+            "name": "returns",
+            "text": "Resolves when the setting is applied."
+          },
+          {
+            "name": "throws",
+            "text": "{Error} If the operation fails."
+          },
+          {
+            "name": "since",
+            "text": "8.43.0"
+          }
+        ],
+        "docs": "Enable or disable the shake channel selector at runtime.\n\nWhen enabled AND shakeMenu is true, shaking the device shows a channel\nselector instead of the debug menu. This allows users to switch between\nupdate channels by shaking their device.\n\nAfter selecting a channel, the app automatically checks for updates\nand downloads if available.\n\nCan also be configured via {@link PluginsConfig.CapacitorUpdater.allowShakeChannelSelector}.",
+        "complexTypes": [
+          "SetShakeChannelSelectorOptions"
+        ],
+        "slug": "setshakechannelselector"
+      },
+      {
+        "name": "isShakeChannelSelectorEnabled",
+        "signature": "() => Promise<ShakeChannelSelectorEnabled>",
+        "parameters": [],
+        "returns": "Promise<ShakeChannelSelectorEnabled>",
+        "tags": [
+          {
+            "name": "returns",
+            "text": "Object with `enabled: true` or `enabled: false`."
+          },
+          {
+            "name": "throws",
+            "text": "{Error} If the operation fails."
+          },
+          {
+            "name": "since",
+            "text": "8.43.0"
+          }
+        ],
+        "docs": "Check if the shake channel selector is currently enabled.\n\nReturns the current state of the shake channel selector feature that can be toggled via\n{@link setShakeChannelSelector} or configured via {@link PluginsConfig.CapacitorUpdater.allowShakeChannelSelector}.",
+        "complexTypes": [
+          "ShakeChannelSelectorEnabled"
+        ],
+        "slug": "isshakechannelselectorenabled"
+      },
       {
         "name": "getAppId",
         "signature": "() => Promise<GetAppIdRes>",
@@ -2614,6 +2678,38 @@
         }
       ]
     },
+    {
+      "name": "SetShakeChannelSelectorOptions",
+      "slug": "setshakechannelselectoroptions",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "enabled",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "boolean"
+        }
+      ]
+    },
+    {
+      "name": "ShakeChannelSelectorEnabled",
+      "slug": "shakechannelselectorenabled",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "enabled",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "boolean"
+        }
+      ]
+    },
     {
       "name": "GetAppIdRes",
       "slug": "getappidres",
@@ -3658,6 +3754,22 @@
           "docs": "Enable shake gesture to show update menu for debugging/testing purposes",
           "complexTypes": [],
           "type": "boolean | undefined"
+        },
+        {
+          "name": "allowShakeChannelSelector",
+          "tags": [
+            {
+              "text": "false",
+              "name": "default"
+            },
+            {
+              "text": "8.43.0",
+              "name": "since"
+            }
+          ],
+          "docs": "Enable the shake gesture to show a channel selector menu for switching between update channels.\nWhen enabled AND `shakeMenu` is true, the shake gesture shows a channel selector\ninstead of the default debug menu (Go Home/Reload/Close).\n\nAfter selecting a channel, the app automatically checks for updates and downloads if available.\nOnly works if channels have `allow_self_set` enabled on the backend.\n\nOnly available for Android and iOS.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
         }
       ],
       "docs": "CapacitorUpdater can be configured with these options:"

package/dist/esm/definitions.d.ts

@@ -330,6 +330,20 @@ declare module '@capacitor/cli' {
              * @since  7.5.0
              */
             shakeMenu?: boolean;
+            /**
+             * Enable the shake gesture to show a channel selector menu for switching between update channels.
+             * When enabled AND `shakeMenu` is true, the shake gesture shows a channel selector
+             * instead of the default debug menu (Go Home/Reload/Close).
+             *
+             * After selecting a channel, the app automatically checks for updates and downloads if available.
+             * Only works if channels have `allow_self_set` enabled on the backend.
+             *
+             * Only available for Android and iOS.
+             *
+             * @default false
+             * @since 8.43.0
+             */
+            allowShakeChannelSelector?: boolean;
         };
     }
 }
@@ -1143,6 +1157,35 @@ export interface CapacitorUpdaterPlugin {
      * @since 7.5.0
      */
     isShakeMenuEnabled(): Promise<ShakeMenuEnabled>;
+    /**
+     * Enable or disable the shake channel selector at runtime.
+     *
+     * When enabled AND shakeMenu is true, shaking the device shows a channel
+     * selector instead of the debug menu. This allows users to switch between
+     * update channels by shaking their device.
+     *
+     * After selecting a channel, the app automatically checks for updates
+     * and downloads if available.
+     *
+     * Can also be configured via {@link PluginsConfig.CapacitorUpdater.allowShakeChannelSelector}.
+     *
+     * @param options {@link SetShakeChannelSelectorOptions} with `enabled: true` to enable or `enabled: false` to disable.
+     * @returns {Promise<void>} Resolves when the setting is applied.
+     * @throws {Error} If the operation fails.
+     * @since 8.43.0
+     */
+    setShakeChannelSelector(options: SetShakeChannelSelectorOptions): Promise<void>;
+    /**
+     * Check if the shake channel selector is currently enabled.
+     *
+     * Returns the current state of the shake channel selector feature that can be toggled via
+     * {@link setShakeChannelSelector} or configured via {@link PluginsConfig.CapacitorUpdater.allowShakeChannelSelector}.
+     *
+     * @returns {Promise<ShakeChannelSelectorEnabled>} Object with `enabled: true` or `enabled: false`.
+     * @throws {Error} If the operation fails.
+     * @since 8.43.0
+     */
+    isShakeChannelSelectorEnabled(): Promise<ShakeChannelSelectorEnabled>;
     /**
      * Get the currently configured App ID used for update server communication.
      *
@@ -1641,6 +1684,12 @@ export interface SetShakeMenuOptions {
 export interface ShakeMenuEnabled {
     enabled: boolean;
 }
+export interface SetShakeChannelSelectorOptions {
+    enabled: boolean;
+}
+export interface ShakeChannelSelectorEnabled {
+    enabled: boolean;
+}
 export interface GetAppIdRes {
     appId: string;
 }