feat(android): implement native PopupWindow context menu

Implement pure native Android context menu using only first-party Android APIs,
matching the iOS UIContextMenuInteraction approach.

- Add FocusMenuPopup with PopupWindow for menu display
- Add FocusMenuItem data class for menu item representation
- Implement GestureDetector for long press detection
- Support reactions bar with bounce animations
- Support menu items with icons, subtitles, and destructive styling
- Support single-level submenus
- Add smart positioning (above/below based on screen space)
- Add entry/exit animations with OvershootInterpolator
- Add background scrim with tap-to-dismiss
- Remove RecyclerView dependency in favor of native LinearLayout
- Fix onReactionPress callback to pass full { emoji, selected } object

Author: shottah

android/build.gradle

@@ -41,3 +41,7 @@ android {
     abortOnError false
   }
 }
+
+dependencies {
+  // No third-party dependencies - uses only native Android APIs
+}

android/src/main/java/expo/modules/focusmenu/ExpoFocusMenuModule.kt

@@ -1,262 +1,34 @@
 package expo.modules.focusmenu
 
-import android.content.Context
-import android.os.Build
-import android.os.VibrationEffect
-import android.os.Vibrator
-import android.view.Menu
-import android.view.MenuItem
-import android.view.View
-import android.widget.PopupMenu
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
-import expo.modules.kotlin.Promise
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 
 class ExpoFocusMenuModule : Module() {
-  private var currentPopupMenu: PopupMenu? = null
-  private var menuItemCallbacks = mutableMapOf<String, (String) -> Unit>()
-
-  override fun definition() = ModuleDefinition {
-    Name("ExpoFocusMenu")
-
-    // Define events that can be sent to JavaScript
-    Events("onMenuItemSelected", "onMenuShown", "onMenuDismissed")
-
-    // Show the native context menu
-    AsyncFunction("showNativeMenu") { items: List<Map<String, Any>>, config: Map<String, Any>?, promise: Promise ->
-      showMenu(items, config ?: emptyMap(), promise)
-    }
-
-    // Dismiss the currently visible menu
-    AsyncFunction("dismissNativeMenu") {
-      dismissMenu()
-    }
-
-    // Check if a menu is currently visible
-    AsyncFunction("isNativeMenuVisible") {
-      currentPopupMenu != null
-    }
-
-    // Set default configuration for menus
-    AsyncFunction("setNativeMenuConfig") { config: Map<String, Any> ->
-      // Store config for future use (could be stored in SharedPreferences)
-    }
-
-    // Export the native view
-    View(ExpoFocusMenuView::class) {
-      // Define props for the view
-      Prop("items") { view, items: List<Map<String, Any>> ->
-        view.menuItems = items
-      }
-
-      // Removed triggerMode - always use long press like iOS
-
-      Prop("hapticFeedback") { view, enabled: Boolean ->
-        view.hapticFeedback = enabled
-      }
-
-      Prop("reactions") { view, emojis: List<String>? ->
-        view.reactions = emojis ?: emptyList()
-      }
-
-
-      // Event handlers
-      Events("onItemPress", "onMenuShow", "onMenuDismiss", "onReactionPress")
-    }
-  }
-
-  private fun showMenu(items: List<Map<String, Any>>, config: Map<String, Any>, promise: Promise) {
-    if (items.isEmpty()) {
-      promise.reject("EMPTY_ITEMS", "Menu items cannot be empty", null)
-      return
-    }
-
-    val context = appContext.currentActivity ?: appContext.reactContext ?: run {
-      promise.reject("NO_ACTIVITY", "No current activity available", null)
-      return
-    }
-
-    CoroutineScope(Dispatchers.Main).launch {
-      try {
-        // Find the root view of the current activity
-        val rootView = context.window.decorView.findViewById<View>(android.R.id.content)
-
-        // Create PopupMenu
-        val popupMenu = PopupMenu(context, rootView)
-        currentPopupMenu = popupMenu
-
-        // Track menu item IDs to their string IDs
-        val menuItemIdMap = mutableMapOf<Int, String>()
-        var menuItemCounter = 1
-
-        // Add items to the menu
-        addItemsToMenu(popupMenu.menu, items, menuItemIdMap, menuItemCounter)
-
-        // Handle haptic feedback
-        val hapticFeedback = config["hapticFeedback"] as? Boolean ?: false
-        if (hapticFeedback) {
-          provideHapticFeedback(context)
-        }
-
-        // Set up menu item click listener
-        var itemSelected = false
-        popupMenu.setOnMenuItemClickListener { menuItem ->
-          val itemId = menuItemIdMap[menuItem.itemId]
-          if (itemId != null && menuItem.isEnabled) {
-            itemSelected = true
-            sendEvent("onMenuItemSelected", mapOf("itemId" to itemId))
-            promise.resolve(itemId)
-            currentPopupMenu = null
-          }
-          true
-        }
-
-        // Set up dismiss listener
-        popupMenu.setOnDismissListener {
-          if (!itemSelected) {
-            promise.resolve(null)
-          }
-          sendEvent("onMenuDismissed", emptyMap())
-          currentPopupMenu = null
-        }
-
-        // Show the menu
-        popupMenu.show()
-        sendEvent("onMenuShown", emptyMap())
-
-      } catch (e: Exception) {
-        promise.reject("MENU_ERROR", "Failed to show menu: ${e.message}", e)
-        currentPopupMenu = null
-      }
-    }
-  }
-
-  private fun addItemsToMenu(
-    menu: Menu,
-    items: List<Map<String, Any>>,
-    menuItemIdMap: MutableMap<Int, String>,
-    startId: Int
-  ): Int {
-    var currentId = startId
-
-    for (item in items) {
-      val id = item["id"] as? String ?: continue
-      val title = item["title"] as? String ?: continue
-      val subtitle = item["subtitle"] as? String
-      val disabled = item["disabled"] as? Boolean ?: false
-      val destructive = item["destructive"] as? Boolean ?: false
-      val icon = item["icon"] as? String
-      val children = item["children"] as? List<Map<String, Any>>
-
-      // Combine title and subtitle for display
-      val displayTitle = if (subtitle != null) {
-        "$title\n$subtitle"
-      } else {
-        title
-      }
-
-      if (children != null && children.isNotEmpty()) {
-        // Create submenu (limited to 1 level deep like iOS)
-        val subMenu = menu.addSubMenu(displayTitle)
-
-        // Add icon if available (only works on some Android versions)
-        if (icon != null) {
-          val iconResource = getIconResource(icon)
-          if (iconResource != 0) {
-            subMenu.setIcon(iconResource)
-          }
-        }
-
-        // Add children to submenu (no further nesting allowed)
-        for (child in children) {
-          val childId = child["id"] as? String ?: continue
-          val childTitle = child["title"] as? String ?: continue
-          val childSubtitle = child["subtitle"] as? String
-          val childDisabled = child["disabled"] as? Boolean ?: false
-
-          val childDisplayTitle = if (childSubtitle != null) {
-            "$childTitle\n$childSubtitle"
-          } else {
-            childTitle
-          }
-
-          val childMenuItem = subMenu.add(Menu.NONE, currentId, Menu.NONE, childDisplayTitle)
-          menuItemIdMap[currentId] = childId
-          currentId++
-          childMenuItem.isEnabled = !childDisabled
-
-          // Add icon for child if available
-          val childIcon = child["icon"] as? String
-          if (childIcon != null) {
-            val childIconResource = getIconResource(childIcon)
-            if (childIconResource != 0) {
-              childMenuItem.setIcon(childIconResource)
+    override fun definition() = ModuleDefinition {
+        Name("ExpoFocusMenu")
+
+        // The native view component
+        View(ExpoFocusMenuView::class) {
+            // Events that fire back to JS
+            Events(
+                "onItemPress",
+                "onReactionPress",
+                "onMenuShow",
+                "onMenuDismiss"
+            )
+
+            // Props from JS
+            Prop("items") { view: ExpoFocusMenuView, items: List<Map<String, Any?>> ->
+                view.setMenuItems(items)
             }
-          }
-        }
-      } else {
-        // Create regular menu item
-        val menuItem = menu.add(Menu.NONE, currentId, Menu.NONE, displayTitle)
-        menuItemIdMap[currentId] = id
-        currentId++
 
-        // Set enabled state
-        menuItem.isEnabled = !disabled
+            Prop("reactions") { view: ExpoFocusMenuView, reactions: List<String>? ->
+                view.setReactions(reactions)
+            }
 
-        // Add icon if available
-        if (icon != null) {
-          val iconResource = getIconResource(icon)
-          if (iconResource != 0) {
-            menuItem.setIcon(iconResource)
-          }
+            Prop("hapticFeedback") { view: ExpoFocusMenuView, enabled: Boolean ->
+                view.configureHapticFeedback(enabled)
+            }
         }
-
-        // Note: Android doesn't have a built-in "destructive" style like iOS
-        // You could implement custom styling if needed
-      }
     }
-
-    return currentId
-  }
-
-  private fun getIconResource(iconName: String): Int {
-    // Map common icon names to Android drawable resources
-    return when (iconName) {
-      "doc.on.doc", "copy" -> android.R.drawable.ic_menu_crop
-      "doc.on.clipboard", "paste" -> android.R.drawable.ic_menu_edit
-      "trash", "delete" -> android.R.drawable.ic_menu_delete
-      "arrowshape.turn.up.left", "reply" -> android.R.drawable.ic_menu_revert
-      "arrowshape.turn.up.right", "forward" -> android.R.drawable.ic_menu_send
-      "share" -> android.R.drawable.ic_menu_share
-      "edit" -> android.R.drawable.ic_menu_edit
-      "search" -> android.R.drawable.ic_menu_search
-      "add", "plus" -> android.R.drawable.ic_menu_add
-      "close" -> android.R.drawable.ic_menu_close_clear_cancel
-      "info" -> android.R.drawable.ic_menu_info_details
-      "preferences", "settings" -> android.R.drawable.ic_menu_preferences
-      "help" -> android.R.drawable.ic_menu_help
-      else -> 0
-    }
-  }
-
-  private fun provideHapticFeedback(context: Context) {
-    val vibrator = context.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator
-    vibrator?.let {
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        it.vibrate(VibrationEffect.createOneShot(10, VibrationEffect.DEFAULT_AMPLITUDE))
-      } else {
-        @Suppress("DEPRECATION")
-        it.vibrate(10)
-      }
-    }
-  }
-
-  private fun dismissMenu() {
-    currentPopupMenu?.dismiss()
-    currentPopupMenu = null
-  }
-}
+}