@onekeyfe/react-native-native-list 3.0.157-alpha.254 → 3.0.157-alpha.258

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

@@ -0,0 +1,29 @@
+package com.margelo.nitro.nativelist
+
+/** A per-view hysteresis observer. Null means no bridge event is needed. */
+internal class NativeListScrollPositionTracker {
+  private var start: Double? = null
+  private var end: Double? = null
+  private var previous: Boolean? = null
+
+  fun configure(start: Double?, end: Double?) {
+    this.start = null
+    this.end = null
+    previous = null
+    if (start == null || end == null || !start.isFinite() || !end.isFinite() || start < 0 || end <= start) return
+    this.start = start
+    this.end = end
+  }
+
+  fun resetDelivery() { previous = null }
+
+  fun update(offset: Double): Boolean? {
+    val start = start ?: return null
+    val end = end ?: return null
+    if (!offset.isFinite()) return null
+    val next = if (previous == true) offset > start else offset >= end
+    if (previous == next) return null
+    previous = next
+    return next
+  }
+}

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

@@ -1,5 +1,6 @@
 package com.margelo.nitro.nativelist
 
+import android.content.res.ColorStateList
 import android.graphics.Paint
 import android.graphics.drawable.GradientDrawable
 import android.text.Spannable
@@ -12,6 +13,7 @@ import android.view.Gravity
 import android.view.View
 import android.view.ViewGroup
 import android.widget.LinearLayout
+import android.widget.ProgressBar
 import android.widget.TextView
 import androidx.core.widget.TextViewCompat
 import com.facebook.react.uimanager.ThemedReactContext
@@ -24,6 +26,10 @@ internal class NativeListSectionHeaderRowView(context: ThemedReactContext) :
   private val mainColumn = LinearLayout(context)
   private val titleLine = PackedTitleLineLayout(context)
   private val title = DottedUnderlineTextView(context)
+  private val titleSpinner = ProgressBar(context, null, android.R.attr.progressBarStyleSmall).apply {
+    isIndeterminate = true
+    importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO
+  }
   private val subtitle = NativeListTextView(context)
   private val trailingColumn = LinearLayout(context)
   private val trailingViews = listOf(NativeListTextView(context))
@@ -64,7 +70,8 @@ internal class NativeListSectionHeaderRowView(context: ThemedReactContext) :
       layout == "table" -> 28
       item.json.optString("variant") == "summary" -> 80
       item.json.optString("variant") == "gallery" -> 32
-      item.json.optString("variant") == "history" -> 16
+      item.json.optString("variant") == "history" ->
+        if (item.json.optBoolean("titleLoading")) 20 else 16
       item.json.optString("value").isNotEmpty() && item.json.optJSONObject("checkbox") != null -> 40
       else -> 36
     }
@@ -284,6 +291,7 @@ internal class NativeListSectionHeaderRowView(context: ThemedReactContext) :
       }
     }
     applyTextStyle(item)
+    titleSpinner.indeterminateTintList = ColorStateList.valueOf(title.currentTextColor)
     style
       .optJSONObject("container")
       ?.optString("contentVerticalAlignment")
@@ -403,6 +411,7 @@ internal class NativeListSectionHeaderRowView(context: ThemedReactContext) :
   override fun recycleContent() {
     checkboxControl.reset()
     currentItem = null
+    titleSpinner.visibility = GONE
   }
 
   override fun disposeContent() {
@@ -437,6 +446,12 @@ internal class NativeListSectionHeaderRowView(context: ThemedReactContext) :
     // Linear/sectioned snapshots reserve the ListItem mx=8 at RecyclerView
     // level, so header-local insets below are source px minus that outer inset.
     val headerHorizontalInset = 12
+    if (item.json.optBoolean("titleLoading")) {
+      titleSpinner.visibility = VISIBLE
+      addView(titleSpinner, LayoutParams(dp(20), dp(20)).apply { marginEnd = dp(8) })
+    } else {
+      titleSpinner.visibility = GONE
+    }
     addView(mainColumn, weighted())
     showText(title, item.json.optString("title"), 1)
     if (hasDottedTitle) {

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

@@ -31,6 +31,7 @@ import android.widget.SeekBar
 import android.widget.TextView
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
+import androidx.recyclerview.widget.ConcatAdapter
 import androidx.recyclerview.widget.GridLayoutManager
 import androidx.recyclerview.widget.ItemTouchHelper
 import androidx.recyclerview.widget.LinearLayoutManager
@@ -111,6 +112,37 @@ class NativeListView(
     data class End(val animated: Boolean) : ScrollRequest()
   }
 
+  private val coordinatorOffsetListener = Runnable { emitScrollPositionThresholdIfNeeded() }
+  private var logicalScrollDistancePx = 0
+  private val scrollPositionTracker = NativeListScrollPositionTracker()
+  var onScrollPositionThresholdChange: ((Boolean) -> Unit)? = null
+    set(value) {
+      field = value
+      scrollPositionTracker.resetDelivery()
+      emitScrollPositionThresholdIfNeeded()
+    }
+
+  fun setScrollPositionThresholdsJson(json: String) {
+    val config = runCatching { JSONObject(json) }.getOrNull()
+    scrollPositionTracker.configure(config?.optDouble("start"), config?.optDouble("end"))
+    emitScrollPositionThresholdIfNeeded()
+  }
+
+  private fun emitScrollPositionThresholdIfNeeded() {
+    if (disposed) return
+    val callback = onScrollPositionThresholdChange ?: return
+    if (layoutManager.findFirstVisibleItemPosition() == 0) {
+      layoutManager.findViewByPosition(0)?.let { first ->
+        logicalScrollDistancePx = (recyclerView.paddingTop - layoutManager.getDecoratedTop(first)).coerceAtLeast(0)
+      }
+    }
+    val contributions = recyclerView.getTag(R.id.onekey_native_scroll_coordinator_consumed_offsets) as? Map<*, *>
+    val parentDistance = contributions?.values?.sumOf { (it as? Int)?.coerceAtLeast(0)?.toLong() ?: 0L } ?: 0L
+    val distance = logicalScrollDistancePx.toLong() + parentDistance
+    val next = scrollPositionTracker.update(distance.toDouble() / density) ?: return
+    callback(next)
+  }
+
   var onRowAction: ((String) -> Unit)? = null
   var onActionAnchorInvalidated: ((String) -> Unit)? = null
   var onSelectionDelta: ((String) -> Unit)? = null
@@ -125,9 +157,53 @@ class NativeListView(
   private var configuredBottomPaddingPx = 0
   private val refreshLayout = SwipeRefreshLayout(context)
   private val refreshIndicatorTravelPx = refreshLayout.progressViewEndOffset
+  private val defaultRefreshTriggerDistancePx = (64 * resources.displayMetrics.density).roundToInt()
   private var refreshIndicatorOffsetPx = 0
   private val contentContainer = FrameLayout(context)
   private val adapter = NativeListAdapter(reactContext)
+  private val containerSlots = mutableListOf<View>()
+  private val slotHeights = IntArray(3)
+  private val headerSlotAdapter = NativeListContainerSlotAdapter()
+  private val emptySlotAdapter = NativeListContainerSlotAdapter()
+  private val footerSlotAdapter = NativeListContainerSlotAdapter()
+  private val scrollContentAdapter = ConcatAdapter(headerSlotAdapter, adapter, emptySlotAdapter, footerSlotAdapter)
+
+  fun mountContainerSlot(view: View, index: Int) {
+    containerSlots.add(index.coerceIn(0, containerSlots.size), view)
+    updateContainerSlots()
+  }
+
+  fun containerSlotCount(): Int = containerSlots.size
+  fun containerSlotAt(index: Int): View = containerSlots[index]
+  fun unmountContainerSlot(index: Int) {
+    val view = containerSlots.removeAt(index)
+    (view.parent as? ViewGroup)?.removeView(view)
+    updateContainerSlots()
+  }
+
+  fun setContainerSlotHeightsJson(json: String) {
+    val values = runCatching { JSONArray(json) }.getOrNull() ?: return
+    if (values.length() != 3) return
+    for (index in 0..2) {
+      val value = values.optDouble(index)
+      if (!value.isFinite() || value < 0) return
+    }
+    for (index in 0..2) slotHeights[index] = (values.getDouble(index) * density).roundToInt()
+    updateContainerSlots()
+  }
+
+  private fun updateContainerSlots() {
+    headerSlotAdapter.update(containerSlots.getOrNull(0), slotHeights[0], true)
+    emptySlotAdapter.update(containerSlots.getOrNull(1), slotHeights[1], config?.items?.isEmpty() != false)
+    footerSlotAdapter.update(containerSlots.getOrNull(2), slotHeights[2], true)
+    layoutManager.spanSizeLookup.invalidateSpanIndexCache()
+    recyclerView.requestLayout()
+  }
+
+  private fun scrollPositionForRow(index: Int): Int = index + headerSlotAdapter.itemCount
+  private fun rowPositionForScroll(index: Int): Int =
+    if (index == RecyclerView.NO_POSITION) RecyclerView.NO_POSITION else index - headerSlotAdapter.itemCount
+
   private val layoutManager = NativeListGridLayoutManager(context, 1)
   // OneKey patch: vertical lists retain vertical drags and leave horizontal drags to a parent pager.
   private val pagerGestureTouchSlop = ViewConfiguration.get(context).scaledTouchSlop
@@ -333,7 +409,7 @@ class NativeListView(
 
   init {
     orientation = VERTICAL
-    recyclerView.adapter = adapter
+    recyclerView.adapter = scrollContentAdapter
     recyclerView.layoutManager = layoutManager
     recyclerView.itemAnimator = null
     recyclerView.addOnItemTouchListener(keyboardTapTouchListener)
@@ -345,7 +421,9 @@ class NativeListView(
     layoutManager.spanSizeLookup = object : GridLayoutManager.SpanSizeLookup() {
       override fun getSpanSize(position: Int): Int {
         if (config?.layout != "grid") return 1
-        val type = adapter.itemAt(position)?.type
+        val rowPosition = rowPositionForScroll(position)
+        if (rowPosition !in 0 until adapter.itemCount) return layoutManager.spanCount
+        val type = adapter.itemAt(rowPosition)?.type
         return if (type == "sectionHeader" || type == "system" || type == "action") {
           layoutManager.spanCount
         } else {
@@ -443,6 +521,8 @@ class NativeListView(
       }
 
       override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
+        logicalScrollDistancePx = (logicalScrollDistancePx + dy).coerceAtLeast(0)
+        emitScrollPositionThresholdIfNeeded()
         if (dx != 0 || dy != 0) invalidateActionAnchor("scroll")
         syncSectionIndexToVisibleRows()
         scheduleVisibleEvent()
@@ -469,7 +549,7 @@ class NativeListView(
 
   private fun keyboardTapIsHandled(recyclerView: RecyclerView, event: MotionEvent): Boolean {
     val child = recyclerView.findChildViewUnder(event.x, event.y) ?: return false
-    val position = recyclerView.getChildAdapterPosition(child)
+    val position = rowPositionForScroll(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
@@ -512,6 +592,8 @@ class NativeListView(
   }
 
   private fun updateRefreshIndicatorOffset(offset: Int) {
+    // Let an ancestor render above its shared header without guessing caller offsets.
+    refreshLayout.setTag(R.id.onekey_native_scroll_coordinator_refresh_inset, offset)
     if (refreshIndicatorOffsetPx == offset) return
     refreshIndicatorOffsetPx = offset
     val refreshing = refreshLayout.isRefreshing
@@ -522,6 +604,8 @@ class NativeListView(
 
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
+    recyclerView.setTag(R.id.onekey_native_scroll_coordinator_offset_listener, coordinatorOffsetListener)
+    emitScrollPositionThresholdIfNeeded()
     startStickyHeaderTracking()
     updateSectionIndexAttachment()
     val first = config?.items?.firstOrNull()
@@ -531,6 +615,9 @@ class NativeListView(
   }
 
   override fun onDetachedFromWindow() {
+    if (recyclerView.getTag(R.id.onekey_native_scroll_coordinator_offset_listener) === coordinatorOffsetListener) {
+      recyclerView.setTag(R.id.onekey_native_scroll_coordinator_offset_listener, null)
+    }
     stopStickyHeaderTracking()
     stopSectionIndexAttachmentTracking()
     scheduleSectionIndexAttachmentToList()
@@ -562,6 +649,7 @@ class NativeListView(
         }
       }.toSet()
       config = next
+    updateContainerSlots()
     usesSelectorSourceScale = next.items.any { it.usesSelectorSourceScale }
     adapter.usesSelectorSourceScale = usesSelectorSourceScale
       adapter.theme = next.theme
@@ -592,13 +680,14 @@ class NativeListView(
       previous?.items?.firstOrNull()?.type == "market" &&
       next.items.firstOrNull()?.type == "market" &&
       previous.items.firstOrNull()?.key != next.items.firstOrNull()?.key &&
-      layoutManager.findFirstVisibleItemPosition() == 0
+      rowPositionForScroll(layoutManager.findFirstVisibleItemPosition()) == 0
     ) {
-      layoutManager.findViewByPosition(0)?.let {
+      layoutManager.findViewByPosition(scrollPositionForRow(0))?.let {
         layoutManager.getDecoratedTop(it) - recyclerView.paddingTop
       }
     } else null
     config = next
+    updateContainerSlots()
     usesSelectorSourceScale = next.items.any { it.usesSelectorSourceScale }
     adapter.usesSelectorSourceScale = usesSelectorSourceScale
     if (previous?.generation != next.generation) endReachedGeneration = null
@@ -612,7 +701,7 @@ class NativeListView(
     updateLayout(next)
     adapter.submitList(next.items) {
       if (marketStartOffset != null) {
-        layoutManager.scrollToPositionWithOffset(0, marketStartOffset)
+        layoutManager.scrollToPositionWithOffset(scrollPositionForRow(0), marketStartOffset)
       }
       relayoutContents(preserveMarketPaginationAnchor)
       performPendingScrollIfNeeded()
@@ -621,16 +710,17 @@ class NativeListView(
       if (next.items.isNotEmpty()) checkEndReached()
     }
     refreshLayout.isEnabled = next.pullToRefresh
+    refreshLayout.setDistanceToTriggerSync(next.refreshTriggerDistance?.let { (it * density).roundToInt() } ?: defaultRefreshTriggerDistancePx)
     refreshLayout.isRefreshing = next.refreshing
     bindFooter(next)
     updateReordering(next)
   }
 
   private fun captureVisibleMarketAnchor(): VisibleMarketAnchor? {
-    val position = layoutManager.findFirstVisibleItemPosition()
+    val position = rowPositionForScroll(layoutManager.findFirstVisibleItemPosition()).coerceAtLeast(0)
     if (position == RecyclerView.NO_POSITION) return null
     val item = adapter.itemAt(position) ?: return null
-    val view = layoutManager.findViewByPosition(position) ?: return null
+    val view = layoutManager.findViewByPosition(scrollPositionForRow(position)) ?: return null
     return VisibleMarketAnchor(
       key = item.key,
       offset = layoutManager.getDecoratedTop(view) - recyclerView.paddingTop,
@@ -686,6 +776,7 @@ class NativeListView(
       previous.rowPressToggles != next.rowPressToggles ||
       previous.reorderable != next.reorderable ||
       previous.pullToRefresh != next.pullToRefresh ||
+      previous.refreshTriggerDistance != next.refreshTriggerDistance ||
       previous.refreshing != next.refreshing ||
       previous.loadMore != next.loadMore ||
       previous.endReachedThreshold != next.endReachedThreshold ||
@@ -837,6 +928,7 @@ class NativeListView(
     if (!marketQuoteOnly) invalidateActionAnchor("snapshot")
     val next = current.copy(items = nextItems, selectedKeys = selected)
     config = next
+    updateContainerSlots()
     usesSelectorSourceScale = next.items.any { it.usesSelectorSourceScale }
     adapter.usesSelectorSourceScale = usesSelectorSourceScale
     adapter.selectedKeys = selected
@@ -940,7 +1032,32 @@ class NativeListView(
         true
       }
       is ScrollRequest.End -> {
-        if (current.items.isNotEmpty()) {
+        val finalSlotHeight = when {
+          footerSlotAdapter.itemCount > 0 -> slotHeights[2]
+          emptySlotAdapter.itemCount > 0 -> slotHeights[1]
+          adapter.itemCount == 0 && headerSlotAdapter.itemCount > 0 -> slotHeights[0]
+          else -> null
+        }
+        if (finalSlotHeight != null) {
+          val target = scrollContentAdapter.itemCount - 1
+          if (request.animated) {
+            val manager = layoutManager
+            val scroller = object : LinearSmoothScroller(context) {
+              override fun calculateDyToMakeVisible(view: View, snapPreference: Int): Int =
+                nativeListEndAlignmentOffset(
+                  manager.height - manager.paddingBottom,
+                  manager.getDecoratedBottom(view),
+                )
+            }
+            scroller.targetPosition = target
+            layoutManager.startSmoothScroll(scroller)
+          } else {
+            layoutManager.scrollToPositionWithOffset(
+              target,
+              nativeListEndAlignmentOffset(viewportLength(layoutManager), finalSlotHeight),
+            )
+          }
+        } else if (current.items.isNotEmpty()) {
           performIndexScroll(
             current.items.lastIndex,
             request.animated,
@@ -962,7 +1079,7 @@ class NativeListView(
     viewOffset: Double,
   ) {
     val manager = recyclerView.layoutManager as? LinearLayoutManager ?: return
-    val visibleView = manager.findViewByPosition(index)
+    val visibleView = manager.findViewByPosition(scrollPositionForRow(index))
     val viewPosition = if (alignment == "nearest") {
       val viewportStart = if (manager.orientation == RecyclerView.VERTICAL) {
         manager.paddingTop
@@ -983,7 +1100,7 @@ class NativeListView(
           else -> return
         }
       } else {
-        val firstVisible = manager.findFirstVisibleItemPosition()
+        val firstVisible = rowPositionForScroll(manager.findFirstVisibleItemPosition())
         if (firstVisible != RecyclerView.NO_POSITION && index < firstVisible) 0.0 else 1.0
       }
     } else {
@@ -1010,13 +1127,13 @@ class NativeListView(
           return smoothAlignmentDelta(manager, view, viewPosition, offsetPx)
         }
       }
-      smoothScroller.targetPosition = index
+      smoothScroller.targetPosition = scrollPositionForRow(index)
       manager.startSmoothScroll(smoothScroller)
       return
     }
 
     val provisionalOffset = (viewPosition * viewportLength(manager)).roundToInt() + offsetPx
-    manager.scrollToPositionWithOffset(index, provisionalOffset)
+    manager.scrollToPositionWithOffset(scrollPositionForRow(index), provisionalOffset)
     relayoutRecyclerView()
     alignAfterLayout(index, viewPosition, offsetPx)
   }
@@ -1024,6 +1141,9 @@ class NativeListView(
   private fun performOffsetScroll(offset: Double, animated: Boolean) {
     val manager = recyclerView.layoutManager as? LinearLayoutManager ?: return
     val target = (offset * density).roundToInt().coerceAtLeast(0)
+    if (!animated) {
+      logicalScrollDistancePx = target
+    }
     if (!animated) {
       recyclerView.stopScroll()
       manager.scrollToPositionWithOffset(0, -target)
@@ -1055,7 +1175,7 @@ class NativeListView(
   ) {
     recyclerView.post {
       val manager = recyclerView.layoutManager as? LinearLayoutManager ?: return@post
-      val view = manager.findViewByPosition(index)
+      val view = manager.findViewByPosition(scrollPositionForRow(index))
       if (view == null) {
         if (attemptsRemaining > 0) {
           alignAfterLayout(index, viewPosition, viewOffset, attemptsRemaining - 1)
@@ -1166,6 +1286,7 @@ class NativeListView(
   fun dispose() {
     if (disposed) return
     disposed = true
+    onScrollPositionThresholdChange = null
     if (!isAttachedToWindow) disposeResources()
   }
 
@@ -1234,11 +1355,11 @@ class NativeListView(
       stickyHeaderHost.visibility = GONE
       return
     }
-    val first = layoutManager.findFirstVisibleItemPosition()
+    val first = rowPositionForScroll(layoutManager.findFirstVisibleItemPosition())
     var position = first
     while (position >= 0 && adapter.itemAt(position)?.let(::isStickySectionHeader) != true) position--
     val item = adapter.itemAt(position)
-    if (item == null || first == RecyclerView.NO_POSITION || (layoutManager.findViewByPosition(position)?.top ?: -1) > 0) {
+    if (item == null || first == RecyclerView.NO_POSITION || (layoutManager.findViewByPosition(scrollPositionForRow(position))?.top ?: -1) > 0) {
       stickyHeaderHost.visibility = GONE
       return
     }
@@ -1267,7 +1388,7 @@ class NativeListView(
     var nextTop = Int.MAX_VALUE
     for (index in 0 until recyclerView.childCount) {
       val child = recyclerView.getChildAt(index)
-      val childPosition = recyclerView.getChildAdapterPosition(child)
+      val childPosition = rowPositionForScroll(recyclerView.getChildAdapterPosition(child))
       if (childPosition > position && adapter.itemAt(childPosition)?.let(::isStickySectionHeader) == true) nextTop = minOf(nextTop, child.top)
     }
     stickyHeaderHost.translationY = minOf(0, nextTop - height).toFloat()
@@ -1501,7 +1622,7 @@ class NativeListView(
 
   private fun syncSectionIndexToVisibleRows() {
     if (sectionIndexScrubbing || sectionIndexProgrammaticScroll || sectionIndexEntries.isEmpty()) return
-    val firstVisible = layoutManager.findFirstVisibleItemPosition()
+    val firstVisible = rowPositionForScroll(layoutManager.findFirstVisibleItemPosition())
     if (firstVisible == RecyclerView.NO_POSITION) return
     sectionIndexView.setActiveIndex(
       sectionIndexEntries.indexOfLast { it.position <= firstVisible }.takeIf { it >= 0 },
@@ -1866,6 +1987,7 @@ class NativeListView(
       }
 
       override fun getMovementFlags(recyclerView: RecyclerView, viewHolder: RecyclerView.ViewHolder): Int {
+        if (viewHolder !is NativeListViewHolder) return makeMovementFlags(0, 0)
         val item = adapter.itemAt(viewHolder.bindingAdapterPosition)
         if (item == null || !item.isReorderable) return makeMovementFlags(0, 0)
         val dragFlags = if (next.orientation == "horizontal") ItemTouchHelper.LEFT or ItemTouchHelper.RIGHT else ItemTouchHelper.UP or ItemTouchHelper.DOWN
@@ -1877,6 +1999,7 @@ class NativeListView(
         source: RecyclerView.ViewHolder,
         target: RecyclerView.ViewHolder,
       ): Boolean {
+        if (source !is NativeListViewHolder || target !is NativeListViewHolder) return false
         val from = source.bindingAdapterPosition
         val to = target.bindingAdapterPosition
         val base = pendingReorder ?: adapter.currentList
@@ -2088,7 +2211,7 @@ class NativeListView(
                 ?.takeIf { it != RecyclerView.NO_POSITION }
                 ?: destinationPosition
               val destinationRow = recyclerView
-                .findViewHolderForAdapterPosition(resolvedPosition)
+                .findViewHolderForAdapterPosition(scrollPositionForRow(resolvedPosition))
                 ?.let { it as? NativeListViewHolder }
                 ?.rowView
               val groupRow = destinationRow?.takeIf {
@@ -2251,8 +2374,20 @@ class NativeListView(
     Choreographer.getInstance().postFrameCallback {
       visibleEventScheduled = false
       val manager = recyclerView.layoutManager as? LinearLayoutManager ?: return@postFrameCallback
-      val first = manager.findFirstVisibleItemPosition()
-      val last = manager.findLastVisibleItemPosition()
+      val visibleRows = (0 until recyclerView.childCount).mapNotNull { index ->
+        val child = recyclerView.getChildAt(index)
+        val holder = recyclerView.getChildViewHolder(child) as? NativeListViewHolder ?: return@mapNotNull null
+        val visible = if (manager.orientation == RecyclerView.VERTICAL) {
+          manager.getDecoratedBottom(child) > recyclerView.paddingTop &&
+            manager.getDecoratedTop(child) < recyclerView.height - recyclerView.paddingBottom
+        } else {
+          manager.getDecoratedRight(child) > recyclerView.paddingLeft &&
+            manager.getDecoratedLeft(child) < recyclerView.width - recyclerView.paddingRight
+        }
+        holder.bindingAdapterPosition.takeIf { visible && it != RecyclerView.NO_POSITION }
+      }
+      val first = visibleRows.minOrNull() ?: RecyclerView.NO_POSITION
+      val last = visibleRows.maxOrNull() ?: RecyclerView.NO_POSITION
       val firstKey = adapter.itemAt(first)?.key
       val lastKey = adapter.itemAt(last)?.key
       val signature = "$first:$last:${firstKey.orEmpty()}:${lastKey.orEmpty()}"
@@ -2271,7 +2406,7 @@ class NativeListView(
     val current = config ?: return
     if (!current.loadMore || current.generation == endReachedGeneration || adapter.itemCount == 0) return
     val manager = recyclerView.layoutManager as? LinearLayoutManager ?: return
-    val lastVisible = manager.findLastVisibleItemPosition()
+    val lastVisible = rowPositionForScroll(manager.findLastVisibleItemPosition())
     val thresholdItems = max(1, ceil(adapter.itemCount * current.endReachedThreshold).toInt())
     if (lastVisible >= adapter.itemCount - thresholdItems) {
       endReachedGeneration = current.generation
@@ -2311,7 +2446,7 @@ class NativeListView(
         adapter.currentList.indexOfFirst { it.key == currentAnchor.key }
       } ?: RecyclerView.NO_POSITION
       if (anchor != null && anchorIndex >= 0) {
-        layoutManager.scrollToPositionWithOffset(anchorIndex, anchor.offset)
+        layoutManager.scrollToPositionWithOffset(scrollPositionForRow(anchorIndex), anchor.offset)
       }
       forceLayout()
       measure(
@@ -2473,7 +2608,11 @@ private class ReorderPlaceholderDecoration(
     val isWalletSidebar =
       item.type == "identity" && item.json.optString("presentation") == "walletSidebar"
     if (!isWalletSidebar && item.type != "walletGroup") return
-    val view = parent.findViewHolderForAdapterPosition(position)?.itemView ?: return
+    val view = (0 until parent.childCount).asSequence().map(parent::getChildAt)
+      .firstOrNull { child ->
+        val holder = parent.getChildViewHolder(child)
+        holder is NativeListViewHolder && holder.bindingAdapterPosition == position
+      } ?: return
     bounds.set(
       (view.left + insetPx).toFloat(),
       view.top.toFloat(),
@@ -2744,7 +2883,7 @@ private class ItemSpacingDecoration(
     parent: RecyclerView,
     state: RecyclerView.State,
   ) {
-    if (spacing <= 0) return
+    if (spacing <= 0 || parent.getChildViewHolder(view) !is NativeListViewHolder) return
     val horizontal = (parent.layoutManager as? LinearLayoutManager)?.orientation == RecyclerView.HORIZONTAL
     val item = view.tag as? NativeListItem
     val sourceWallet = item?.type == "identity" && item.json.optString("presentation") == "walletSidebar" && item.hasExplicitHeight
@@ -2766,7 +2905,7 @@ private class SelectorBackgroundDecoration(private val adapter: NativeListAdapte
   override fun onDraw(canvas: Canvas, parent: RecyclerView, state: RecyclerView.State) {
     for (index in 0 until parent.childCount) {
       val child = parent.getChildAt(index)
-      val item = adapter.itemAt(parent.getChildAdapterPosition(child)) ?: continue
+      val item = adapter.itemAt(parent.getChildViewHolder(child).takeIf { it is NativeListViewHolder }?.bindingAdapterPosition ?: RecyclerView.NO_POSITION) ?: continue
       if (!item.json.optBoolean("backgroundFullWidth", false)) continue
       val color = resolveNativeListSelectorBackgroundColor(
         rowType = item.type,

package/android/src/main/res/values/native_scroll_coordinator_ids.xml

@@ -0,0 +1,5 @@
+<resources>
+    <item name="onekey_native_scroll_coordinator_consumed_offsets" type="id" />
+    <item name="onekey_native_scroll_coordinator_offset_listener" type="id" />
+    <item name="onekey_native_scroll_coordinator_refresh_inset" type="id" />
+</resources>

package/android/src/test/java/com/margelo/nitro/nativelist/NativeListEndAlignmentTest.kt

@@ -0,0 +1,34 @@
+package com.margelo.nitro.nativelist
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class NativeListEndAlignmentTest {
+  @Test fun tallFooterEndsAtViewportBottom() {
+    val viewportHeight = 600
+    val footerHeight = 1000
+    val start = nativeListEndAlignmentOffset(viewportHeight, footerHeight)
+    assertEquals(-400, start)
+    assertEquals(viewportHeight, start + footerHeight)
+  }
+
+  @Test fun tallEmptySlotUsesTheSameEndAlignmentWithPadding() {
+    val viewportTop = 80
+    val viewportBottom = 680
+    val emptyHeight = 900
+    val start = viewportTop + nativeListEndAlignmentOffset(viewportBottom - viewportTop, emptyHeight)
+    assertEquals(viewportBottom, start + emptyHeight)
+  }
+
+  @Test fun animatedCorrectionMovesDecoratedBottomToViewportBottom() {
+    val decoratedBottom = 1240
+    val viewportBottom = 680
+    val correction = nativeListEndAlignmentOffset(viewportBottom, decoratedBottom)
+    assertEquals(-560, correction)
+    assertEquals(viewportBottom, decoratedBottom + correction)
+  }
+
+  @Test fun shortFooterRetainsBottomAlignment() {
+    assertEquals(480, nativeListEndAlignmentOffset(600, 120))
+  }
+}

package/android/src/test/java/com/margelo/nitro/nativelist/NativeListScrollPositionTrackerTest.kt

@@ -0,0 +1,28 @@
+package com.margelo.nitro.nativelist
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class NativeListScrollPositionTrackerTest {
+  @Test fun hysteresisAndDisabledLifecycle() {
+    val tracker = NativeListScrollPositionTracker()
+    assertNull(tracker.update(200.0))
+    tracker.configure(48.0, 160.0)
+    assertEquals(false, tracker.update(0.0))
+    assertNull(tracker.update(159.0))
+    assertEquals(true, tracker.update(160.0))
+    assertNull(tracker.update(100.0))
+    assertEquals(false, tracker.update(48.0))
+    assertNull(tracker.update(49.0))
+    tracker.configure(null, null)
+    assertNull(tracker.update(200.0))
+    tracker.configure(48.0, 160.0)
+    assertEquals(true, tracker.update(200.0))
+    tracker.resetDelivery()
+    assertEquals(true, tracker.update(200.0))
+    assertNull(tracker.update(Double.NaN))
+    tracker.configure(48.0, 48.0)
+    assertNull(tracker.update(48.0))
+  }
+}

package/docs/DESIGN.md

@@ -43,8 +43,10 @@ applying them.
 Section headers and scrolling footer/status rows use the flattened row stream.
 `fixedFooter` is a separate descriptor outside that stream, and `emptyState` is
 used when content is empty; both reuse row binders and currently accept only
-`action` or `system` through the public API. A generic public list-header slot is
-not yet exposed. `groupId` and `groupPosition` preserve continuous card geometry
+`action` or `system` through the public API. Native vertical lists additionally
+expose `listHeader`, `listEmpty`, and `listFooter` React container slots. These
+three fixed roots remain outside row identity and scroll with the native list;
+see SPEC.md for mounting, index translation, measurement and platform limits. `groupId` and `groupPosition` preserve continuous card geometry
 without nesting lists inside cells. These placement/grouping rules belong to the
 container even when the displayed content uses an existing row template.