@capgo/capacitor-updater 7.42.9 → 7.45.10

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,461 @@ 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 = toChannelList(channelsRaw);
+
+                            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 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);
+            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");
+                                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 (
+                                    "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 blocked: " + detail);
+                                    });
+                                    return;
+                                }
+
+                                String latestUrl = getString(latestRes, "url");
+
+                                // Check if there's an actual update available
+                                if ("up_to_date".equals(latestKind) || 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);
+    }
 }