@onekeyfe/react-native-native-list 3.0.157-alpha.249 → 3.0.157-alpha.250

package/android/src/main/java/com/onekey/nativelist/NativeListRendererRowView.kt

@@ -0,0 +1,415 @@
+package com.margelo.nitro.nativelist
+
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.drawable.GradientDrawable
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewOutlineProvider
+import com.facebook.react.uimanager.ThemedReactContext
+import kotlin.math.roundToInt
+import org.json.JSONObject
+
+internal enum class NativeListRendererUpdate {
+  UNCHANGED,
+  CONTENT,
+  ASSETS,
+  REPLACE,
+}
+
+// Shared chrome and binding lifetime; each renderer owns its content views.
+internal abstract class NativeListRendererRowView(protected val reactContext: ThemedReactContext) :
+  NativeListRowHost(reactContext) {
+  protected abstract fun bindContent(
+    item: NativeListItem,
+    theme: JSONObject?,
+    layout: String,
+    checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String,
+  )
+
+  protected open fun bindSelectionContent(
+    item: NativeListItem,
+    checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String,
+  ) {}
+
+  protected abstract fun recycleContent()
+
+  protected abstract fun disposeContent()
+
+  // Evaluated on every bind (including unchanged rebinds), before bindContent.
+  protected open fun usesSourceScale(item: NativeListItem, provided: Boolean) =
+    item.usesSelectorSourceScale || provided
+
+  protected open fun onRowTouch(event: MotionEvent) {}
+
+  protected open fun consumesRowClick() = false
+
+  protected fun setTouchPressed(value: Boolean) {
+    touchPressed = value
+  }
+
+  protected fun retainBoundItem(item: NativeListItem): Boolean {
+    if (current?.key != item.key) return false
+    current = item
+    tag = item
+    return true
+  }
+
+  protected open fun accessibilityText(item: NativeListItem) =
+    item.json.optString("accessibilityLabel", item.json.optString("title"))
+
+  protected open val assetFields: List<String> = emptyList()
+
+  private fun update(old: NativeListItem?, next: NativeListItem): NativeListRendererUpdate {
+    if (old == null || old.key != next.key || old.rendererKey != next.rendererKey)
+      return NativeListRendererUpdate.REPLACE
+    if (old.content == next.content) return NativeListRendererUpdate.UNCHANGED
+    if (
+      assetFields.any {
+        nativeListCanonical(old.json.opt(it)) != nativeListCanonical(next.json.opt(it))
+      }
+    )
+      return NativeListRendererUpdate.ASSETS
+    return NativeListRendererUpdate.CONTENT
+  }
+
+  protected open fun defaultHeight(item: NativeListItem, layout: String) = 0
+
+  protected open fun minimumContentHeight(item: NativeListItem, layout: String, sizeDelta: Int) =
+    dp((defaultHeight(item, layout) + sizeDelta).coerceAtLeast(0))
+
+  protected open fun modelHeight(item: NativeListItem, layout: String): Int? =
+    if (item.json.has("height"))
+      when (item.json.optString("heightRounding")) {
+        "floor" -> (item.json.optDouble("height") * resources.displayMetrics.density).toInt()
+        "nearest" -> stylePx(item.json.optDouble("height"))
+        else -> dp(item.json.optInt("height"))
+      }
+    else null
+
+  protected open fun horizontalWidth(item: NativeListItem) = dp(280)
+
+  protected open val defaultBorderWidth = 0
+
+  protected open fun defaultBorderColor(theme: JSONObject?) = Color.TRANSPARENT
+
+  protected open fun resolvedMeasureHeight(explicit: Int?): Int? = explicit
+
+  protected open val defaultCornerRadius = 0
+  protected open val defaultSeparatorInset = 12
+  protected open val pressChangesBackground = true
+
+  protected open fun pressContent(pressed: Boolean) {}
+
+  protected open val showsSelection = true
+  protected open val pressedColorName = "rowPressedBackground"
+  protected open val pressedColorFallback = "#00000017"
+  private var current: NativeListItem? = null
+  private var theme: JSONObject? = null
+  private var listLayout = "linear"
+  private var itemIndex: Int? = null
+
+  protected open fun unselectedBackground(
+    item: NativeListItem,
+    theme: JSONObject?,
+    layout: String,
+    itemIndex: Int?,
+  ) = color(theme?.optString("rowBackground", "#FFFFFF") ?: "#FFFFFF")
+
+  protected open fun backgroundGroupPosition(
+    item: NativeListItem,
+    layout: String,
+    itemIndex: Int?,
+    selected: Boolean,
+  ) = item.json.optString("groupPosition")
+
+  private var selected = false
+  protected val rowSelected
+    get() = selected
+
+  protected var sourceScale = false
+  private var inputSignature = ""
+  private var explicitHeight: Int? = null
+  private var touchPressed = false
+  private var reorderActive = false
+  private val separator = Paint(Paint.ANTI_ALIAS_FLAG)
+
+  protected fun dp(value: Int) =
+    if (sourceScale) (value * resources.displayMetrics.density).roundToInt()
+    else NativeListScale.dp(resources, value)
+
+  protected fun scaledDp(value: Float) =
+    if (sourceScale) value * resources.displayMetrics.density
+    else NativeListScale.dp(resources, value)
+
+  protected fun stylePx(value: Double) = (value * resources.displayMetrics.density).roundToInt()
+
+  private fun color(value: String, fallback: Int = Color.TRANSPARENT) =
+    runCatching { parseNativeListColor(value) }.getOrDefault(fallback)
+
+  init {
+    orientation = HORIZONTAL
+    setOnClickListener {
+      if (consumesRowClick()) return@setOnClickListener
+      current
+        ?.takeIf { it.isRowPressEnabled }
+        ?.let { onRowPress?.invoke(it, NativeListActionOrigin(this, this, bindingEpoch, "row")) }
+    }
+    setOnTouchListener { _, event ->
+      val wasPressed = touchPressed
+      when (event.actionMasked) {
+        MotionEvent.ACTION_DOWN -> touchPressed = current?.isRowPressEnabled == true
+        // Legacy: leaving the row clears the pressed highlight before release.
+        MotionEvent.ACTION_MOVE ->
+          if (event.x < 0 || event.y < 0 || event.x >= width || event.y >= height)
+            touchPressed = false
+        MotionEvent.ACTION_UP,
+        MotionEvent.ACTION_CANCEL -> touchPressed = false
+      }
+      onRowTouch(event)
+      // Rebuild drawables only when the pressed state actually changes.
+      if (touchPressed != wasPressed) appearance()
+      false
+    }
+  }
+
+  override fun bind(
+    item: NativeListItem,
+    theme: JSONObject?,
+    layout: String,
+    listOrientation: String,
+    itemIndex: Int?,
+    selected: Boolean,
+    checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String,
+    useSourceScale: Boolean,
+  ) {
+    val update = update(current, item)
+    val signature =
+      nativeListCanonical(
+        JSONObject()
+          .put("theme", theme)
+          .put("layout", layout)
+          .put("orientation", listOrientation)
+          .put("sourceScale", useSourceScale)
+          .put("listStyle", listStyle)
+      )
+    sourceScale = usesSourceScale(item, useSourceScale)
+    if (update != NativeListRendererUpdate.UNCHANGED || signature != inputSignature) {
+      if (current != null) onBindingInvalidated?.invoke(this, bindingEpoch)
+      bindingEpoch++
+      if (update == NativeListRendererUpdate.REPLACE) {
+        recycleContent()
+        touchPressed = false
+      }
+      bindContent(item, theme, layout, checkboxState)
+      inputSignature = signature
+    }
+    current = item
+    tag = item
+    this.theme = theme
+    listLayout = layout
+    this.itemIndex = itemIndex
+    this.selected = selected
+    explicitHeight = item.styledHeight?.let(::stylePx) ?: modelHeight(item, layout)
+    val sizeDelta =
+      when (item.json.optString("size")) {
+        "small" -> -8
+        "large" -> 12
+        else -> 0
+      }
+    minimumHeight = if (explicitHeight == null) minimumContentHeight(item, layout, sizeDelta) else 0
+    layoutParams =
+      (layoutParams
+          ?: android.view.ViewGroup.LayoutParams(
+            LayoutParams.MATCH_PARENT,
+            LayoutParams.WRAP_CONTENT,
+          ))
+        .apply {
+          width =
+            if (listOrientation == "horizontal") horizontalWidth(item)
+            else LayoutParams.MATCH_PARENT
+          height = LayoutParams.WRAP_CONTENT
+        }
+    contentDescription = accessibilityText(item)
+    setTag(
+      com.facebook.react.R.id.react_test_id,
+      item.json.optString("testID").takeIf { it.isNotEmpty() },
+    )
+    isEnabled = !item.json.optBoolean("disabled")
+    isClickable = item.isWholeRowInteractive
+    isFocusable = isClickable
+    if (!isEnabled) touchPressed = false
+    bindSelectionContent(item, checkboxState)
+    appearance()
+    requestLayout()
+  }
+
+  override fun bindSelection(
+    item: NativeListItem,
+    theme: JSONObject?,
+    layout: String,
+    itemIndex: Int?,
+    selected: Boolean,
+    checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String,
+  ) {
+    if (current?.key != item.key) return
+    current = item
+    tag = item
+    this.theme = theme
+    this.selected = selected
+    listLayout = layout
+    this.itemIndex = itemIndex
+    bindSelectionContent(item, checkboxState)
+    appearance()
+  }
+
+  protected fun emitAction(
+    key: String,
+    view: View,
+    source: String,
+    slot: Int? = null,
+    target: NativeSelectionTarget? = null,
+    anchorInset: Int = 0,
+  ) {
+    val item = current ?: return
+    // Legacy: row disabled/deprecated state only gates the controls that opted
+    // into it (text accessories, checkboxes, footer actions, retry); icon menus,
+    // leading actions, badges and close controls keep working.
+    if (key.isNotEmpty())
+      onAction?.invoke(
+        item,
+        key,
+        target,
+        NativeListActionOrigin(view, this, bindingEpoch, source, slot, anchorInset),
+      )
+  }
+
+  protected open fun appearance() {
+    val item = current ?: return
+    val pressed = touchPressed || reorderActive
+    pressContent(pressed)
+    val container = item.json.optJSONObject("style")?.optJSONObject("container") ?: JSONObject()
+    val showSelected =
+      showsSelection && selected && (listLayout != "sectioned" || item.json.optBoolean("selected"))
+    val backgroundName =
+      if (pressed && pressChangesBackground) pressedColorName
+      else if (showSelected) "rowSelectedBackground" else "rowBackground"
+    val backgroundFallback =
+      if (pressed && pressChangesBackground) pressedColorFallback
+      else if (showSelected) "#0000000F" else "#FFFFFF"
+    var fill =
+      if (!pressed && !showSelected) unselectedBackground(item, theme, listLayout, itemIndex)
+      else color(theme?.optString(backgroundName, backgroundFallback) ?: backgroundFallback)
+    if (!pressed || !pressChangesBackground) {
+      if (item.json.has("backgroundColor"))
+        fill = color(item.json.optString("backgroundColor"), fill)
+      if (container.has("backgroundColor"))
+        fill = color(container.optString("backgroundColor"), fill)
+    }
+    val position = backgroundGroupPosition(item, listLayout, itemIndex, showSelected)
+    val radius =
+      if (container.has("cornerRadius")) stylePx(container.optDouble("cornerRadius")).toFloat()
+      else if (defaultCornerRadius > 0) dp(defaultCornerRadius).toFloat()
+      else if (listStyle?.has("groupCornerRadius") == true)
+        stylePx(listStyle!!.optDouble("groupCornerRadius")).toFloat()
+      else dp(12).toFloat()
+    val top =
+      container.has("cornerRadius") ||
+        defaultCornerRadius > 0 ||
+        position in setOf("first", "single")
+    val bottom =
+      container.has("cornerRadius") ||
+        defaultCornerRadius > 0 ||
+        position in setOf("last", "single")
+    // Legacy: the pressed fill is always a fully rounded 12dp "single" shape,
+    // independent of the resting group position.
+    val pressedShape =
+      pressed && pressChangesBackground && !container.has("cornerRadius") && defaultCornerRadius <= 0
+    val radii =
+      if (pressedShape) FloatArray(8) { scaledDp(12f) }
+      else FloatArray(8) { if (it < 4 && top || it >= 4 && bottom) radius else 0f }
+    outlineProvider = ViewOutlineProvider.BACKGROUND
+    clipToOutline = container.has("cornerRadius")
+    background =
+      GradientDrawable().apply {
+        setColor(fill)
+        cornerRadii = radii
+      }
+    foreground =
+      if (container.has("borderWidth") || defaultBorderWidth > 0)
+        GradientDrawable().apply {
+          setColor(Color.TRANSPARENT)
+          cornerRadii = radii
+          setStroke(
+            if (container.has("borderWidth")) stylePx(container.optDouble("borderWidth"))
+            else dp(defaultBorderWidth),
+            color(container.optString("borderColor"), defaultBorderColor(theme)),
+          )
+        }
+      else null
+    alpha =
+      container.optDouble("opacity", item.json.optDouble("opacity", 1.0)).toFloat() *
+        if (isEnabled) 1f else 0.5f
+    separator.color =
+      color(
+        listStyle
+          ?.optJSONObject("separator")
+          ?.optString("color", theme?.optString("separator", "#0000001F") ?: "#0000001F")
+          ?: theme?.optString("separator", "#0000001F")
+          ?: "#0000001F"
+      )
+    separator.strokeWidth = 1f
+    invalidate()
+  }
+
+  override fun setReorderActive(active: Boolean) {
+    reorderActive = active
+    appearance()
+  }
+
+  override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+    // Android's native measurement consumes the exact resolved text/image views.
+    super.onMeasure(
+      widthMeasureSpec,
+      resolvedMeasureHeight(explicitHeight)?.let {
+        MeasureSpec.makeMeasureSpec(it, MeasureSpec.EXACTLY)
+      } ?: heightMeasureSpec,
+    )
+  }
+
+  override fun dispatchDraw(canvas: Canvas) {
+    super.dispatchDraw(canvas)
+    current?.takeIf { it.json.optBoolean("separator") }?.let {
+      val start =
+        listStyle
+          ?.optJSONObject("separator")
+          ?.takeIf { it.has("inset") }
+          ?.let { stylePx(it.optDouble("inset")) } ?: dp(defaultSeparatorInset)
+      canvas.drawLine(start.toFloat(), height - 1f, width.toFloat(), height - 1f, separator)
+    }
+  }
+
+  override fun onInitializeAccessibilityNodeInfo(
+    info: android.view.accessibility.AccessibilityNodeInfo
+  ) {
+    super.onInitializeAccessibilityNodeInfo(info)
+    info.viewIdResourceName = getTag(com.facebook.react.R.id.react_test_id) as? String
+  }
+
+  override fun recycle() {
+    if (current != null) onBindingInvalidated?.invoke(this, bindingEpoch)
+    bindingEpoch++
+    current = null
+    tag = null
+    inputSignature = ""
+    touchPressed = false
+    reorderActive = false
+    recycleContent()
+  }
+
+  override fun dispose() {
+    recycle()
+    disposeContent()
+  }
+}

package/android/src/main/java/com/onekey/nativelist/NativeListResolvedText.kt

@@ -0,0 +1,163 @@
+package com.margelo.nitro.nativelist
+
+import android.content.Context
+import android.graphics.Paint
+import android.graphics.Typeface
+import android.text.Spannable
+import android.text.SpannableStringBuilder
+import android.text.TextUtils
+import android.text.style.LineHeightSpan
+import android.util.TypedValue
+import android.view.Gravity
+import android.widget.TextView
+import kotlin.math.roundToInt
+import org.json.JSONObject
+
+internal class NativeListLineHeightSpan(private val height: Int) : LineHeightSpan {
+  override fun chooseHeight(
+    text: CharSequence,
+    start: Int,
+    end: Int,
+    spanstartv: Int,
+    v: Int,
+    fm: Paint.FontMetricsInt,
+  ) {
+    val leading = height - (fm.descent - fm.ascent)
+    fm.ascent -= kotlin.math.ceil(leading / 2.0).toInt()
+    fm.descent += kotlin.math.floor(leading / 2.0).toInt()
+    if (start == 0) fm.top = fm.ascent
+    if (end == text.length) fm.bottom = fm.descent
+  }
+}
+
+internal data class NativeListResolvedText(
+  val text: String,
+  val fontSize: Float,
+  val typeface: Typeface,
+  val color: Int,
+  val lineHeight: Int,
+  val explicitLineHeight: Boolean,
+  val lines: Int,
+  val explicitTruncation: Boolean,
+  val clip: Boolean,
+  val gravity: Int,
+  val offset: Float,
+) {
+  fun bind(view: NativeListTextView) {
+    view.includeFontPadding = false
+    view.fontFeatureSettings = "tnum"
+    view.setTextSize(TypedValue.COMPLEX_UNIT_PX, fontSize)
+    view.typeface = typeface
+    view.setTextColor(color)
+    view.letterSpacing = 0f
+    view.gravity = gravity
+    view.opticalOffsetY = offset
+    view.maxLines = lines
+    view.setHorizontallyScrolling(lines == 1 && explicitTruncation)
+    view.ellipsize = if (explicitTruncation && !clip) TextUtils.TruncateAt.END else null
+    view.setLineSpacing(0f, 1f)
+    if (explicitLineHeight) {
+      view.text =
+        SpannableStringBuilder(text).apply {
+          setSpan(
+            NativeListLineHeightSpan(lineHeight),
+            0,
+            length,
+            Spannable.SPAN_EXCLUSIVE_EXCLUSIVE,
+          )
+        }
+    } else {
+      view.text = text
+      if (lineHeight > 0) androidx.core.widget.TextViewCompat.setLineHeight(view, lineHeight)
+    }
+    view.visibility = if (text.isEmpty()) android.view.View.GONE else android.view.View.VISIBLE
+  }
+
+  companion object {
+    fun resolve(
+      context: Context,
+      text: String,
+      style: JSONObject?,
+      size: Float,
+      weight: String,
+      color: Int,
+      lineHeight: Int,
+      lines: Int,
+      sourceScale: Boolean,
+    ): NativeListResolvedText {
+      val density = context.resources.displayMetrics.density
+      val maxLines = (style?.optInt("lines", lines) ?: lines).coerceIn(1, 3)
+      val truncation = style?.let { it.has("lines") || it.has("truncate") } == true
+      val fontSize =
+        if (style?.has("fontSize") == true) (style.optDouble("fontSize") * density).toFloat()
+        else
+          (if (sourceScale) size else NativeListScale.font(context.resources, size)) *
+            context.resources.displayMetrics.scaledDensity
+      val face =
+        when (style?.optString("fontWeight", weight) ?: weight) {
+          "medium" -> NativeListFonts.medium(context)
+          "semibold" -> NativeListFonts.semibold(context)
+          "bold" -> NativeListFonts.bold(context)
+          else -> NativeListFonts.regular(context)
+        }
+      val line =
+        if (style?.has("lineHeight") == true) (style.optDouble("lineHeight") * density).roundToInt()
+        else if (sourceScale) (lineHeight * density).roundToInt()
+        else NativeListScale.dp(context.resources, lineHeight)
+      val horizontal =
+        when (style?.optString("alignment")) {
+          "center" -> Gravity.CENTER_HORIZONTAL
+          "end" -> Gravity.END
+          else -> Gravity.START
+        }
+      val vertical =
+        when (style?.optString("verticalAlignment")) {
+          "center" -> Gravity.CENTER_VERTICAL
+          "bottom" -> Gravity.BOTTOM
+          else -> Gravity.TOP
+        }
+      return NativeListResolvedText(
+        if (maxLines == 1 && truncation) text.replace(Regex("\\r\\n|[\\r\\n]"), " ") else text,
+        fontSize,
+        face,
+        style
+          ?.optString("color")
+          ?.takeIf { it.isNotEmpty() }
+          ?.let { runCatching { parseNativeListColor(it) }.getOrDefault(color) } ?: color,
+        line,
+        style?.has("lineHeight") == true,
+        maxLines,
+        truncation,
+        style?.optString("truncate") == "clip",
+        horizontal or vertical,
+        ((style?.optDouble("offsetY", 0.0) ?: 0.0) * density).toFloat(),
+      )
+    }
+  }
+}
+
+/**
+ * Legacy selector source-scale typography (accountSelector / networkSelector /
+ * walletSidebar with source scaling): whole-pixel unscaled font size, unhinted
+ * fractional advances and the original line box. A property explicitly set by the
+ * caller's text style (`fontSize`, `lineHeight`) is already resolved in source
+ * units and is left untouched so user style still takes effect.
+ */
+internal fun applyNativeListSourceTypography(view: TextView, style: JSONObject?) {
+  val metrics = view.resources.displayMetrics
+  val line = view.lineHeight
+  view.paintFlags = view.paintFlags or Paint.SUBPIXEL_TEXT_FLAG or Paint.LINEAR_TEXT_FLAG
+  if (style?.has("fontSize") != true)
+    view.setTextSize(
+      TypedValue.COMPLEX_UNIT_PX,
+      kotlin.math.ceil((view.textSize * metrics.density / metrics.scaledDensity).toDouble()).toFloat(),
+    )
+  view.letterSpacing = 0f
+  if (style?.has("lineHeight") != true && view.text.isNotEmpty()) {
+    val text = SpannableStringBuilder(view.text)
+    text.getSpans(0, text.length, NativeListLineHeightSpan::class.java).forEach(text::removeSpan)
+    text.setSpan(NativeListLineHeightSpan(line), 0, text.length, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+    view.setLineSpacing(0f, 1f)
+    view.text = text
+  }
+}

package/android/src/main/java/com/onekey/nativelist/NativeListRowHost.kt

@@ -0,0 +1,70 @@
+package com.margelo.nitro.nativelist
+
+import android.animation.TimeInterpolator
+import android.view.View
+import android.widget.LinearLayout
+import com.facebook.react.uimanager.ThemedReactContext
+import org.json.JSONObject
+
+internal data class NativeListActionOrigin(
+  val sourceView: View,
+  val ownerRowView: NativeListRowHost,
+  val bindingEpoch: Long,
+  val source: String,
+  val slot: Int? = null,
+  val anchorInsetPixels: Int = 0,
+  val windowPointPixels: android.graphics.PointF? = null,
+)
+
+/** List-facing lifecycle shared by template renderers. */
+internal abstract class NativeListRowHost(context: ThemedReactContext) : LinearLayout(context) {
+  var bindingEpoch: Long = 0
+    protected set
+
+  var listStyle: JSONObject? = null
+  var onRowPress: ((NativeListItem, NativeListActionOrigin) -> Unit)? = null
+  var onAction:
+    ((NativeListItem, String, NativeSelectionTarget?, NativeListActionOrigin?) -> Unit)? =
+    null
+  var onBindingInvalidated: ((NativeListRowHost, Long) -> Unit)? = null
+
+  abstract fun bind(
+    item: NativeListItem,
+    theme: JSONObject?,
+    layout: String,
+    listOrientation: String,
+    itemIndex: Int?,
+    selected: Boolean,
+    checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String,
+    useSourceScale: Boolean = false,
+  )
+
+  abstract fun bindSelection(
+    item: NativeListItem,
+    theme: JSONObject?,
+    layout: String,
+    itemIndex: Int?,
+    selected: Boolean,
+    checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String,
+  )
+
+  open fun bindMarketQuote(item: NativeListItem, theme: JSONObject?) {}
+
+  open fun bindStableSummary(item: NativeListItem) {}
+
+  abstract fun recycle()
+
+  abstract fun dispose()
+
+  open fun setReorderActive(active: Boolean) {}
+
+  open fun canStartWalletGroupReorder(localY: Float) = true
+
+  open fun finishWalletGroupReorder(
+    durationMs: Long,
+    interpolator: TimeInterpolator,
+    completion: (() -> Unit)? = null,
+  ) {
+    completion?.invoke()
+  }
+}