react-native-platform-components 1.4.0 → 1.5.0

package/android/src/main/java/com/platformcomponents/PCContextMenuView.kt

@@ -1,46 +1,33 @@
 package com.platformcomponents
 
-import android.annotation.SuppressLint
 import android.content.Context
-import android.graphics.Color
-import android.graphics.drawable.Drawable
+import android.os.SystemClock
 import android.util.Log
-import android.view.Menu
+import android.view.Gravity
+import android.view.HapticFeedbackConstants
 import android.view.MotionEvent
-import android.view.View
 import android.view.ViewConfiguration
 import androidx.appcompat.widget.PopupMenu
-import androidx.core.content.ContextCompat
-import androidx.core.graphics.drawable.DrawableCompat
 import com.facebook.react.views.view.ReactViewGroup
 
 class PCContextMenuView(context: Context) : ReactViewGroup(context) {
 
-  data class Action(
-    val id: String,
-    val title: String,
-    val subtitle: String?,
-    val image: String?,
-    val imageColor: String?,
-    val destructive: Boolean,
-    val disabled: Boolean,
-    val hidden: Boolean,
-    val state: String?, // "off" | "on" | "mixed"
-    val subactions: List<Action>
-  )
-
   companion object {
     private const val TAG = "PCContextMenu"
   }
 
   // --- Props ---
   var menuTitle: String? = null
-  var actions: List<Action> = emptyList()
+  /** The flattened menu items (see PCMenuSupport) */
+  var actions: List<PCMenuSupport.Item> = emptyList()
   var interactivity: String = "enabled" // "enabled" | "disabled"
   var trigger: String = "longPress"     // "longPress" | "tap"
   var androidVisible: String = "closed" // "open" | "closed" (Android-only programmatic)
   var androidAnchorPosition: String? = "left" // "left" | "right"
 
+  /** The `haptics` prop, played when an action is picked (an action's own `haptics` wins). */
+  var haptics: String = ""
+
   // --- Events ---
   var onPressAction: ((id: String, title: String) -> Unit)? = null
   var onMenuOpen: (() -> Unit)? = null
@@ -79,12 +66,20 @@ class PCContextMenuView(context: Context) : ReactViewGroup(context) {
         touchDownY = ev.y
         // In longPress mode, schedule long-press detection
         if (trigger == "longPress") {
+          // Dispatch recycles MotionEvent instances before this callback runs.
+          val downTime = ev.downTime
+          val downX = ev.x
+          val downY = ev.y
+          cancelPendingLongPress()
           longPressRunnable = Runnable {
             if (handleLongClick()) {
+              // The long-press haptic View.performLongClick plays, which this
+              // path bypasses; off with haptics "none" (isHapticFeedbackEnabled)
+              if (popupShowing) performHapticFeedback(HapticFeedbackConstants.LONG_PRESS)
               // Cancel any pending touch events on children
               val cancel = MotionEvent.obtain(
-                ev.downTime, System.currentTimeMillis(),
-                MotionEvent.ACTION_CANCEL, ev.x, ev.y, 0
+                downTime, SystemClock.uptimeMillis(),
+                MotionEvent.ACTION_CANCEL, downX, downY, 0
               )
               super.dispatchTouchEvent(cancel)
               cancel.recycle()
@@ -146,7 +141,7 @@ class PCContextMenuView(context: Context) : ReactViewGroup(context) {
     menuTitle = value
   }
 
-  fun applyActions(newActions: List<Action>) {
+  fun applyActions(newActions: List<PCMenuSupport.Item>) {
     actions = newActions
     Log.d(TAG, "applyActions size=${actions.size}")
   }
@@ -193,9 +188,14 @@ class PCContextMenuView(context: Context) : ReactViewGroup(context) {
   }
 
   fun applyAndroidAnchorPosition(value: String?) {
-    androidAnchorPosition = value ?: "left"
+    androidAnchorPosition = if (value == "right") "right" else "left"
+    popupMenu?.gravity = popupGravity()
   }
 
+  /** "right" aligns the popup to the anchor's end edge, "left" to its start edge. */
+  private fun popupGravity(): Int =
+    if (androidAnchorPosition == "right") Gravity.END else Gravity.START
+
   // ---- Internal ----
 
   private fun updateEnabledState() {
@@ -234,10 +234,9 @@ class PCContextMenuView(context: Context) : ReactViewGroup(context) {
     }
   }
 
-  @SuppressLint("RestrictedApi")
   private fun showPopupMenu() {
-    val visibleActions = actions.filter { !it.hidden }
-    if (visibleActions.isEmpty()) {
+    val items = actions
+    if (items.isEmpty()) {
       Log.d(TAG, "showPopupMenu: no visible actions")
       return
     }
@@ -247,32 +246,22 @@ class PCContextMenuView(context: Context) : ReactViewGroup(context) {
       return
     }
 
-    Log.d(TAG, "showPopupMenu: creating popup with ${visibleActions.size} actions")
-
-    val popup = PopupMenu(context, this)
-
-    // Try to enable icons in the popup menu
-    try {
-      val menuHelper = PopupMenu::class.java.getDeclaredField("mPopup")
-      menuHelper.isAccessible = true
-      val menuPopupHelper = menuHelper.get(popup)
-      val setForceShowIcon = menuPopupHelper.javaClass.getDeclaredMethod(
-        "setForceShowIcon",
-        Boolean::class.java
-      )
-      setForceShowIcon.invoke(menuPopupHelper, true)
-    } catch (e: Exception) {
-      Log.d(TAG, "Could not enable popup menu icons: ${e.message}")
-    }
-
-    buildMenu(popup.menu, visibleActions, 0)
+    Log.d(TAG, "showPopupMenu: creating popup with ${items.size} items")
 
-    popup.setOnMenuItemClickListener { item ->
-      val actionId = item.intent?.getStringExtra("actionId") ?: ""
-      val actionTitle = item.title?.toString() ?: ""
-      Log.d(TAG, "popup onMenuItemClick id=$actionId title=$actionTitle")
+    val popup = PopupMenu(context, this, popupGravity())
+    popupMenu = popup
+    val hasIcons = PCMenuSupport.populate(context, popup.menu, items) { popupMenu === popup }
+    // Show item icons (public AndroidX PopupMenu API, works on every supported API level).
+    popup.setForceShowIcon(hasIcons)
+
+    popup.setOnMenuItemClickListener { menuItem ->
+      // Submenu headers open their submenu; they aren't actions.
+      val item = PCMenuSupport.itemFor(menuItem, items)
+      if (item == null || !item.isAction) return@setOnMenuItemClickListener false
+      Log.d(TAG, "popup onMenuItemClick")
       dismissAfterSelect = true
-      onPressAction?.invoke(actionId, actionTitle)
+      PCHaptics.perform(this, item.haptics.ifEmpty { haptics })
+      onPressAction?.invoke(item.id, item.title)
       true
     }
 
@@ -298,105 +287,6 @@ class PCContextMenuView(context: Context) : ReactViewGroup(context) {
     popup.show()
   }
 
-  private fun buildMenu(menu: Menu, actions: List<Action>, groupId: Int) {
-    var order = 0
-    for (action in actions) {
-      if (action.hidden) continue
-
-      if (action.subactions.isNotEmpty()) {
-        // Create submenu
-        val subMenu = menu.addSubMenu(groupId, order, order, action.title)
-        buildMenu(subMenu, action.subactions, groupId + 1)
-
-        // Set icon on submenu header if available
-        action.image?.let { imageName ->
-          getDrawableByName(imageName)?.let { drawable ->
-            val tintedDrawable = tintDrawable(drawable, action.imageColor)
-            subMenu.item.icon = tintedDrawable
-          }
-        }
-      } else {
-        // Create regular item
-        val item = menu.add(groupId, order, order, buildTitle(action))
-
-        // Store action ID in intent for retrieval
-        item.intent = android.content.Intent().apply {
-          putExtra("actionId", action.id)
-        }
-
-        // Set enabled state
-        item.isEnabled = !action.disabled
-
-        // Set icon
-        action.image?.let { imageName ->
-          getDrawableByName(imageName)?.let { drawable ->
-            val tintedDrawable = tintDrawable(drawable, action.imageColor)
-            item.icon = tintedDrawable
-          }
-        }
-
-        // Set checkable state
-        when (action.state) {
-          "on" -> {
-            item.isCheckable = true
-            item.isChecked = true
-          }
-          "mixed" -> {
-            item.isCheckable = true
-            item.isChecked = true // Android doesn't have "mixed", treat as checked
-          }
-          else -> {
-            item.isCheckable = false
-          }
-        }
-      }
-      order++
-    }
-  }
-
-  private fun buildTitle(action: Action): String {
-    // On Android, we can't easily style text as destructive in PopupMenu
-    // We could prefix with emoji or special character, but keeping it simple
-    return action.title
-  }
-
-  private fun getDrawableByName(name: String): Drawable? {
-    // First try as a drawable resource
-    val resourceId = context.resources.getIdentifier(
-      name,
-      "drawable",
-      context.packageName
-    )
-
-    if (resourceId != 0) {
-      return ContextCompat.getDrawable(context, resourceId)
-    }
-
-    // Try common Material icons (ic_ prefix)
-    val icResourceId = context.resources.getIdentifier(
-      "ic_$name",
-      "drawable",
-      context.packageName
-    )
-
-    if (icResourceId != 0) {
-      return ContextCompat.getDrawable(context, icResourceId)
-    }
-
-    Log.d(TAG, "Drawable not found: $name")
-    return null
-  }
-
-  private fun tintDrawable(drawable: Drawable, colorString: String?): Drawable {
-    if (colorString.isNullOrEmpty()) return drawable
-
-    val color = ColorParser.parse(colorString) ?: return drawable
-
-    val wrappedDrawable = DrawableCompat.wrap(drawable.mutate())
-    DrawableCompat.setTint(wrappedDrawable, color)
-    return wrappedDrawable
-  }
-
   override fun onDetachedFromWindow() {
     cancelPendingLongPress()
     if (popupShowing) {

package/android/src/main/java/com/platformcomponents/PCContextMenuViewManager.kt

@@ -51,70 +51,9 @@ class PCContextMenuViewManager :
     view.applyMenuTitle(value)
   }
 
+  // actions: the flattened menu items (src/menuItems.ts)
   override fun setActions(view: PCContextMenuView, value: ReadableArray?) {
-    val out = ArrayList<PCContextMenuView.Action>()
-    if (value != null) {
-      for (i in 0 until value.size()) {
-        val m = value.getMap(i) ?: continue
-        out.add(parseAction(m))
-      }
-    }
-    view.applyActions(out)
-  }
-
-  private fun parseAction(map: ReadableMap): PCContextMenuView.Action {
-    val id = map.getStringOrEmpty("id")
-    val title = map.getStringOrEmpty("title")
-    val subtitle = map.getStringOrNull("subtitle")
-    val image = map.getStringOrNull("image")
-    val imageColor = map.getStringOrNull("imageColor")
-    val state = map.getStringOrNull("state")
-
-    // Parse attributes
-    var destructive = false
-    var disabled = false
-    var hidden = false
-    if (map.hasKey("attributes") && !map.isNull("attributes")) {
-      val attrs = map.getMap("attributes")
-      if (attrs != null) {
-        destructive = attrs.getStringOrEmpty("destructive") == "true"
-        disabled = attrs.getStringOrEmpty("disabled") == "true"
-        hidden = attrs.getStringOrEmpty("hidden") == "true"
-      }
-    }
-
-    // Parse subactions recursively
-    val subactions = ArrayList<PCContextMenuView.Action>()
-    if (map.hasKey("subactions") && !map.isNull("subactions")) {
-      val subs = map.getArray("subactions")
-      if (subs != null) {
-        for (j in 0 until subs.size()) {
-          val subMap = subs.getMap(j) ?: continue
-          subactions.add(parseAction(subMap))
-        }
-      }
-    }
-
-    return PCContextMenuView.Action(
-      id = id,
-      title = title,
-      subtitle = subtitle,
-      image = image,
-      imageColor = imageColor,
-      destructive = destructive,
-      disabled = disabled,
-      hidden = hidden,
-      state = state,
-      subactions = subactions
-    )
-  }
-
-  private fun ReadableMap.getStringOrEmpty(key: String): String {
-    return if (hasKey(key) && !isNull(key)) getString(key) ?: "" else ""
-  }
-
-  private fun ReadableMap.getStringOrNull(key: String): String? {
-    return if (hasKey(key) && !isNull(key)) getString(key) else null
+    view.applyActions(PCMenuSupport.parseItems(value))
   }
 
   override fun setInteractivity(view: PCContextMenuView, value: String?) {
@@ -129,6 +68,11 @@ class PCContextMenuViewManager :
     // Android ignores iOS config
   }
 
+  // "" (none added) | "none" | "selection" | "light" | "medium" | "heavy" | "success" | "warning" | "error"
+  override fun setHaptics(view: PCContextMenuView, value: String?) {
+    view.haptics = PCHaptics.configure(view, value)
+  }
+
   override fun setAndroid(view: PCContextMenuView, value: ReadableMap?) {
     if (value == null) {
       view.applyAndroidAnchorPosition(null)