@onekeyfe/react-native-pager-view 3.0.157-alpha.257 → 3.0.157-alpha.262

package/android/src/main/java/com/reactnativepagerview/CollapsiblePagerHost.kt

@@ -1,6 +1,8 @@
 package com.reactnativepagerview
 
 import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Matrix
 import android.graphics.Rect
 import android.os.SystemClock
 import android.view.MotionEvent
@@ -19,11 +21,11 @@ import androidx.core.view.ViewCompat
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import androidx.swiperefreshlayout.widget.CircularProgressDrawable
+import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
 import androidx.viewpager2.widget.ViewPager2
 import com.facebook.react.R as ReactR
 import com.facebook.react.uimanager.events.NativeGestureUtil
 import com.facebook.react.views.scroll.ReactScrollView
-import com.facebook.react.views.swiperefresh.ReactSwipeRefreshLayout
 import com.margelo.nitro.nativelogger.OneKeyLog
 import java.lang.ref.WeakReference
 import java.util.WeakHashMap
@@ -120,12 +122,24 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private val restoredRecyclerKeys = WeakHashMap<RecyclerView, String>()
   private val originalScrollerPadding = WeakHashMap<ScrollView, ScrollerPadding>()
   private val restoredScrollerKeys = WeakHashMap<ScrollView, String>()
-  private val scrollerRefreshIndicators = WeakHashMap<ScrollView, WeakReference<View>>()
+  private val ownedScrollerKeys = WeakHashMap<NativeScrollerViewport, String>()
+  private var foregroundRefreshIndicator: WeakReference<ImageView>? = null
+  private var refreshForegroundWasVisible = false
+  private val refreshForegroundMatrix = Matrix()
+  private val refreshForegroundOrigin = FloatArray(2)
+  private val refreshForegroundAncestors = ArrayList<View>()
+  private var refreshForegroundAncestorAlpha = 1f
   private val pageOffsets = HashMap<String, Int>()
   private var observedRecyclerView: RecyclerView? = null
   private var observedScrollListener: RecyclerView.OnScrollListener? = null
+  private var observedOwnedScroller: NativeScrollerViewport? = null
+  private var observedOwnedScrollerKey: String? = null
+  private var observedOwnedScrollerListener: ViewTreeObserver.OnScrollChangedListener? = null
+  private var observedOwnedScrollerTreeObserver: ViewTreeObserver? = null
   private var observedNativeScroller: ScrollView? = null
   private var observedNativeScrollerListener: ViewTreeObserver.OnScrollChangedListener? = null
+  private var observedNativeScrollerTreeObserver: ViewTreeObserver? = null
+  private var observedPageRemoved = false
   private var attachmentGeneration = 0
   private val touchSlopPx = ViewConfiguration.get(context).scaledTouchSlop
   private val hostIdentity = System.identityHashCode(this)
@@ -139,6 +153,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private var headerDownEvent: MotionEvent? = null
   private var headerHasHorizontalChild = false
   private var forwardedScrollable: View? = null
+  private var pendingRefreshPull: WeakReference<SwipeRefreshLayout>? = null
   private var nativeGestureStarted = false
   private var pressCancelled = false
   private val pageContentLayoutListener = ViewTreeObserver.OnPreDrawListener {
@@ -314,6 +329,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   }
 
   fun removeReactChild(child: View) {
+    releaseRefreshForeground()
     val index = logicalChildren.indexOf(child)
     if (index < 0) return
     logicalChildren.removeAt(index)
@@ -327,10 +343,17 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
         stickyHeaderView = null
       }
       else -> {
+        val observed = observedRecyclerView ?: observedOwnedScroller ?: observedNativeScroller
+        if (observed != null && isDescendant(observed, child)) {
+          // The page detaches only later; its scroller must not keep writing this key.
+          detachPrimaryScrollObserver(recordOffset = false)
+          observedPageRemoved = true
+        }
         when (val scrollable =
           findExplicitNativeScrollerInView(child) ?: findVerticalScrollableView(child)) {
           is RecyclerView -> restoreRecyclerInsets(scrollable)
           is ScrollView -> restoreNativeScrollerInsets(scrollable)
+          is NativeScrollerViewport -> restoreOwnedScrollerInsets(scrollable)
         }
         adapter.removePage(child)
         log("page-detach slot=${index - PAGE_SLOT_OFFSET} nativePages=${adapter.itemCount}")
@@ -339,6 +362,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   }
 
   fun removeAllReactChildren() {
+    releaseRefreshForeground()
     detachPrimaryScrollObserver()
     for (recycler in originalRecyclerPadding.keys.toList()) {
       restoreRecyclerInsets(recycler)
@@ -346,6 +370,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     for (scroller in originalScrollerPadding.keys.toList()) {
       restoreNativeScrollerInsets(scroller)
     }
+    for (scroller in ownedScrollerKeys.keys.toList()) restoreOwnedScrollerInsets(scroller)
     headerView?.let { view -> super.removeView(view) }
     stickyHeaderView?.let { view -> super.removeView(view) }
     headerView = null
@@ -361,8 +386,10 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   fun reactChildAt(index: Int) = logicalChildren[index]
 
   fun selectPage(position: Int) {
+    pendingRefreshPull = null
     if (adapter.itemCount == 0) return
     detachPrimaryScrollObserver()
+    releaseRefreshForeground()
     selectedPage = position.coerceIn(0, adapter.itemCount - 1)
     val savedOffset = pageOffsets[currentPageKey()]
       ?: primaryScrollableForPage(selectedPage)?.let(::verticalScrollOffset)
@@ -396,7 +423,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   fun attachedPageCount(): Int = (pager.getChildAt(0) as? RecyclerView)?.childCount ?: 0
 
   fun observedScrollableCount(): Int =
-    originalRecyclerPadding.size + originalScrollerPadding.size
+    originalRecyclerPadding.size + originalScrollerPadding.size + ownedScrollerKeys.size
 
   private fun layoutPagerIfRequested() {
     val recycler = pager.getChildAt(0) as? RecyclerView ?: return
@@ -493,6 +520,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
 
   private fun maximumHeaderOffset(): Int {
     val scrollable = observedRecyclerView
+      ?: observedOwnedScroller
       ?: observedNativeScroller
       ?: primaryScrollableForPage(selectedPage)
       ?: return headerHeightPx
@@ -514,7 +542,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     applyHeaderOffset()
   }
 
-  private fun publishConsumedOffset(recycler: RecyclerView, remove: Boolean = false) {
+  private fun publishConsumedOffset(recycler: View, remove: Boolean = false) {
     val key = R.id.onekey_native_scroll_coordinator_consumed_offsets
     val existing = recycler.getTag(key) as? NativeScrollCoordinatorContributions
     val contributions = existing ?: if (remove) return else NativeScrollCoordinatorContributions().also {
@@ -535,6 +563,8 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     nativeTabBarView.translationY = -offset
     nativeSubHeaderView.translationY = -offset
     observedRecyclerView?.let { publishConsumedOffset(it) }
+    // Adjacent owned pages are translated too; unchanged values are not republished.
+    for (scroller in ownedScrollerKeys.keys) publishConsumedOffset(scroller)
   }
 
   private fun pageKey(index: Int): String = pageKeys.getOrNull(index) ?: "page-$index"
@@ -561,6 +591,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   }
 
   private fun findExplicitNativeScrollerInView(view: View): View? {
+    if (view is NativeScrollerView) return view.viewport
     if (view !== this && view is CollapsiblePagerHost) {
       return view.currentPrimaryScrollableForParent()
     }
@@ -577,6 +608,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   }
 
   private fun findVerticalScrollableView(view: View): View? {
+    if (view is NativeScrollerView) return view.viewport
     if (view !== this && view is CollapsiblePagerHost) {
       return view.currentPrimaryScrollableForParent()
     }
@@ -605,30 +637,28 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private fun verticalScrollOffset(view: View): Int = when (view) {
     is RecyclerView -> view.computeVerticalScrollOffset()
     is ScrollView -> view.scrollY
+    is NativeScrollerViewport -> view.scrollY
     else -> 0
   }
 
   private fun prepareAdjacentPages() {
-    // Retained pages and replaced controls may leave the attached view tree.
-    for ((scroller, indicator) in scrollerRefreshIndicators.toMap()) {
-      if (nativeScrollerRefreshIndicator(scroller) !== indicator.get()) {
-        restoreNativeScrollerRefreshIndicator(scroller)
-      }
-    }
     val first = max(0, selectedPage - 1)
     val last = min(adapter.itemCount - 1, selectedPage + 1)
     for (index in first..last) {
       when (val scrollable = primaryScrollableForPage(index)) {
         is RecyclerView -> applyRecyclerInsets(scrollable, index)
         is ScrollView -> applyNativeScrollerInsets(scrollable, index)
+        is NativeScrollerViewport -> applyOwnedScrollerInsets(scrollable, index)
       }
     }
+    updateRefreshForeground()
   }
 
   private fun attachPrimaryScrollObserver() {
     if (selectedPage !in 0 until adapter.itemCount) return
-    val previous = observedRecyclerView ?: observedNativeScroller
-    if (previous != null && !isDescendant(previous, adapter.pageAt(selectedPage))) {
+    val previous = observedRecyclerView ?: observedOwnedScroller ?: observedNativeScroller
+    if (observedPageRemoved || previous != null && !isDescendant(previous, adapter.pageAt(selectedPage))) {
+      observedPageRemoved = false
       detachPrimaryScrollObserver()
       // A replacement scroller starts at the beginning while retaining header collapse.
       pageOffsets[currentPageKey()] = 0
@@ -636,6 +666,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     when (val scrollable = primaryScrollableForPage(selectedPage)) {
       is RecyclerView -> attachRecyclerObserver(scrollable)
       is ScrollView -> attachNativeScrollerObserver(scrollable)
+      is NativeScrollerViewport -> attachOwnedScrollerObserver(scrollable)
     }
   }
 
@@ -669,11 +700,11 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     )
   }
 
-  private fun detachRecyclerObserver() {
+  private fun detachRecyclerObserver(recordOffset: Boolean) {
     val recycler = observedRecyclerView
     val listener = observedScrollListener
     if (recycler != null) {
-      pageOffsets[currentPageKey()] = recycler.computeVerticalScrollOffset()
+      if (recordOffset) pageOffsets[currentPageKey()] = recycler.computeVerticalScrollOffset()
       publishConsumedOffset(recycler, remove = true)
     }
     if (recycler != null && listener != null) recycler.removeOnScrollListener(listener)
@@ -696,27 +727,35 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     detachPrimaryScrollObserver()
     observedNativeScroller = scroller
     applyNativeScrollerInsets(scroller, selectedPage)
-    val listener = ViewTreeObserver.OnScrollChangedListener {
-      val contentOffset = scroller.scrollY
-      pageOffsets[currentPageKey()] = contentOffset
-      if (contentOffset > 0 && headerOffsetPx < headerHeightPx) {
-        setHeaderOffset(headerHeightPx)
+    val listener = object : ViewTreeObserver.OnScrollChangedListener {
+      override fun onScrollChanged() {
+        if (observedNativeScrollerListener !== this) {
+          removeScrollChangedListener(null, scroller, this)
+          return
+        }
+        val contentOffset = scroller.scrollY
+        pageOffsets[currentPageKey()] = contentOffset
+        if (contentOffset > 0 && headerOffsetPx < headerHeightPx) {
+          setHeaderOffset(headerHeightPx)
+        }
       }
     }
     observedNativeScrollerListener = listener
-    scroller.viewTreeObserver.addOnScrollChangedListener(listener)
+    observedNativeScrollerTreeObserver = scroller.viewTreeObserver.also {
+      it.addOnScrollChangedListener(listener)
+    }
     log(
       "scroller-observer-attach inner=$selectedPage key=${currentPageKey()} " +
         "scroller=${System.identityHashCode(scroller)}",
     )
   }
 
-  private fun detachNativeScrollerObserver() {
+  private fun detachNativeScrollerObserver(recordOffset: Boolean) {
     val scroller = observedNativeScroller
     val listener = observedNativeScrollerListener
-    if (scroller != null) pageOffsets[currentPageKey()] = scroller.scrollY
-    if (scroller != null && listener != null && scroller.viewTreeObserver.isAlive) {
-      scroller.viewTreeObserver.removeOnScrollChangedListener(listener)
+    if (scroller != null && recordOffset) pageOffsets[currentPageKey()] = scroller.scrollY
+    if (scroller != null && listener != null) {
+      removeScrollChangedListener(observedNativeScrollerTreeObserver, scroller, listener)
     }
     if (scroller != null) {
       log(
@@ -726,11 +765,87 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     }
     observedNativeScroller = null
     observedNativeScrollerListener = null
+    observedNativeScrollerTreeObserver = null
   }
 
-  private fun detachPrimaryScrollObserver() {
-    detachRecyclerObserver()
-    detachNativeScrollerObserver()
+  private fun detachPrimaryScrollObserver(recordOffset: Boolean = true) {
+    detachOwnedScrollerObserver(recordOffset)
+    detachRecyclerObserver(recordOffset)
+    detachNativeScrollerObserver(recordOffset)
+  }
+
+  private fun removeScrollChangedListener(
+    registered: ViewTreeObserver?,
+    scroller: View,
+    listener: ViewTreeObserver.OnScrollChangedListener,
+  ) {
+    // A detached scroller returns a new floating observer, while the listener is
+    // still registered on the window observer. Try every instance that can own it.
+    for (observer in arrayOf(registered, scroller.viewTreeObserver, viewTreeObserver)) {
+      if (observer != null && observer.isAlive) observer.removeOnScrollChangedListener(listener)
+    }
+  }
+
+  private fun applyOwnedScrollerInsets(scroller: NativeScrollerViewport, pageIndex: Int) {
+    scroller.host.setPagerInset(this, headerHeightPx + stickyHeaderHeightPx)
+    publishConsumedOffset(scroller)
+    val key = pageKey(pageIndex)
+    if (ownedScrollerKeys[scroller] == key) return
+    ownedScrollerKeys[scroller] = key
+    postForCurrentAttachment {
+      if (ownedScrollerKeys[scroller] == key && scroller.isAttachedToWindow) {
+        scroller.host.restoreScrollOffset(pageOffsets[key] ?: 0)
+      }
+    }
+  }
+
+  private fun restoreOwnedScrollerInsets(scroller: NativeScrollerViewport) {
+    scroller.stopMotion()
+    scroller.host.cancelPendingScrollRestore()
+    ownedScrollerKeys.remove(scroller)
+    publishConsumedOffset(scroller, remove = true)
+    scroller.host.setPagerInset(this, null)
+  }
+
+  private fun attachOwnedScrollerObserver(scroller: NativeScrollerViewport) {
+    if (observedOwnedScroller === scroller && observedOwnedScrollerKey == currentPageKey()) {
+      applyOwnedScrollerInsets(scroller, selectedPage)
+      return
+    }
+    detachPrimaryScrollObserver()
+    observedOwnedScroller = scroller
+    observedOwnedScrollerKey = currentPageKey()
+    val key = currentPageKey()
+    applyOwnedScrollerInsets(scroller, selectedPage)
+    val listener = object : ViewTreeObserver.OnScrollChangedListener {
+      override fun onScrollChanged() {
+        if (observedOwnedScrollerListener !== this) {
+          removeScrollChangedListener(null, scroller, this)
+          return
+        }
+        val contentOffset = scroller.scrollY
+        pageOffsets[key] = contentOffset
+        if (contentOffset > 0 && headerOffsetPx < headerHeightPx) setHeaderOffset(headerHeightPx)
+      }
+    }
+    observedOwnedScrollerListener = listener
+    observedOwnedScrollerTreeObserver = scroller.viewTreeObserver.also {
+      it.addOnScrollChangedListener(listener)
+    }
+  }
+
+  private fun detachOwnedScrollerObserver(recordOffset: Boolean) {
+    val scroller = observedOwnedScroller ?: return
+    scroller.stopMotion()
+    publishConsumedOffset(scroller, remove = true)
+    if (recordOffset) observedOwnedScrollerKey?.let { pageOffsets[it] = scroller.scrollY }
+    observedOwnedScrollerListener?.let {
+      removeScrollChangedListener(observedOwnedScrollerTreeObserver, scroller, it)
+    }
+    observedOwnedScroller = null
+    observedOwnedScrollerKey = null
+    observedOwnedScrollerListener = null
+    observedOwnedScrollerTreeObserver = null
   }
 
   private fun applyRecyclerInsets(recycler: RecyclerView, pageIndex: Int) {
@@ -805,7 +920,6 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     updateScrollerPaddingOwnership(scroller, original)
     val topInset = headerHeightPx + stickyHeaderHeightPx
     scroller.clipToPadding = false
-    applyNativeScrollerRefreshIndicator(scroller, topInset)
     if (scroller is ReactScrollView) {
       // Fabric owns the content child's layout, so ScrollView padding alone
       // cannot move it. RN's native ScrollAway API also updates Fabric culling.
@@ -908,7 +1022,6 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   }
 
   private fun restoreNativeScrollerInsets(scroller: ScrollView) {
-    restoreNativeScrollerRefreshIndicator(scroller)
     val original = originalScrollerPadding.remove(scroller) ?: return
     updateScrollerPaddingOwnership(scroller, original)
     restoredScrollerKeys.remove(scroller)
@@ -923,12 +1036,14 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     scroller.setPadding(original.left, original.top, original.right, original.bottom)
   }
 
-  private fun nativeScrollerRefreshIndicator(scroller: ScrollView): View? {
-    if (!nativeSmoothHeaderScrollEnabled) return null
-    var ancestor = scroller.parent
-    while (ancestor != null && ancestor !== this) ancestor = ancestor.parent
-    if (ancestor !== this) return null
-    val refresh = scroller.parent as? ReactSwipeRefreshLayout ?: return null
+  private fun refreshLayoutFor(scrollable: View): SwipeRefreshLayout? {
+    if (scrollable !is ScrollView && scrollable !is RecyclerView && scrollable !is NativeScrollerViewport) return null
+    var ancestor = scrollable.parent
+    while (ancestor != null && ancestor !is SwipeRefreshLayout) ancestor = ancestor.parent
+    return ancestor as? SwipeRefreshLayout
+  }
+
+  private fun refreshIndicatorFor(refresh: SwipeRefreshLayout): ImageView? {
     for (index in 0 until refresh.childCount) {
       val child = refresh.getChildAt(index)
       if (child is ImageView && child.drawable is CircularProgressDrawable) return child
@@ -936,29 +1051,119 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     return null
   }
 
-  private fun applyNativeScrollerRefreshIndicator(scroller: ScrollView, inset: Int) {
-    val indicator = nativeScrollerRefreshIndicator(scroller)
-    if (scrollerRefreshIndicators[scroller]?.get() !== indicator) {
-      restoreNativeScrollerRefreshIndicator(scroller)
+  private fun refreshForegroundOwner(scrollable: View): CollapsiblePagerHost? {
+    var owner: CollapsiblePagerHost? = null
+    var ancestor = scrollable.parent
+    while (ancestor != null) {
+      if (ancestor is CollapsiblePagerHost && ancestor.nativeSmoothHeaderScrollEnabled &&
+        ancestor.isAttachedToWindow && ancestor.isShown &&
+        ancestor.primaryScrollableForPage(ancestor.selectedPage) === scrollable) {
+        owner = ancestor
+      }
+      ancestor = ancestor.parent
+    }
+    return owner
+  }
+
+  private fun updateRefreshForeground() {
+    val scrollable = primaryScrollableForPage(selectedPage)
+    val refresh = scrollable?.takeIf { refreshForegroundOwner(it) === this }?.let(::refreshLayoutFor)
+    val indicator = refresh?.let(::refreshIndicatorFor)
+    if (foregroundRefreshIndicator?.get() !== indicator) releaseRefreshForeground()
+    if (indicator != null) {
+      if (foregroundRefreshIndicator?.get() !== indicator) {
+        foregroundRefreshIndicator = WeakReference(indicator)
+      }
+      val state = refreshIndicatorAlphas.getOrPut(indicator) {
+        NativeRefreshForegroundAlpha(indicator.alpha)
+      }
+      val alpha = state.update(indicator.alpha, this, acquire = true)
+      if (indicator.alpha != alpha) indicator.alpha = alpha
     }
-    if (indicator == null) return
-    if (scrollerRefreshIndicators[scroller]?.get() !== indicator) {
-      scrollerRefreshIndicators[scroller] = WeakReference(indicator)
+    val visible = indicator?.isShown == true &&
+      (refreshIndicatorAlphas[indicator]?.drawingAlpha ?: 0f) > 0f
+    // The foreground lies outside the original child's invalidation rectangle.
+    // Repaint once on disappearance as well as throughout the native animation.
+    if (visible || refreshForegroundWasVisible) postInvalidateOnAnimation()
+    refreshForegroundWasVisible = visible
+  }
+
+  private fun releaseRefreshForeground() {
+    val indicator = foregroundRefreshIndicator?.get()
+    foregroundRefreshIndicator = null
+    if (indicator != null) {
+      refreshIndicatorAlphas[indicator]?.let { state ->
+        indicator.alpha = state.update(indicator.alpha, this, acquire = false)
+        if (state.isEmpty) refreshIndicatorAlphas.remove(indicator)
+      }
     }
-    val translation = refreshIndicatorTranslations.getOrPut(indicator) {
-      NativeScrollerRefreshTranslation(indicator.translationY)
+    if (indicator != null || refreshForegroundWasVisible) invalidate()
+    refreshForegroundWasVisible = false
+  }
+
+  private fun refreshMatrixInHost(refresh: View): Boolean {
+    refreshForegroundMatrix.reset()
+    refreshForegroundAncestorAlpha = 1f
+    refreshForegroundAncestors.clear()
+    try {
+      var current: View? = refresh
+      while (current != null && current !== this) {
+        refreshForegroundAncestors.add(current)
+        current = current.parent as? View
+      }
+      if (current !== this) return false
+      for (index in refreshForegroundAncestors.lastIndex downTo 0) {
+        val child = refreshForegroundAncestors[index]
+        val parent = child.parent as? View ?: return false
+        refreshForegroundMatrix.preTranslate(
+          (child.left - parent.scrollX).toFloat(), (child.top - parent.scrollY).toFloat(),
+        )
+        refreshForegroundMatrix.preConcat(child.matrix)
+        refreshForegroundAncestorAlpha *= child.alpha
+      }
+      return true
+    } finally {
+      refreshForegroundAncestors.clear()
     }
-    // Moving only the drawing preserves RN's offsets and AndroidX's active pull/refresh animation.
-    // setProgressViewOffset would reset that animation and clear isRefreshing.
-    val next = translation.update(indicator.translationY, this, inset.toFloat())
-    if (indicator.translationY != next) indicator.translationY = next
   }
 
-  private fun restoreNativeScrollerRefreshIndicator(scroller: ScrollView) {
-    val indicator = scrollerRefreshIndicators.remove(scroller)?.get() ?: return
-    val translation = refreshIndicatorTranslations[indicator] ?: return
-    indicator.translationY = translation.update(indicator.translationY, this, null)
-    if (translation.isEmpty) refreshIndicatorTranslations.remove(indicator)
+  override fun dispatchDraw(canvas: Canvas) {
+    // The original parent advances native refresh animations and their listeners.
+    super.dispatchDraw(canvas)
+    val indicator = foregroundRefreshIndicator?.get() ?: return
+    val scrollable = primaryScrollableForPage(selectedPage) ?: return
+    if (refreshForegroundOwner(scrollable) !== this) return
+    val refresh = refreshLayoutFor(scrollable) ?: return
+    if (refreshIndicatorFor(refresh) !== indicator || !indicator.isShown ||
+      indicator.width <= 0 || indicator.height <= 0 || !refreshMatrixInHost(refresh)) return
+    val alpha = (refreshIndicatorAlphas[indicator]?.drawingAlpha ?: return) *
+      refreshForegroundAncestorAlpha
+    if (alpha <= 0f) return
+    refreshForegroundOrigin[0] = 0f
+    refreshForegroundOrigin[1] = 0f
+    refreshForegroundMatrix.mapPoints(refreshForegroundOrigin)
+    val appliedInset = (refresh.getTag(R.id.onekey_native_scroll_coordinator_refresh_inset) as? Number)
+      ?.toFloat() ?: 0f
+    val save = canvas.save()
+    try {
+      // Pin the refresh container's origin to this Host top while retaining its
+      // horizontal page position, native scale/pivot, and caller translation.
+      canvas.translate(0f, -refreshForegroundOrigin[1])
+      canvas.concat(refreshForegroundMatrix)
+      canvas.translate(indicator.left.toFloat(), nativeRefreshForegroundTop(indicator.top, appliedInset))
+      canvas.concat(indicator.matrix)
+      if (alpha < 1f) {
+        canvas.saveLayerAlpha(
+          0f, 0f, indicator.width.toFloat(), indicator.height.toFloat(),
+          (alpha * 255f).roundToInt().coerceIn(0, 255),
+        )
+      }
+      // Direct draw deliberately bypasses the alpha used to hide the original
+      // RenderNode. Do not advance Animation.getTransformation a second time.
+      indicator.draw(canvas)
+    } finally {
+      canvas.restoreToCount(save)
+    }
   }
 
   private fun headerRegionAt(y: Float): String? {
@@ -1185,10 +1390,12 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     axes and ViewCompat.SCROLL_AXIS_VERTICAL != 0 && isCurrentPageTarget(target)
 
   override fun onNestedScrollAccepted(child: View, target: View, axes: Int, type: Int) {
+    if (type == ViewCompat.TYPE_TOUCH) pendingRefreshPull = null
     nestedScrollingParentHelper.onNestedScrollAccepted(child, target, axes, type)
   }
 
   override fun onStopNestedScroll(target: View, type: Int) {
+    if (pendingRefreshPull?.get() === target) pendingRefreshPull = null
     nestedScrollingParentHelper.onStopNestedScroll(target, type)
     onHeaderOffsetChanged?.invoke()
   }
@@ -1203,10 +1410,18 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
       val used = min(dy, maximumOffset - headerOffsetPx)
       setHeaderOffset(headerOffsetPx + used)
       consumed[1] += used
-    } else if (dy < 0 && headerOffsetPx > 0 && !target.canScrollVertically(-1)) {
-      val used = max(dy, -headerOffsetPx)
-      setHeaderOffset(headerOffsetPx + used)
-      consumed[1] += used
+    } else if (dy < 0 && headerOffsetPx > 0) {
+      // Refresh wrappers forward nested scrolls but do not scroll themselves.
+      val canScrollUp = if (target is SwipeRefreshLayout) {
+        target.canChildScrollUp()
+      } else {
+        target.canScrollVertically(-1)
+      }
+      if (!canScrollUp) {
+        val used = max(dy, -headerOffsetPx)
+        setHeaderOffset(headerOffsetPx + used)
+        consumed[1] += used
+      }
     }
   }
 
@@ -1219,10 +1434,14 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     type: Int,
     consumed: IntArray,
   ) {
-    if (!isCurrentPageTarget(target) || dyUnconsumed >= 0 || headerOffsetPx <= 0) return
+    if (!isCurrentPageTarget(target) || dyUnconsumed >= 0) return
     val used = max(dyUnconsumed, -headerOffsetPx)
     setHeaderOffset(headerOffsetPx + used)
     consumed[1] += used
+    if (type == ViewCompat.TYPE_TOUCH && dyUnconsumed < used &&
+      target is SwipeRefreshLayout && target.isEnabled) {
+      pendingRefreshPull = WeakReference(target)
+    }
   }
 
   override fun onNestedScroll(
@@ -1244,6 +1463,20 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     )
   }
 
+  override fun onNestedPreFling(target: View, velocityX: Float, velocityY: Float): Boolean {
+    val refresh = pendingRefreshPull?.get()
+    val scrollable = primaryScrollableForPage(selectedPage)
+    if (nativeSmoothHeaderScrollEnabled && refresh != null && refresh === target && isCurrentPageTarget(target) &&
+      headerOffsetPx == 0 && scrollable != null && !scrollable.canScrollVertically(-1) &&
+      refresh.isEnabled && !refresh.isRefreshing &&
+      refreshIndicatorFor(refresh)?.visibility == View.VISIBLE) {
+      // A small release reversal must settle the current refresh pull, not fling
+      // content upward and make its first positive offset collapse the header.
+      return true
+    }
+    return super.onNestedPreFling(target, velocityX, velocityY)
+  }
+
   override fun getNestedScrollAxes() = nestedScrollingParentHelper.nestedScrollAxes
 
   override fun onAttachedToWindow() {
@@ -1259,6 +1492,8 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   }
 
   override fun onDetachedFromWindow() {
+    pendingRefreshPull = null
+    releaseRefreshForeground()
     attachmentGeneration += 1
     headerDownEvent?.recycle()
     headerDownEvent = null
@@ -1275,6 +1510,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     for (scroller in originalScrollerPadding.keys.toList()) {
       restoreNativeScrollerInsets(scroller)
     }
+    for (scroller in ownedScrollerKeys.keys.toList()) restoreOwnedScrollerInsets(scroller)
     log(
       "host-detach generation=$attachmentGeneration inner=$selectedPage " +
         "outer=${outerPagerIndex()} nativePages=${adapter.itemCount}",
@@ -1283,7 +1519,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   }
 
   companion object {
-    private val refreshIndicatorTranslations = WeakHashMap<View, NativeScrollerRefreshTranslation>()
+    private val refreshIndicatorAlphas = WeakHashMap<ImageView, NativeRefreshForegroundAlpha>()
     const val NATIVE_SCROLLER_ID_PREFIX = "rnc-collapsible-pager-native-scroller:"
     const val PAGE_SLOT_OFFSET = 2
   }

package/android/src/main/java/com/reactnativepagerview/NativeScrollerPendingRestore.kt

@@ -0,0 +1,26 @@
+package com.reactnativepagerview
+
+/**
+ * A pager-owned offset restoration that NestedScrollView clamped because the
+ * React content height had not reached native yet. It is reapplied on content
+ * layout until reached or cancelled by user/command/content replacement.
+ */
+internal class NativeScrollerPendingRestore {
+  var target: Int? = null
+    private set
+
+  fun request(target: Int, reached: Int) {
+    this.target = if (reached == target) null else target
+  }
+
+  /** The offset to reapply after a content layout pass. */
+  fun anchor(current: Int): Int = target ?: current
+
+  fun settle(reached: Int) {
+    if (target == reached) target = null
+  }
+
+  fun cancel() {
+    target = null
+  }
+}