@onekeyfe/react-native-native-list 3.0.128 → 3.0.130

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

@@ -19,6 +19,21 @@ class HybridNativeList(context: ThemedReactContext) : HybridNativeListSpec() {
       dispatchToUi { hostView.applySnapshot(value) }
     }
 
+  override var keyboardDismissMode: NativeListKeyboardDismissMode = NativeListKeyboardDismissMode.NONE
+    set(value) {
+      if (field == value) return
+      field = value
+      dispatchToUi { hostView.keyboardDismissMode = value }
+    }
+
+  override var keyboardShouldPersistTaps: NativeListKeyboardShouldPersistTaps =
+    NativeListKeyboardShouldPersistTaps.NEVER
+    set(value) {
+      if (field == value) return
+      field = value
+      dispatchToUi { hostView.keyboardShouldPersistTaps = value }
+    }
+
   override var onRowAction: ((payloadJson: String) -> Unit)? = null
     set(value) { field = value; hostView.onRowAction = value }
   override var onActionAnchorInvalidated: ((payloadJson: String) -> Unit)? = null

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

@@ -876,6 +876,7 @@ internal class NativeListRowView(
     checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String,
     useSourceScale: Boolean = false,
   ) {
+    val reusesImageIdentity = boundKey == item.key && (tag as? NativeListItem)?.type == item.type
     val shouldRestorePressed = touchPressed && boundKey == item.key
     cancelMarketLongPress()
     marketLongPressFired = false
@@ -887,10 +888,13 @@ internal class NativeListRowView(
     tag = item
     selectorUsesSourceScale = item.type == "market" || item.type == "system" && item.json.optString("presentation") == "market" && item.json.optString("variant") == "retry" || item.usesSelectorSourceScale || useSourceScale
     reorderActive = false
-    leadingImages.forEach(OneKeyImageReusableView::prepareForReuse)
-    secondaryImage.prepareForReuse()
-    mediaNetworkImage.prepareForReuse()
-    metricVisualImages.forEach(OneKeyImageReusableView::prepareForReuse)
+    if (!reusesImageIdentity) {
+      selectorImages.forEach(OneKeyImageReusableView::prepareForReuse)
+      leadingImages.forEach(OneKeyImageReusableView::prepareForReuse)
+      secondaryImage.prepareForReuse()
+      mediaNetworkImage.prepareForReuse()
+      metricVisualImages.forEach(OneKeyImageReusableView::prepareForReuse)
+    }
     resetViews()
 
     val primary = color(theme, "primaryText", "#000000DF")
@@ -1014,6 +1018,7 @@ internal class NativeListRowView(
     restoreRestingBackground()
     invalidateCurrentBinding()
     boundKey = null
+    selectorImages.forEach(OneKeyImageReusableView::prepareForReuse)
     leadingImages.forEach(OneKeyImageReusableView::prepareForReuse)
     secondaryImage.prepareForReuse()
     mediaNetworkImage.prepareForReuse()
@@ -1185,11 +1190,10 @@ internal class NativeListRowView(
     marketOriginalPaintFlags.clear()
     selectorLineHeights.clear()
     selectorFontSizes.clear()
+    selectorImages.forEach { (it.parent as? ViewGroup)?.removeView(it) }
     // OneKey patch: selector-only views cannot survive a recycled binding.
     selectorViews.forEach { (it.parent as? ViewGroup)?.removeView(it) }
     selectorViews.clear()
-    selectorImages.forEach(OneKeyImageReusableView::dispose)
-    selectorImages.clear()
     selectorHeight = null
     marketBadgeViews.forEachIndexed { index, badge ->
       (badge.parent as? ViewGroup)?.removeView(badge)
@@ -3386,9 +3390,8 @@ internal class NativeListRowView(
         }
         val image = overlay.optJSONObject("image")
         val view = when {
-          image != null -> OneKeyImageReusableView(reactContext).also {
+          image != null -> (selectorImages.getOrNull(index) ?: OneKeyImageReusableView(reactContext).also(selectorImages::add)).also {
             bindImage(image, it, boundKey ?: "", 10 + index, "generic", hideUntilLoaded = true)
-            selectorImages.add(it)
           }
           overlay.optString("text").isNotEmpty() -> TextView(context).apply {
             text = overlay.optString("text")
@@ -4141,7 +4144,11 @@ internal class NativeListRowView(
     val expectedEpoch = bindingEpoch
     val retryLimit = source.optInt("retryTimes", 0).coerceAtLeast(0)
     val uri = source.optString("uri").trim().takeIf(String::isNotEmpty)
-    if (hideUntilLoaded) imageView.visibility = INVISIBLE
+    val sourceHeadersJson = source.optJSONObject("headers")?.toString()
+    val recyclingKey = if (retryAttempt == 0) "$token:$slot" else "$token:$slot:retry:$retryAttempt"
+    if (hideUntilLoaded && !imageView.isDisplaying(uri, sourceHeadersJson, recyclingKey)) {
+      imageView.visibility = INVISIBLE
+    }
     val handleLoad: (() -> Unit)? = if (hideUntilLoaded) ({
       if (bindingEpoch == expectedEpoch) {
         imageView.visibility = VISIBLE
@@ -4156,12 +4163,12 @@ internal class NativeListRowView(
     }) else onError
     imageView.configure(
       sourceUri = uri,
-      sourceHeadersJson = source.optJSONObject("headers")?.toString(),
+      sourceHeadersJson = sourceHeadersJson,
       variant = variant,
       contentFit = source.optString("contentFit", "cover"),
       cachePolicy = source.optString("cachePolicy", "memory-disk"),
       autoplay = source.optBoolean("autoplay", false),
-      recyclingKey = if (retryAttempt == 0) "$token:$slot" else "$token:$slot:retry:$retryAttempt",
+      recyclingKey = recyclingKey,
       optimizeTos = retryAttempt == 0 && source.optBoolean("optimizeTos", true),
       overscan = source.optDouble("overscan", 1.1),
       loadingStrategy = source.optString("loadingStrategy", "none"),

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

@@ -1,10 +1,12 @@
 package com.margelo.nitro.nativelist
 
 import android.animation.TimeInterpolator
+import android.content.Context
 import android.graphics.Canvas
 import android.graphics.Color
 import android.graphics.Paint
 import android.graphics.Path
+import android.graphics.Rect
 import android.graphics.RectF
 import android.graphics.drawable.ShapeDrawable
 import android.graphics.drawable.shapes.PathShape
@@ -19,12 +21,16 @@ import android.view.MotionEvent
 import android.view.View
 import android.view.ViewConfiguration
 import android.view.ViewGroup
+import android.view.ViewTreeObserver
 import android.view.accessibility.AccessibilityEvent
 import android.view.accessibility.AccessibilityNodeInfo
+import android.view.inputmethod.InputMethodManager
 import android.widget.FrameLayout
 import android.widget.LinearLayout
 import android.widget.SeekBar
 import android.widget.TextView
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
 import androidx.recyclerview.widget.GridLayoutManager
 import androidx.recyclerview.widget.ItemTouchHelper
 import androidx.recyclerview.widget.LinearLayoutManager
@@ -93,6 +99,8 @@ class NativeListView(
   var onReorder: ((String) -> Unit)? = null
   var onEndReached: ((String) -> Unit)? = null
   var onVisibleRangeChanged: ((String) -> Unit)? = null
+  var keyboardDismissMode = NativeListKeyboardDismissMode.NONE
+  var keyboardShouldPersistTaps = NativeListKeyboardShouldPersistTaps.NEVER
   private val density = resources.displayMetrics.density
   private val recyclerView = RecyclerView(context)
   private var configuredTopPaddingPx = 0
@@ -105,6 +113,7 @@ class NativeListView(
   private val layoutManager = GridLayoutManager(context, 1)
   // OneKey patch: vertical lists retain vertical drags and leave horizontal drags to a parent pager.
   private val pagerGestureTouchSlop = ViewConfiguration.get(context).scaledTouchSlop
+  private var pagerGestureIsVertical = false
   private val pagerGestureTouchListener = object : RecyclerView.SimpleOnItemTouchListener() {
     private var downX = 0f
     private var downY = 0f
@@ -117,22 +126,77 @@ class NativeListView(
           downX = event.x
           downY = event.y
           directionResolved = false
+          pagerGestureIsVertical = false
         }
         MotionEvent.ACTION_MOVE -> if (!directionResolved) {
           val deltaX = abs(event.x - downX)
           val deltaY = abs(event.y - downY)
           if (max(deltaX, deltaY) > pagerGestureTouchSlop) {
             directionResolved = true
-            recyclerView.parent?.requestDisallowInterceptTouchEvent(deltaY >= deltaX)
+            pagerGestureIsVertical = deltaY >= deltaX
+            recyclerView.parent?.requestDisallowInterceptTouchEvent(pagerGestureIsVertical)
+            if (
+              pagerGestureIsVertical &&
+              keyboardDismissMode == NativeListKeyboardDismissMode.ON_DRAG
+            ) {
+              dismissKeyboard()
+            }
           }
         }
         MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
           recyclerView.parent?.requestDisallowInterceptTouchEvent(false)
+          pagerGestureIsVertical = false
         }
       }
       return false
     }
   }
+  // Intercept only a completed tap so RecyclerView keeps drag and reorder ownership.
+  private val keyboardTapTouchListener = object : RecyclerView.SimpleOnItemTouchListener() {
+    private var downX = 0f
+    private var downY = 0f
+    private var observingTap = false
+    private var moved = false
+
+    override fun onInterceptTouchEvent(recyclerView: RecyclerView, event: MotionEvent): Boolean {
+      when (event.actionMasked) {
+        MotionEvent.ACTION_DOWN -> {
+          downX = event.x
+          downY = event.y
+          moved = false
+          observingTap =
+            keyboardShouldPersistTaps != NativeListKeyboardShouldPersistTaps.ALWAYS &&
+              focusedTextEditor() != null
+        }
+        MotionEvent.ACTION_MOVE -> if (
+          observingTap && hypot(event.x - downX, event.y - downY) > pagerGestureTouchSlop
+        ) {
+          moved = true
+        }
+        MotionEvent.ACTION_UP -> {
+          val shouldDismiss =
+            observingTap &&
+              !moved &&
+              reorderPlaceholderDecoration.position == RecyclerView.NO_POSITION &&
+              when (keyboardShouldPersistTaps) {
+                NativeListKeyboardShouldPersistTaps.NEVER -> true
+                NativeListKeyboardShouldPersistTaps.HANDLED ->
+                  !keyboardTapIsHandled(recyclerView, event)
+                NativeListKeyboardShouldPersistTaps.ALWAYS -> false
+              }
+          observingTap = false
+          if (shouldDismiss) {
+            dismissKeyboard()
+            return true
+          }
+        }
+        MotionEvent.ACTION_CANCEL -> observingTap = false
+      }
+      return false
+    }
+
+    override fun onTouchEvent(recyclerView: RecyclerView, event: MotionEvent) = Unit
+  }
   private val reorderPlaceholderDecoration = ReorderPlaceholderDecoration(
     adapter = adapter,
     insetPx = dp(REORDER_PLACEHOLDER_INSET_DP),
@@ -169,6 +233,11 @@ class NativeListView(
   private var sectionIndexHapticsEnabled = true
   private val sectionIndexLocationOnScreen = IntArray(2)
   private val sectionIndexHostLocationOnScreen = IntArray(2)
+  private var sectionIndexObservedTree: ViewTreeObserver? = null
+  private val sectionIndexPreDrawListener = ViewTreeObserver.OnPreDrawListener {
+    updateSectionIndexAttachment()
+    true
+  }
   private var pendingScrollRequest: ScrollRequest? = null
   private val actionAnchorInstanceId = UUID.randomUUID().toString()
   private var actionAnchorCounter = 0L
@@ -178,12 +247,14 @@ class NativeListView(
   private var lastLayoutDirection = layoutDirection
   private var lastMarketPaginationAnchorLogAtMs = 0L
   private var disposed = false
+  private var resourcesDisposed = false
 
   init {
     orientation = VERTICAL
     recyclerView.adapter = adapter
     recyclerView.layoutManager = layoutManager
     recyclerView.itemAnimator = null
+    recyclerView.addOnItemTouchListener(keyboardTapTouchListener)
     recyclerView.addOnItemTouchListener(pagerGestureTouchListener)
     recyclerView.addItemDecoration(reorderPlaceholderDecoration)
     // OneKey patch: full-width selector header backgrounds do not change row content insets.
@@ -272,6 +343,12 @@ class NativeListView(
           RecyclerView.SCROLL_STATE_DRAGGING -> {
             sectionIndexProgrammaticScroll = false
             invalidateActionAnchor("scroll")
+            if (
+              keyboardDismissMode == NativeListKeyboardDismissMode.ON_DRAG &&
+              (layoutManager.orientation == RecyclerView.HORIZONTAL || pagerGestureIsVertical)
+            ) {
+              dismissKeyboard()
+            }
           }
           RecyclerView.SCROLL_STATE_IDLE -> sectionIndexProgrammaticScroll = false
         }
@@ -286,6 +363,44 @@ class NativeListView(
     })
   }
 
+  private fun focusedTextEditor(): View? {
+    val insets = ViewCompat.getRootWindowInsets(this)
+    if (insets != null && !insets.isVisible(WindowInsetsCompat.Type.ime())) return null
+    val focused = rootView.findFocus() ?: reactContext.currentActivity?.currentFocus
+    return focused?.takeIf(View::onCheckIsTextEditor)
+  }
+
+  private fun dismissKeyboard(): Boolean {
+    val focused = focusedTextEditor() ?: return false
+    val windowToken = focused.windowToken
+    focused.clearFocus()
+    val inputMethodManager =
+      context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
+    return inputMethodManager.hideSoftInputFromWindow(windowToken, 0)
+  }
+
+  private fun keyboardTapIsHandled(recyclerView: RecyclerView, event: MotionEvent): Boolean {
+    val child = recyclerView.findChildViewUnder(event.x, event.y) ?: return false
+    val position = recyclerView.getChildAdapterPosition(child)
+    val item = adapter.itemAt(position) ?: return false
+    val clickable = clickableDescendantAt(child, event.rawX.toInt(), event.rawY.toInt())
+    val accessoryHandlesTap = clickable != null && clickable !== child
+    return accessoryHandlesTap ||
+      (!item.json.optBoolean("disabled", false) && !item.json.optBoolean("pressDisabled", false))
+  }
+
+  private fun clickableDescendantAt(view: View, rawX: Int, rawY: Int): View? {
+    if (!view.isShown) return null
+    val bounds = Rect()
+    if (!view.getGlobalVisibleRect(bounds) || !bounds.contains(rawX, rawY)) return null
+    if (view is ViewGroup) {
+      for (index in view.childCount - 1 downTo 0) {
+        clickableDescendantAt(view.getChildAt(index), rawX, rawY)?.let { return it }
+      }
+    }
+    return view.takeIf { it.isEnabled && it.isClickable }
+  }
+
   override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
     super.onLayout(changed, left, top, right, bottom)
     val first = config?.items?.firstOrNull()
@@ -328,8 +443,10 @@ class NativeListView(
   }
 
   override fun onDetachedFromWindow() {
+    stopSectionIndexAttachmentTracking()
     attachSectionIndexToList()
     updateRefreshIndicatorOffset(0)
+    if (disposed) disposeResources()
     super.onDetachedFromWindow()
   }
 
@@ -954,17 +1071,25 @@ class NativeListView(
 
   fun dispose() {
     if (disposed) return
+    disposed = true
+    if (!isAttachedToWindow) disposeResources()
+  }
+
+  private fun disposeResources() {
+    if (resourcesDisposed) return
+    resourcesDisposed = true
+    stopSectionIndexAttachmentTracking()
     attachSectionIndexToList()
     stopReorderRelayoutLoop()
     invalidateActionAnchor("destroy")
     actionAnchor = null
-    disposed = true
     pendingScrollRequest = null
     visibleEventScheduled = false
     reorderTouchHandler?.removeCallbacksAndMessages(null)
     reorderTouchHandler = null
     reorderTouchListener?.let(recyclerView::removeOnItemTouchListener)
     reorderTouchListener = null
+    recyclerView.removeOnItemTouchListener(keyboardTapTouchListener)
     recyclerView.removeOnItemTouchListener(pagerGestureTouchListener)
     itemTouchHelper?.attachToRecyclerView(null)
     itemTouchHelper = null
@@ -1093,16 +1218,21 @@ class NativeListView(
 
   private fun updateSectionIndexAttachment() {
     val windowHost = rootView as? FrameLayout
-    val useWindowHost = config?.sectionIndexCenteredInWindow == true &&
+    val canUseWindowHost = config?.sectionIndexCenteredInWindow == true &&
       sectionIndexEntries.isNotEmpty() &&
       isAttachedToWindow &&
-      isShown &&
       width > 0 &&
       height > 0 &&
       windowHost != null &&
       windowHost.width > 0 &&
       windowHost.height > 0 &&
       windowHost !== contentContainer
+    if (canUseWindowHost) {
+      startSectionIndexAttachmentTracking()
+    } else {
+      stopSectionIndexAttachmentTracking()
+    }
+    val useWindowHost = canUseWindowHost && isShown
     if (useWindowHost) {
       attachSectionIndexToWindow(windowHost)
     } else {
@@ -1110,9 +1240,25 @@ class NativeListView(
     }
   }
 
+  private fun startSectionIndexAttachmentTracking() {
+    val observer = viewTreeObserver
+    if (sectionIndexObservedTree === observer) return
+    sectionIndexObservedTree?.takeIf(ViewTreeObserver::isAlive)
+      ?.removeOnPreDrawListener(sectionIndexPreDrawListener)
+    observer.addOnPreDrawListener(sectionIndexPreDrawListener)
+    sectionIndexObservedTree = observer
+  }
+
+  private fun stopSectionIndexAttachmentTracking() {
+    sectionIndexObservedTree?.takeIf(ViewTreeObserver::isAlive)
+      ?.removeOnPreDrawListener(sectionIndexPreDrawListener)
+    sectionIndexObservedTree = null
+  }
+
   private fun attachSectionIndexToList() {
     if (sectionIndexView.parent === contentContainer) return
     (sectionIndexView.parent as? ViewGroup)?.removeView(sectionIndexView)
+    sectionIndexView.translationX = 0f
     contentContainer.addView(
       sectionIndexView,
       FrameLayout.LayoutParams(
@@ -1129,27 +1275,40 @@ class NativeListView(
     windowHost.getLocationOnScreen(sectionIndexHostLocationOnScreen)
     getLocationOnScreen(sectionIndexLocationOnScreen)
     val listLeft = sectionIndexLocationOnScreen[0] - sectionIndexHostLocationOnScreen[0]
-    val maximumEndMargin = (windowHost.width - railWidth).coerceAtLeast(0)
-    val endMargin = if (layoutDirection == LAYOUT_DIRECTION_RTL) {
+    val targetRailLeft = if (layoutDirection == LAYOUT_DIRECTION_RTL) {
       listLeft
     } else {
-      windowHost.width - listLeft - width
-    }.coerceIn(0, maximumEndMargin)
+      listLeft + width - railWidth
+    }
+    val restingRailLeft = if (layoutDirection == LAYOUT_DIRECTION_RTL) {
+      0
+    } else {
+      windowHost.width - railWidth
+    }
     val layoutParams = FrameLayout.LayoutParams(
       railWidth,
       railHeight,
       Gravity.TOP or Gravity.END,
     ).apply {
-      marginEnd = endMargin
       topMargin = (windowHost.height - railHeight) / 2
     }
     if (sectionIndexView.parent !== windowHost) {
       (sectionIndexView.parent as? ViewGroup)?.removeView(sectionIndexView)
       windowHost.addView(sectionIndexView, layoutParams)
       sectionIndexView.bringToFront()
-    } else {
+    } else if (!sectionIndexView.hasSameWindowLayout(layoutParams)) {
       sectionIndexView.layoutParams = layoutParams
     }
+    sectionIndexView.translationX = (targetRailLeft - restingRailLeft).toFloat()
+  }
+
+  private fun View.hasSameWindowLayout(next: FrameLayout.LayoutParams): Boolean {
+    val current = layoutParams as? FrameLayout.LayoutParams ?: return false
+    return current.width == next.width &&
+      current.height == next.height &&
+      current.gravity == next.gravity &&
+      current.marginEnd == next.marginEnd &&
+      current.topMargin == next.topMargin
   }
 
   private fun sectionIndexPreviewBackground(): ShapeDrawable {

package/ios/HybridNativeList.swift

@@ -16,6 +16,26 @@ final class HybridNativeList: HybridNativeListSpec {
     }
   }
 
+  var keyboardDismissMode: NativeListKeyboardDismissMode = .none {
+    didSet {
+      guard keyboardDismissMode != oldValue else { return }
+      runOnMain { [weak self] in
+        guard let self else { return }
+        self.hostView.setKeyboardDismissMode(self.keyboardDismissMode)
+      }
+    }
+  }
+
+  var keyboardShouldPersistTaps: NativeListKeyboardShouldPersistTaps = .never {
+    didSet {
+      guard keyboardShouldPersistTaps != oldValue else { return }
+      runOnMain { [weak self] in
+        guard let self else { return }
+        self.hostView.setKeyboardShouldPersistTaps(self.keyboardShouldPersistTaps)
+      }
+    }
+  }
+
   var onRowAction: ((_ payloadJson: String) -> Void)?
   var onActionAnchorInvalidated: ((_ payloadJson: String) -> Void)?
   var onSelectionDelta: ((_ payloadJson: String) -> Void)?

package/ios/RNCNativeListView.swift

@@ -89,8 +89,18 @@ final class NativeListView: UIView {
     target: self,
     action: #selector(marketLongPressChanged(_:))
   )
+  private lazy var keyboardTapRecognizer = UITapGestureRecognizer(
+    target: self,
+    action: #selector(keyboardTapRecognized(_:))
+  )
+  private lazy var keyboardDragRecognizer = UIPanGestureRecognizer(
+    target: self,
+    action: #selector(keyboardDragRecognized(_:))
+  )
   // OneKey patch: claim only vertical drags so held rows and ancestor pagers stay responsive.
   private lazy var listBodyGestureGuard = UIPanGestureRecognizer(target: nil, action: nil)
+  private var keyboardDismissMode: NativeListKeyboardDismissMode = .none
+  private var keyboardShouldPersistTaps: NativeListKeyboardShouldPersistTaps = .never
   private var interactiveReorderSource: (key: String, index: Int)?
   private weak var interactiveReorderCell: NativeListCell?
   private var interactiveReorderCompactKey: String?
@@ -123,6 +133,16 @@ final class NativeListView: UIView {
     collectionView.dragDelegate = self
     collectionView.dropDelegate = self
     collectionView.alwaysBounceVertical = true
+    keyboardTapRecognizer.cancelsTouchesInView = true
+    keyboardTapRecognizer.delegate = self
+    addGestureRecognizer(keyboardTapRecognizer)
+    keyboardDragRecognizer.cancelsTouchesInView = false
+    keyboardDragRecognizer.delegate = self
+    keyboardDragRecognizer.isEnabled = false
+    if #available(iOS 13.4, *) {
+      keyboardDragRecognizer.allowedScrollTypesMask = .all
+    }
+    collectionView.addGestureRecognizer(keyboardDragRecognizer)
     // OneKey patch: keep list-body drags from being claimed by an ancestor modal sheet.
     listBodyGestureGuard.cancelsTouchesInView = false
     listBodyGestureGuard.isEnabled = false
@@ -228,6 +248,60 @@ final class NativeListView: UIView {
     }
   }
 
+  func setKeyboardDismissMode(_ mode: NativeListKeyboardDismissMode) {
+    keyboardDismissMode = mode
+    keyboardDragRecognizer.isEnabled = mode == .onDrag
+    switch mode {
+    case .none:
+      collectionView.keyboardDismissMode = .none
+    case .onDrag:
+      collectionView.keyboardDismissMode = .onDrag
+    case .interactive:
+      collectionView.keyboardDismissMode = .interactive
+    }
+  }
+
+  func setKeyboardShouldPersistTaps(_ mode: NativeListKeyboardShouldPersistTaps) {
+    keyboardShouldPersistTaps = mode
+  }
+
+  @objc private func keyboardTapRecognized(_ gesture: UITapGestureRecognizer) {
+    guard gesture.state == .ended else { return }
+    window?.endEditing(true)
+  }
+
+  @objc private func keyboardDragRecognized(_ gesture: UIPanGestureRecognizer) {
+    guard gesture.state == .began, keyboardDismissMode == .onDrag else { return }
+    window?.endEditing(true)
+  }
+
+  private func focusedTextInput(in view: UIView?) -> UIView? {
+    guard let view else { return nil }
+    if view.isFirstResponder, view is any UITextInput { return view }
+    for child in view.subviews {
+      if let result = focusedTextInput(in: child) { return result }
+    }
+    return nil
+  }
+
+  private func keyboardTapIsHandled(_ touch: UITouch) -> Bool {
+    var touchedView = touch.view
+    while let current = touchedView, current !== self {
+      if let control = current as? UIControl, control.isEnabled { return true }
+      touchedView = current.superview
+    }
+    if let touchView = touch.view,
+       touchView === footerCell || touchView.isDescendant(of: footerCell) {
+      guard let footer = config?.fixedFooter else { return false }
+      return !footer.data.bool("disabled") && !footer.data.bool("pressDisabled")
+    }
+    let point = touch.location(in: collectionView)
+    guard collectionView.bounds.contains(point),
+          let indexPath = collectionView.indexPathForItem(at: point),
+          let item = item(at: indexPath) else { return false }
+    return !item.data.bool("disabled") && !item.data.bool("pressDisabled")
+  }
+
   required init?(coder: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
@@ -1072,7 +1146,7 @@ final class NativeListView: UIView {
       attachSectionIndexToList()
       return
     }
-    attachSectionIndex(to: hostView)
+    attachSectionIndex(to: hostView, centeredIn: window)
   }
 
   private var sectionIndexHostView: UIView? {
@@ -1110,7 +1184,7 @@ final class NativeListView: UIView {
     NSLayoutConstraint.activate(sectionIndexLayoutConstraints)
   }
 
-  private func attachSectionIndex(to hostView: UIView) {
+  private func attachSectionIndex(to hostView: UIView, centeredIn window: UIWindow) {
     let railHeight = sectionIndexView.preferredHeight(constrainedTo: hostView.bounds.height)
     if sectionIndexView.superview === hostView {
       sectionIndexHostHeightConstraint?.constant = railHeight
@@ -1123,7 +1197,7 @@ final class NativeListView: UIView {
     sectionIndexHostHeightConstraint = heightConstraint
     sectionIndexLayoutConstraints = [
       sectionIndexView.trailingAnchor.constraint(equalTo: safeAreaLayoutGuide.trailingAnchor),
-      sectionIndexView.centerYAnchor.constraint(equalTo: hostView.centerYAnchor),
+      sectionIndexView.centerYAnchor.constraint(equalTo: window.centerYAnchor),
       sectionIndexView.widthAnchor.constraint(equalToConstant: Self.sectionIndexRailWidth),
       heightConstraint,
     ]
@@ -1879,6 +1953,9 @@ final class NativeListView: UIView {
   }
 
   override func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
+    if gestureRecognizer === keyboardDragRecognizer {
+      return keyboardDismissMode == .onDrag && focusedTextInput(in: window) != nil
+    }
     if gestureRecognizer === reorderLongPress || gestureRecognizer === marketLongPress {
       let point = gestureRecognizer.location(in: collectionView)
       guard let indexPath = collectionView.indexPathForItem(at: point),
@@ -1898,6 +1975,20 @@ final class NativeListView: UIView {
 
 extension NativeListView: UIGestureRecognizerDelegate {
   func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool {
+    if gestureRecognizer === keyboardDragRecognizer {
+      return keyboardDismissMode == .onDrag && focusedTextInput(in: window) != nil
+    }
+    if gestureRecognizer === keyboardTapRecognizer {
+      guard focusedTextInput(in: window) != nil else { return false }
+      switch keyboardShouldPersistTaps {
+      case .never:
+        return true
+      case .always:
+        return false
+      case .handled:
+        return !keyboardTapIsHandled(touch)
+      }
+    }
     if gestureRecognizer === listBodyGestureGuard { return true }
     var view = touch.view
     while let current = view, current !== footerCell {
@@ -1911,6 +2002,18 @@ extension NativeListView: UIGestureRecognizerDelegate {
     _ gestureRecognizer: UIGestureRecognizer,
     shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer
   ) -> Bool {
+    if gestureRecognizer === keyboardDragRecognizer {
+      return otherGestureRecognizer === collectionView.panGestureRecognizer ||
+        otherGestureRecognizer === listBodyGestureGuard
+    }
+    if otherGestureRecognizer === keyboardDragRecognizer {
+      return gestureRecognizer === collectionView.panGestureRecognizer ||
+        gestureRecognizer === listBodyGestureGuard
+    }
+    if gestureRecognizer === keyboardTapRecognizer ||
+       otherGestureRecognizer === keyboardTapRecognizer {
+      return false
+    }
     if gestureRecognizer === listBodyGestureGuard {
       guard let otherView = otherGestureRecognizer.view else { return false }
       return otherView === collectionView || otherView.isDescendant(of: collectionView)

package/lib/module/NativeList.js

@@ -27,6 +27,8 @@ function parsePayload(payloadJson) {
 export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
   snapshot,
   webVirtualizationEnabled: _webVirtualizationEnabled,
+  keyboardDismissMode = 'none',
+  keyboardShouldPersistTaps = 'never',
   onRowAction,
   onActionAnchorInvalidated,
   onSelectionDelta,
@@ -41,6 +43,7 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
   initialScrollViewOffset,
   ...viewProps
 }, forwardedRef) {
+  const normalizedKeyboardShouldPersistTaps = keyboardShouldPersistTaps === true ? 'always' : keyboardShouldPersistTaps === false ? 'never' : keyboardShouldPersistTaps;
   const nativeRef = useRef(null);
   const callbacksRef = useRef({
     onRowAction,
@@ -275,7 +278,9 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
   return /*#__PURE__*/_jsx(NativeListHost, {
     ...viewProps,
     ...nativeCallbacks,
-    snapshotJson: snapshotJson
+    snapshotJson: snapshotJson,
+    keyboardDismissMode: keyboardDismissMode,
+    keyboardShouldPersistTaps: normalizedKeyboardShouldPersistTaps
   });
 });
 //# sourceMappingURL=NativeList.js.map

package/lib/module/NativeList.web.js

@@ -23,6 +23,8 @@ export function preloadNativeListAvatarImages(sources) {
 export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
   snapshot,
   webVirtualizationEnabled = true,
+  keyboardDismissMode: _keyboardDismissMode,
+  keyboardShouldPersistTaps: _keyboardShouldPersistTaps,
   onRowAction,
   onActionAnchorInvalidated,
   onSelectionDelta,