@capgo/capacitor-updater 8.48.0 → 8.49.1

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

@@ -19,10 +19,13 @@ 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, ThreeFingerPinchDetector.Listener {
 
@@ -36,11 +39,13 @@ public class ShakeMenu implements ShakeDetector.Listener, ThreeFingerPinchDetect
     private ThreeFingerPinchDetector pinchDetector;
     private boolean isShowing = false;
     private Logger logger;
+    private String gesture;
 
     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);
@@ -52,6 +57,10 @@ public class ShakeMenu implements ShakeDetector.Listener, ThreeFingerPinchDetect
         }
     }
 
+    public boolean usesGesture(String gesture) {
+        return this.gesture != null && this.gesture.equals(gesture);
+    }
+
     public void stop() {
         if (shakeDetector != null) {
             shakeDetector.stop();
@@ -114,21 +123,43 @@ public class ShakeMenu implements ShakeDetector.Listener, ThreeFingerPinchDetect
                 }
                 String appName = activity.getPackageManager().getApplicationLabel(activity.getApplicationInfo()).toString();
                 String title = "Preview " + appName + " Menu";
-                String message = "Reload the current preview or leave the test app.";
-                String okButtonTitle = "Leave test app";
-                String reloadButtonTitle = "Reload app";
-                String cancelButtonTitle = "Close 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.setPositiveButton(okButtonTitle, null);
-                builder.setNeutralButton(reloadButtonTitle, null);
+                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(
-                    cancelButtonTitle,
+                    "Close menu",
                     new DialogInterface.OnClickListener() {
                         public void onClick(DialogInterface dialog, int id) {
                             logger.info("Shake menu cancelled");
@@ -139,21 +170,12 @@ public class ShakeMenu implements ShakeDetector.Listener, ThreeFingerPinchDetect
                 );
 
                 AlertDialog dialog = builder.create();
-                dialog.setOnDismissListener((dialogInterface) -> isShowing = false);
-                dialog.show();
-                dialog.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener((view) -> {
-                    setPreviewMenuButtonsEnabled(dialog, false);
-                    runPreviewMenuAction(dialog, "Could not leave the test app.", "Error leaving test app: ", () ->
-                        plugin.leavePreviewSessionFromShakeMenu()
-                    );
-                });
-                dialog.getButton(AlertDialog.BUTTON_NEUTRAL).setOnClickListener((view) -> {
-                    setPreviewMenuButtonsEnabled(dialog, false);
-                    logger.info("Reloading webview");
-                    runPreviewMenuAction(dialog, "Could not reload the test app.", "Error reloading test app: ", () ->
-                        plugin.reloadPreviewSessionFromShakeMenu()
-                    );
+                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;
@@ -165,29 +187,40 @@ public class ShakeMenu implements ShakeDetector.Listener, ThreeFingerPinchDetect
         try {
             String appName = activity.getPackageManager().getApplicationLabel(activity.getApplicationInfo()).toString();
             String title = "Preview " + appName + " Menu";
-            String message = "Reload or leave the current preview, or switch update channel.";
-            String[] actions = { "Reload preview", "Leave test app", "Switch channel" };
-            final boolean[] openingChannelSelector = { false };
+            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, (dialogInterface, which) -> {
+            builder.setItems(actions.toArray(new String[0]), (dialogInterface, which) -> {
                 AlertDialog dialog = (AlertDialog) dialogInterface;
-                if (which == 0) {
+                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 (which == 1) {
+                } 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 {
-                    openingChannelSelector[0] = true;
+                    openingNestedSelector[0] = true;
                     dialog.dismiss();
                     showChannelSelector();
                 }
@@ -200,7 +233,7 @@ public class ShakeMenu implements ShakeDetector.Listener, ThreeFingerPinchDetect
 
             AlertDialog dialog = builder.create();
             dialog.setOnDismissListener((dialogInterface) -> {
-                if (!openingChannelSelector[0] && !previewActionRunning[0]) {
+                if (!openingNestedSelector[0] && !previewActionRunning[0]) {
                     isShowing = false;
                 }
             });
@@ -235,6 +268,146 @@ public class ShakeMenu implements ShakeDetector.Listener, ThreeFingerPinchDetect
         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 {

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

@@ -6,27 +6,37 @@
 
 package ee.forgr.capacitor_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 com.getcapacitor.Bridge;
+import android.view.Window;
+import android.view.WindowManager;
+import android.view.accessibility.AccessibilityEvent;
 import com.getcapacitor.BridgeActivity;
-import java.lang.reflect.Field;
+import java.lang.ref.WeakReference;
+import java.util.List;
 
-public class ThreeFingerPinchDetector implements View.OnTouchListener {
+public class ThreeFingerPinchDetector {
 
     public interface Listener {
         void onThreeFingerPinchDetected();
     }
 
     private static final int REQUIRED_POINTER_COUNT = 3;
-    private static final float MIN_SCALE_DELTA = 0.30f;
+    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 View targetView;
-    private View.OnTouchListener previousOnTouchListener;
-    private boolean touchListenerInstalled = false;
+    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;
@@ -38,74 +48,68 @@ public class ThreeFingerPinchDetector implements View.OnTouchListener {
     }
 
     public void start(BridgeActivity activity) {
-        if (targetView != null) {
+        if (targetWindow != null) {
             stop();
         }
 
-        View view = null;
-        Bridge bridge = activity.getBridge();
-        if (bridge != null && bridge.getWebView() != null) {
-            view = bridge.getWebView();
-        }
-        if (view == null && activity.getWindow() != null) {
-            view = activity.getWindow().getDecorView().getRootView();
-        }
-        if (view == null) {
-            logger.warn("Three finger pinch detector could not find a target view");
+        Window window = activity.getWindow();
+        if (window == null) {
+            logger.warn("Three finger pinch detector could not find a target window");
             return;
         }
 
-        this.targetView = view;
-        this.previousOnTouchListener = getCurrentOnTouchListener(view);
-        if (this.previousOnTouchListener != this) {
-            this.targetView.setOnTouchListener(this);
-            this.touchListenerInstalled = true;
-        }
+        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 (targetView != null) {
-            View.OnTouchListener currentOnTouchListener = getCurrentOnTouchListener(targetView);
-            if (touchListenerInstalled && (currentOnTouchListener == this || currentOnTouchListener == null)) {
-                targetView.setOnTouchListener(previousOnTouchListener);
+        if (targetWindow != null) {
+            if (windowCallback instanceof PinchWindowCallback) {
+                ((PinchWindowCallback) windowCallback).disable();
             }
-            targetView = null;
-            previousOnTouchListener = null;
-            touchListenerInstalled = false;
+            if (detectorReference != null) {
+                detectorReference.clear();
+            }
+            if (targetWindow.getCallback() == windowCallback) {
+                targetWindow.setCallback(previousWindowCallback);
+            }
+            targetWindow = null;
+            previousWindowCallback = null;
+            windowCallback = null;
+            detectorReference = null;
         }
         reset();
     }
 
-    @Override
-    public boolean onTouch(View view, MotionEvent event) {
-        boolean consumedByPreviousListener = false;
-        if (previousOnTouchListener != null && previousOnTouchListener != this) {
-            consumedByPreviousListener = previousOnTouchListener.onTouch(view, event);
-        }
-
+    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 consumedByPreviousListener;
+            return;
         }
 
         if (event.getPointerCount() != REQUIRED_POINTER_COUNT) {
             if (action == MotionEvent.ACTION_POINTER_DOWN) {
                 reset();
             }
-            return consumedByPreviousListener;
+            return;
         }
 
         float span = calculateSpan(event);
         if (span <= 0) {
-            return consumedByPreviousListener;
+            return;
         }
 
         if (!tracking || action == MotionEvent.ACTION_POINTER_DOWN) {
             initialSpan = span;
             tracking = true;
             triggered = false;
-            return consumedByPreviousListener;
+            logger.info("Three finger pinch tracking started");
+            return;
         }
 
         if (!triggered && Math.abs(span - initialSpan) / initialSpan >= MIN_SCALE_DELTA) {
@@ -113,13 +117,12 @@ public class ThreeFingerPinchDetector implements View.OnTouchListener {
             if (currentTime - lastPinchTime > PINCH_TIMEOUT) {
                 triggered = true;
                 lastPinchTime = currentTime;
+                logger.info("Three finger pinch threshold reached");
                 if (listener != null) {
                     listener.onThreeFingerPinchDetected();
                 }
             }
         }
-
-        return consumedByPreviousListener;
     }
 
     private float calculateSpan(MotionEvent event) {
@@ -141,29 +144,180 @@ public class ThreeFingerPinchDetector implements View.OnTouchListener {
         return totalDistance / REQUIRED_POINTER_COUNT;
     }
 
-    private View.OnTouchListener getCurrentOnTouchListener(View view) {
-        try {
-            Field listenerInfoField = View.class.getDeclaredField("mListenerInfo");
-            listenerInfoField.setAccessible(true);
-            Object listenerInfo = listenerInfoField.get(view);
-            if (listenerInfo == null) {
-                return null;
-            }
-            Field onTouchListenerField = listenerInfo.getClass().getDeclaredField("mOnTouchListener");
-            onTouchListenerField.setAccessible(true);
-            Object listener = onTouchListenerField.get(listenerInfo);
-            if (listener instanceof View.OnTouchListener) {
-                return (View.OnTouchListener) listener;
-            }
-        } catch (ReflectiveOperationException | RuntimeException exception) {
-            logger.warn("Three finger pinch detector could not inspect the current touch listener: " + exception.getMessage());
-        }
-        return null;
-    }
-
     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);
+            }
+        }
+    }
 }