react-native-platform-components 1.3.0 → 1.5.0

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

@@ -0,0 +1,204 @@
+package com.platformcomponents
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.viewmanagers.PCButtonManagerDelegate
+import com.facebook.react.viewmanagers.PCButtonManagerInterface
+import com.platformcomponents.PCButtonSupport.doubleOr
+import com.platformcomponents.PCButtonSupport.stringOr
+
+class PCButtonViewManager :
+  SimpleViewManager<PCButtonView>(),
+  PCButtonManagerInterface<PCButtonView> {
+
+  companion object {
+    private const val TAG = "PCButton"
+  }
+
+  private val delegate: ViewManagerDelegate<PCButtonView> = PCButtonManagerDelegate(this)
+
+  override fun getName(): String = "PCButton"
+
+  override fun getDelegate(): ViewManagerDelegate<PCButtonView> = delegate
+
+  override fun createViewInstance(reactContext: ThemedReactContext): PCButtonView {
+    return PCButtonView(reactContext)
+  }
+
+  /**
+   * Pass the StateWrapper to the view so it can update Fabric state with its
+   * natural size, and report it right away so the first layout already fits.
+   */
+  override fun updateState(
+    view: PCButtonView,
+    props: ReactStylesDiffMap,
+    stateWrapper: StateWrapper
+  ): Any? {
+    view.stateWrapper = stateWrapper
+    view.reportIntrinsicSize()
+    return null
+  }
+
+  override fun addEventEmitters(reactContext: ThemedReactContext, view: PCButtonView) {
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, view.id)
+    fun dispatch(name: String, fill: WritableMap.() -> Unit = {}) {
+      dispatcher?.dispatchEvent(ButtonEvent(UIManagerHelper.getSurfaceId(view), view.id, name, fill))
+    }
+
+    view.onPress = {
+      PCHaptics.perform(view, view.haptics)
+      dispatch("topButtonPress")
+    }
+    view.onSelectedChange = { selected -> dispatch("topSelectedChange") { putBoolean("selected", selected) } }
+    view.onMenuSelect = { id, title ->
+      dispatch("topMenuSelect") {
+        putString("id", id)
+        putString("title", title)
+      }
+    }
+    view.onMenuOpen = { dispatch("topMenuOpen") }
+    view.onMenuClose = { dispatch("topMenuClose") }
+  }
+
+  /** The checked state follows `selected` once every prop of an update is in. */
+  override fun onAfterUpdateTransaction(view: PCButtonView) {
+    super.onAfterUpdateTransaction(view)
+    view.syncChecked()
+  }
+
+  override fun setLabel(view: PCButtonView, value: String?) {
+    view.applyLabel(value ?: "")
+  }
+
+  // icon: {iconType, iconName, iconUri, iconScale, iconTinted}
+  override fun setIcon(view: PCButtonView, value: ReadableMap?) {
+    view.applyIcon(PCButtonSupport.parseIcon(value))
+  }
+
+  override fun setVariant(view: PCButtonView, value: String?) {
+    view.applyVariant(value)
+  }
+
+  override fun setSize(view: PCButtonView, value: String?) {
+    view.applySize(value)
+  }
+
+  override fun setShape(view: PCButtonView, value: String?) {
+    view.applyShape(value)
+  }
+
+  // "leading" (default) | "trailing"
+  override fun setIconPosition(view: PCButtonView, value: String?) {
+    view.applyIconPosition(value)
+  }
+
+  // Negative = use shape
+  override fun setCornerRadius(view: PCButtonView, value: Double) {
+    view.applyCornerRadius(value.toFloat())
+  }
+
+  override fun setInteractivity(view: PCButtonView, value: String?) {
+    view.applyInteractivity(value)
+  }
+
+  // "true" | "false"
+  override fun setLoading(view: PCButtonView, value: String?) {
+    view.applyLoading(value == "true")
+  }
+
+  // Colors arrive already processed by React Native (ARGB ints)
+  override fun setColor(view: PCButtonView, value: Int?) {
+    view.applyColors(value, view.foregroundColor, view.rippleColor, view.strokeColor)
+  }
+
+  override fun setForegroundColor(view: PCButtonView, value: Int?) {
+    view.applyColors(view.containerColor, value, view.rippleColor, view.strokeColor)
+  }
+
+  override fun setAndroidRippleColor(view: PCButtonView, value: Int?) {
+    view.applyColors(view.containerColor, view.foregroundColor, value, view.strokeColor)
+  }
+
+  override fun setAndroidStrokeColor(view: PCButtonView, value: Int?) {
+    view.applyColors(view.containerColor, view.foregroundColor, view.rippleColor, value)
+  }
+
+  override fun setDisabledColor(view: PCButtonView, value: Int?) {
+    view.applyDisabledColors(value, view.disabledForegroundColor)
+  }
+
+  override fun setDisabledForegroundColor(view: PCButtonView, value: Int?) {
+    view.applyDisabledColors(view.disabledContainerColor, value)
+  }
+
+  // labelStyle: {fontFamily, fontSize, fontWeight, fontStyle}; empty / 0 = default
+  override fun setLabelStyle(view: PCButtonView, value: ReadableMap?) {
+    view.applyLabelStyle(
+      fontFamily = value?.stringOr("fontFamily", "") ?: "",
+      fontSize = value?.doubleOr("fontSize", 0.0)?.toFloat() ?: 0f,
+      fontWeight = value?.stringOr("fontWeight", "") ?: "",
+      fontStyle = value?.stringOr("fontStyle", "") ?: ""
+    )
+  }
+
+  // 0 (or below 1) = no cap
+  override fun setMaxFontSizeMultiplier(view: PCButtonView, value: Double) {
+    view.applyMaxFontSizeMultiplier(value.toFloat())
+  }
+
+  override fun setSpokenLabel(view: PCButtonView, value: String?) {
+    view.applySpokenLabel(value ?: "")
+  }
+
+  // "" (none added) | "none" | "selection" | "light" | "medium" | "heavy" | "success" | "warning" | "error"
+  override fun setHaptics(view: PCButtonView, value: String?) {
+    view.haptics = PCHaptics.configure(view, value)
+  }
+
+  // "expressive" (default) | "m3"
+  override fun setAndroidMaterial(view: PCButtonView, value: String?) {
+    view.applyMaterial(value)
+  }
+
+  // "" (not a toggle) | "true" | "false"
+  override fun setSelected(view: PCButtonView, value: String?) {
+    view.applySelected(value ?: "")
+  }
+
+  // Bumped by JS after every onSelectedChange; the update it causes runs
+  // onAfterUpdateTransaction, which shows `selected` again
+  override fun setSelectedEventCount(view: PCButtonView, value: Int) {}
+
+  // menu: the flattened menu items
+  override fun setMenu(view: PCButtonView, value: ReadableArray?) {
+    view.applyMenu(PCMenuSupport.parseItems(value))
+  }
+
+  // ios: symbol effects, iOS only
+  override fun setIos(view: PCButtonView, value: ReadableMap?) {}
+
+  // --- Events ---
+  private class ButtonEvent(
+    surfaceId: Int,
+    viewTag: Int,
+    private val name: String,
+    private val fill: WritableMap.() -> Unit
+  ) : Event<ButtonEvent>(surfaceId, viewTag) {
+    // Every press counts; two quick presses must not merge into one
+    override fun canCoalesce(): Boolean = false
+
+    override fun getEventName(): String = name
+
+    // Fabric reads the payload from here
+    override fun getEventData(): WritableMap = Arguments.createMap().apply(fill)
+  }
+}

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)