@onekeyfe/react-native-pager-view 3.0.169 → 3.0.171

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

@@ -123,6 +123,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private val originalScrollerPadding = WeakHashMap<ScrollView, ScrollerPadding>()
   private val restoredScrollerKeys = WeakHashMap<ScrollView, String>()
   private val ownedScrollerKeys = WeakHashMap<NativeScrollerViewport, String>()
+  private val ownedScrollerRestoreRequests = HashMap<String, Pair<WeakReference<NativeScrollerViewport>, Int?>>()
   private var foregroundRefreshIndicator: WeakReference<ImageView>? = null
   private var refreshForegroundWasVisible = false
   private val refreshForegroundMatrix = Matrix()
@@ -130,13 +131,23 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private val refreshForegroundAncestors = ArrayList<View>()
   private var refreshForegroundAncestorAlpha = 1f
   private val pageOffsets = HashMap<String, Int>()
+  private val pageHeaderOffsets = HashMap<String, Int>()
+  private var transitionHeaderOffsets: Map<String, Int>? = null
+  private var transitionPageOffsets: Map<String, Int>? = null
+  private var transitionSourcePage = 0
+  private var transitionTargetPage: Int? = null
+  private var syntheticPageRestore = false
+  private var resumeTransitionSource: Int? = null
+  private val pendingPageRestores = HashSet<String>()
   private var observedRecyclerView: RecyclerView? = null
+  private var observedRecyclerKey: String? = 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 observedNativeScrollerKey: String? = null
   private var observedNativeScrollerListener: ViewTreeObserver.OnScrollChangedListener? = null
   private var observedNativeScrollerTreeObserver: ViewTreeObserver? = null
   private var observedPageRemoved = false
@@ -230,6 +241,19 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     OneKeyLog.debug("CollapsiblePager", "host=$hostIdentity $message")
   }
 
+  private var offsetDiagSequence = 0L
+
+  private fun offsetDiag(phase: String, view: View? = null, key: String = currentPageKey()) {
+    if ((context.applicationInfo.flags and android.content.pm.ApplicationInfo.FLAG_DEBUGGABLE) == 0) return
+    val safeKey = if (key in setOf("portfolio", "perps", "defi", "nft", "history")) key else "other"
+    val observed = observedOwnedScroller ?: observedNativeScroller ?: observedRecyclerView
+    OneKeyLog.debug("CollapsiblePager", "[HOME-OFFSET-DIAG] phase=$phase seq=${++offsetDiagSequence} " +
+      "wallMs=${System.currentTimeMillis()} monoMs=${SystemClock.uptimeMillis()} host=$hostIdentity " +
+      "generation=$attachmentGeneration page=$selectedPage key=$safeKey header=$headerOffsetPx headerHeight=$headerHeightPx " +
+      "view=${view?.let { System.identityHashCode(it) }} tag=${view?.id} observed=${observed?.let { System.identityHashCode(it) }} " +
+      "offset=${view?.let(::verticalScrollOffset)} cache=${pageOffsets[key]} boundsHeight=${view?.height}")
+  }
+
   private fun outerPagerIndex(): Int {
     var ancestor = parent as? View
     while (ancestor != null) {
@@ -386,16 +410,80 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
 
   fun reactChildAt(index: Int) = logicalChildren[index]
 
+  internal fun beginPageTransition(target: Int? = null) {
+    if (!nativeSmoothHeaderScrollEnabled || headerHeightPx <= 0) return
+    if (transitionHeaderOffsets == null) {
+      pageHeaderOffsets[currentPageKey()] = headerOffsetPx
+      detachPrimaryScrollObserver()
+      transitionSourcePage = selectedPage
+      transitionHeaderOffsets = pageHeaderOffsets.toMap()
+      transitionPageOffsets = pageOffsets.toMap()
+    }
+    if (target != null) transitionTargetPage = target
+  }
+
+  internal fun onPagerScrolled(position: Int, offset: Float) {
+    val headers = transitionHeaderOffsets ?: return
+    val target = transitionTargetPage
+    val first = if (target != null) transitionSourcePage else position
+    val second = target ?: (position + 1).coerceAtMost(adapter.itemCount - 1)
+    val fraction = if (target != null && target != first) {
+      ((position + offset - first) / (target - first)).coerceIn(0f, 1f)
+    } else offset
+    val firstH = headers[pageKey(first)] ?: 0
+    val secondH = headers[pageKey(second)] ?: 0
+    syntheticPageRestore = true
+    setHeaderOffset((firstH + (secondH - firstH) * fraction).roundToInt())
+    syntheticPageRestore = false
+    updateNativeTabProgress(position, offset)
+  }
+
+  internal fun onPagerScrollStateChanged(state: Int) {
+    if (state == ViewPager2.SCROLL_STATE_DRAGGING || state == ViewPager2.SCROLL_STATE_SETTLING) {
+      beginPageTransition()
+    } else if (state == ViewPager2.SCROLL_STATE_IDLE && transitionHeaderOffsets != null) {
+      finishPageTransition(pager.currentItem)
+    }
+  }
+
+  private fun finishPageTransition(position: Int) {
+    val headers = transitionHeaderOffsets ?: return
+    detachPrimaryScrollObserver(recordOffset = false)
+    releaseRefreshForeground()
+    selectedPage = position.coerceIn(0, adapter.itemCount - 1)
+    syntheticPageRestore = true
+    setHeaderOffset(headers[currentPageKey()] ?: 0)
+    transitionHeaderOffsets = null
+    transitionPageOffsets = null
+    transitionTargetPage = null
+    syntheticPageRestore = false
+    pageHeaderOffsets[currentPageKey()] = headerOffsetPx
+    prepareAdjacentPages()
+    attachPrimaryScrollObserver()
+  }
+
   fun selectPage(position: Int) {
+    offsetDiag("select-begin-target=$position", observedOwnedScroller ?: observedNativeScroller ?: observedRecyclerView)
     pendingRefreshPull = null
     if (adapter.itemCount == 0) return
+    if (nativeSmoothHeaderScrollEnabled && headerHeightPx > 0) {
+      if (transitionHeaderOffsets != null) return
+      beginPageTransition(position)
+      finishPageTransition(position)
+      return
+    }
     detachPrimaryScrollObserver()
     releaseRefreshForeground()
     selectedPage = position.coerceIn(0, adapter.itemCount - 1)
     val savedOffset = pageOffsets[currentPageKey()]
       ?: primaryScrollableForPage(selectedPage)?.let(::verticalScrollOffset)
       ?: 0
-    if (savedOffset > 0) setHeaderOffset(headerHeightPx)
+    offsetDiag("select-offset=$savedOffset-source=${if (pageOffsets[currentPageKey()] != null) "saved" else "live"}")
+    if (savedOffset > 0) {
+      offsetDiag("select-force-collapse-before")
+      setHeaderOffset(headerHeightPx)
+      offsetDiag("select-force-collapse-after")
+    }
     postForCurrentAttachment {
       prepareAdjacentPages()
       attachPrimaryScrollObserver()
@@ -537,9 +625,14 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
 
   private fun setHeaderOffset(offset: Int) {
     // val next = offset.coerceIn(0, headerHeightPx)
-    val next = offset.coerceIn(0, maximumHeaderOffset())
+    val pending = nativeSmoothHeaderScrollEnabled && currentPageKey() in pendingPageRestores
+    val maximum = if (transitionHeaderOffsets != null || pending) headerHeightPx else maximumHeaderOffset()
+    val next = offset.coerceIn(0, maximum)
     if (headerOffsetPx == next) return
     headerOffsetPx = next
+    if (nativeSmoothHeaderScrollEnabled && transitionHeaderOffsets == null && !syntheticPageRestore && !pending) {
+      pageHeaderOffsets[currentPageKey()] = next
+    }
     applyHeaderOffset()
   }
 
@@ -656,13 +749,17 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   }
 
   private fun attachPrimaryScrollObserver() {
+    if (transitionHeaderOffsets != null) return
     if (selectedPage !in 0 until adapter.itemCount) return
     val previous = observedRecyclerView ?: observedOwnedScroller ?: observedNativeScroller
     if (observedPageRemoved || previous != null && !isDescendant(previous, adapter.pageAt(selectedPage))) {
+      offsetDiag("primary-replacement-before-removed=$observedPageRemoved", previous)
       observedPageRemoved = false
-      detachPrimaryScrollObserver()
+      detachPrimaryScrollObserver(recordOffset = !nativeSmoothHeaderScrollEnabled)
       // A replacement scroller starts at the beginning while retaining header collapse.
-      pageOffsets[currentPageKey()] = 0
+      offsetDiag("primary-replacement-cache-before", previous)
+      if (!nativeSmoothHeaderScrollEnabled) pageOffsets[currentPageKey()] = 0
+      offsetDiag("primary-replacement-cache-after", previous)
     }
     when (val scrollable = primaryScrollableForPage(selectedPage)) {
       is RecyclerView -> attachRecyclerObserver(scrollable)
@@ -672,24 +769,33 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   }
 
   private fun attachRecyclerObserver(recycler: RecyclerView) {
-    if (observedRecyclerView === recycler) {
+    if (observedRecyclerView === recycler && observedRecyclerKey == currentPageKey()) {
       applyRecyclerInsets(recycler, selectedPage)
       publishConsumedOffset(recycler)
       return
     }
 
     detachPrimaryScrollObserver()
+    offsetDiag("recycler-attach-before", recycler)
     observedRecyclerView = recycler
+    observedRecyclerKey = currentPageKey()
     applyRecyclerInsets(recycler, selectedPage)
     publishConsumedOffset(recycler)
+    val key = currentPageKey()
     val listener = object : RecyclerView.OnScrollListener() {
       override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
+        if (observedScrollListener !== this || observedRecyclerKey != key ||
+          key != currentPageKey() || !isAttachedToWindow ||
+          transitionHeaderOffsets != null || syntheticPageRestore || key in pendingPageRestores) return
         val contentOffset = recyclerView.computeVerticalScrollOffset()
-        pageOffsets[currentPageKey()] = contentOffset
+        if (pageOffsets[currentPageKey()] != contentOffset) offsetDiag("recycler-cache-before-new=$contentOffset", recyclerView)
+        pageOffsets[key] = contentOffset
         // Nested touch scrolling moves list content only after the header has
         // collapsed. Programmatic list jumps bypass those parent callbacks.
         if (contentOffset > 0 && headerOffsetPx < headerHeightPx) {
+          offsetDiag("recycler-positive-collapse-before", recyclerView)
           setHeaderOffset(headerHeightPx)
+          offsetDiag("recycler-positive-collapse-after", recyclerView)
         }
       }
     }
@@ -705,7 +811,11 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     val recycler = observedRecyclerView
     val listener = observedScrollListener
     if (recycler != null) {
-      if (recordOffset) pageOffsets[currentPageKey()] = recycler.computeVerticalScrollOffset()
+      offsetDiag("recycler-detach-save-before-record=$recordOffset", recycler)
+      if (recordOffset && transitionPageOffsets == null) observedRecyclerKey?.let {
+        if (it !in pendingPageRestores) pageOffsets[it] = recycler.computeVerticalScrollOffset()
+      }
+      offsetDiag("recycler-detach-save-after", recycler)
       publishConsumedOffset(recycler, remove = true)
     }
     if (recycler != null && listener != null) recycler.removeOnScrollListener(listener)
@@ -716,28 +826,37 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
       )
     }
     observedRecyclerView = null
+    observedRecyclerKey = null
     observedScrollListener = null
   }
 
   private fun attachNativeScrollerObserver(scroller: ScrollView) {
-    if (observedNativeScroller === scroller) {
+    if (observedNativeScroller === scroller && observedNativeScrollerKey == currentPageKey()) {
       applyNativeScrollerInsets(scroller, selectedPage)
       return
     }
 
     detachPrimaryScrollObserver()
+    offsetDiag("scrollview-attach-before", scroller)
     observedNativeScroller = scroller
+    observedNativeScrollerKey = currentPageKey()
     applyNativeScrollerInsets(scroller, selectedPage)
+    val key = currentPageKey()
     val listener = object : ViewTreeObserver.OnScrollChangedListener {
       override fun onScrollChanged() {
         if (observedNativeScrollerListener !== this) {
           removeScrollChangedListener(null, scroller, this)
           return
         }
+        if (key != currentPageKey() || !isAttachedToWindow ||
+          transitionHeaderOffsets != null || syntheticPageRestore || key in pendingPageRestores) return
         val contentOffset = scroller.scrollY
-        pageOffsets[currentPageKey()] = contentOffset
+        if (pageOffsets[currentPageKey()] != contentOffset) offsetDiag("scrollview-cache-before-new=$contentOffset", scroller)
+        pageOffsets[key] = contentOffset
         if (contentOffset > 0 && headerOffsetPx < headerHeightPx) {
+          offsetDiag("scrollview-positive-collapse-before", scroller)
           setHeaderOffset(headerHeightPx)
+          offsetDiag("scrollview-positive-collapse-after", scroller)
         }
       }
     }
@@ -754,7 +873,11 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private fun detachNativeScrollerObserver(recordOffset: Boolean) {
     val scroller = observedNativeScroller
     val listener = observedNativeScrollerListener
-    if (scroller != null && recordOffset) pageOffsets[currentPageKey()] = scroller.scrollY
+    offsetDiag("scrollview-detach-save-before-record=$recordOffset", scroller)
+    if (scroller != null && recordOffset && transitionPageOffsets == null) observedNativeScrollerKey?.let {
+      if (it !in pendingPageRestores) pageOffsets[it] = scroller.scrollY
+    }
+    offsetDiag("scrollview-detach-save-after", scroller)
     if (scroller != null && listener != null) {
       removeScrollChangedListener(observedNativeScrollerTreeObserver, scroller, listener)
     }
@@ -765,6 +888,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
       )
     }
     observedNativeScroller = null
+    observedNativeScrollerKey = null
     observedNativeScrollerListener = null
     observedNativeScrollerTreeObserver = null
   }
@@ -793,9 +917,23 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     val key = pageKey(pageIndex)
     if (ownedScrollerKeys[scroller] == key) return
     ownedScrollerKeys[scroller] = key
+    if (nativeSmoothHeaderScrollEnabled) {
+      pendingPageRestores.add(key)
+      ownedScrollerRestoreRequests[key] = WeakReference(scroller) to null
+    }
+    val generation = attachmentGeneration
     postForCurrentAttachment {
-      if (ownedScrollerKeys[scroller] == key && scroller.isAttachedToWindow) {
-        scroller.host.restoreScrollOffset(pageOffsets[key] ?: 0)
+      if (ownedScrollerKeys[scroller] == key && generation == attachmentGeneration &&
+        scroller.isAttachedToWindow && (!nativeSmoothHeaderScrollEnabled ||
+          (key in pendingPageRestores && ownedScrollerRestoreRequests[key]?.first?.get() === scroller))) {
+        offsetDiag("owned-restore-before", scroller, key)
+        val saved = transitionPageOffsets?.get(key) ?: pageOffsets[key] ?: 0
+        scroller.host.restoreScrollOffset(saved)
+        if (nativeSmoothHeaderScrollEnabled) {
+          ownedScrollerRestoreRequests[key] = WeakReference(scroller) to generation
+          recordOwnedScrollerOffset(scroller, key)
+        }
+        offsetDiag("owned-restore-after", scroller, key)
       }
     }
   }
@@ -803,7 +941,9 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private fun restoreOwnedScrollerInsets(scroller: NativeScrollerViewport) {
     scroller.stopMotion()
     scroller.host.cancelPendingScrollRestore()
-    ownedScrollerKeys.remove(scroller)
+    ownedScrollerKeys.remove(scroller)?.let { key ->
+      if (ownedScrollerRestoreRequests[key]?.first?.get() === scroller) ownedScrollerRestoreRequests.remove(key)
+    }
     publishConsumedOffset(scroller, remove = true)
     scroller.host.setPagerInset(this, null)
   }
@@ -811,9 +951,11 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private fun attachOwnedScrollerObserver(scroller: NativeScrollerViewport) {
     if (observedOwnedScroller === scroller && observedOwnedScrollerKey == currentPageKey()) {
       applyOwnedScrollerInsets(scroller, selectedPage)
+      if (nativeSmoothHeaderScrollEnabled) recordOwnedScrollerOffset(scroller, currentPageKey())
       return
     }
     detachPrimaryScrollObserver()
+    offsetDiag("owned-attach-before", scroller)
     observedOwnedScroller = scroller
     observedOwnedScrollerKey = currentPageKey()
     val key = currentPageKey()
@@ -824,9 +966,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
           removeScrollChangedListener(null, scroller, this)
           return
         }
-        val contentOffset = scroller.scrollY
-        pageOffsets[key] = contentOffset
-        if (contentOffset > 0 && headerOffsetPx < headerHeightPx) setHeaderOffset(headerHeightPx)
+        recordOwnedScrollerOffset(scroller, key)
       }
     }
     observedOwnedScrollerListener = listener
@@ -835,11 +975,37 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     }
   }
 
+  private fun recordOwnedScrollerOffset(scroller: NativeScrollerViewport, key: String) {
+    if (ownedScrollerKeys[scroller] != key || !isAttachedToWindow || !scroller.isAttachedToWindow) return
+    if (key in pendingPageRestores) {
+      // A false native pending flag before our posted request executes is not cancellation.
+      val request = ownedScrollerRestoreRequests[key]
+      if (request == null || request.first.get() !== scroller || request.second != attachmentGeneration ||
+        scroller.width <= 0 || scroller.height <= 0 || scroller.host.hasPendingScrollRestore()) return
+      pendingPageRestores.remove(key)
+      ownedScrollerRestoreRequests.remove(key)
+    }
+    if (observedOwnedScroller !== scroller || observedOwnedScrollerKey != key ||
+      key != currentPageKey() || transitionHeaderOffsets != null || syntheticPageRestore) return
+    val contentOffset = scroller.scrollY
+    if (pageOffsets[key] != contentOffset) offsetDiag("owned-cache-before-new=$contentOffset", scroller, key)
+    pageOffsets[key] = contentOffset
+    if (contentOffset > 0 && headerOffsetPx < headerHeightPx) {
+      offsetDiag("owned-positive-collapse-before", scroller, key)
+      setHeaderOffset(headerHeightPx)
+      offsetDiag("owned-positive-collapse-after", scroller, key)
+    }
+  }
+
   private fun detachOwnedScrollerObserver(recordOffset: Boolean) {
     val scroller = observedOwnedScroller ?: return
     scroller.stopMotion()
     publishConsumedOffset(scroller, remove = true)
-    if (recordOffset) observedOwnedScrollerKey?.let { pageOffsets[it] = scroller.scrollY }
+    offsetDiag("owned-detach-save-before-record=$recordOffset", scroller)
+    if (recordOffset && transitionPageOffsets == null) observedOwnedScrollerKey?.let {
+      if (it !in pendingPageRestores) pageOffsets[it] = scroller.scrollY
+    }
+    offsetDiag("owned-detach-save-after", scroller)
     observedOwnedScrollerListener?.let {
       removeScrollChangedListener(observedOwnedScrollerTreeObserver, scroller, it)
     }
@@ -893,6 +1059,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     val key = pageKey(pageIndex)
     if (restoredRecyclerKeys[recycler] != key) {
       restoredRecyclerKeys[recycler] = key
+      if (nativeSmoothHeaderScrollEnabled) pendingPageRestores.add(key)
       val generation = attachmentGeneration
       recycler.post {
         if (!isAttachedToWindow || generation != attachmentGeneration ||
@@ -901,9 +1068,16 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
           if (restoredRecyclerKeys[recycler] == key) restoredRecyclerKeys.remove(recycler)
           return@post
         }
-        val saved = pageOffsets[key] ?: 0
+        val saved = transitionPageOffsets?.get(key) ?: pageOffsets[key] ?: 0
         val current = recycler.computeVerticalScrollOffset()
+        offsetDiag("recycler-restore-before-saved=$saved", recycler, key)
+        if (nativeSmoothHeaderScrollEnabled && (recycler.height <= 0 || recycler.childCount == 0)) {
+          restoredRecyclerKeys.remove(recycler)
+          return@post
+        }
         if (saved != current) recycler.scrollBy(0, saved - current)
+        pendingPageRestores.remove(key)
+        offsetDiag("recycler-restore-after", recycler, key)
       }
     }
   }
@@ -949,6 +1123,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     val key = pageKey(pageIndex)
     if (restoredScrollerKeys[scroller] != key) {
       restoredScrollerKeys[scroller] = key
+      if (nativeSmoothHeaderScrollEnabled) pendingPageRestores.add(key)
       val generation = attachmentGeneration
       scroller.post {
         if (!isAttachedToWindow || generation != attachmentGeneration ||
@@ -957,8 +1132,16 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
           if (restoredScrollerKeys[scroller] == key) restoredScrollerKeys.remove(scroller)
           return@post
         }
-        val saved = pageOffsets[key] ?: 0
+        val saved = transitionPageOffsets?.get(key) ?: pageOffsets[key] ?: 0
+        offsetDiag("scrollview-restore-before-saved=$saved", scroller, key)
+        if (nativeSmoothHeaderScrollEnabled &&
+          (scroller.height <= 0 || (scroller.getChildAt(0)?.height ?: 0) <= 0)) {
+          restoredScrollerKeys.remove(scroller)
+          return@post
+        }
         if (scroller.scrollY != saved) scroller.scrollTo(scroller.scrollX, saved)
+        pendingPageRestores.remove(key)
+        offsetDiag("scrollview-restore-after", scroller, key)
       }
     }
   }
@@ -1399,6 +1582,10 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   override fun onNestedScrollAccepted(child: View, target: View, axes: Int, type: Int) {
     if (type == ViewCompat.TYPE_TOUCH) pendingRefreshPull = null
     nestedScrollingParentHelper.onNestedScrollAccepted(child, target, axes, type)
+    if (type == ViewCompat.TYPE_TOUCH) {
+      pendingPageRestores.remove(currentPageKey())
+      ownedScrollerRestoreRequests.remove(currentPageKey())
+    }
   }
 
   override fun onStopNestedScroll(target: View, type: Int) {
@@ -1492,6 +1679,13 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     restoredRecyclerKeys.clear()
     restoredScrollerKeys.clear()
     viewTreeObserver.addOnPreDrawListener(pageContentLayoutListener)
+    resumeTransitionSource?.let { source ->
+      resumeTransitionSource = null
+      if (source in 0 until adapter.itemCount) {
+        pager.setCurrentItem(source, false)
+        selectPage(source)
+      }
+    }
     log(
       "host-attach generation=$attachmentGeneration inner=$selectedPage " +
         "outer=${outerPagerIndex()} nativePages=${adapter.itemCount}",
@@ -1511,6 +1705,15 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     nestedNativeGestureStarted = false
     viewTreeObserver.removeOnPreDrawListener(pageContentLayoutListener)
     detachPrimaryScrollObserver()
+    transitionHeaderOffsets?.let { headers ->
+      resumeTransitionSource = transitionSourcePage
+      syntheticPageRestore = true
+      setHeaderOffset(headers[pageKey(transitionSourcePage)] ?: 0)
+      syntheticPageRestore = false
+    }
+    transitionHeaderOffsets = null
+    transitionPageOffsets = null
+    transitionTargetPage = null
     // Snapshot live keys before restoration removes their padding records.
     for (recycler in originalRecyclerPadding.keys.toTypedArray()) {
       restoreRecyclerInsets(recycler)

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

@@ -43,6 +43,7 @@ class CollapsiblePagerViewManager : ViewGroupManager<CollapsiblePagerHost>(),
     )
     host.pager.registerOnPageChangeCallback(object : ViewPager2.OnPageChangeCallback() {
       override fun onPageScrolled(position: Int, offset: Float, offsetPixels: Int) {
+        host.onPagerScrolled(position, offset)
         dispatch(reactContext, host, PageScrollEvent(host.id, position, offset))
       }
 
@@ -55,6 +56,7 @@ class CollapsiblePagerViewManager : ViewGroupManager<CollapsiblePagerHost>(),
       }
 
       override fun onPageScrollStateChanged(state: Int) {
+        host.onPagerScrollStateChanged(state)
         val value = when (state) {
           ViewPager2.SCROLL_STATE_IDLE -> "idle"
           ViewPager2.SCROLL_STATE_DRAGGING -> "dragging"
@@ -324,13 +326,19 @@ class CollapsiblePagerViewManager : ViewGroupManager<CollapsiblePagerHost>(),
 
   override fun setPage(view: CollapsiblePagerHost?, selectedPage: Int) {
     if (view != null && selectedPage in 0 until view.adapter.itemCount) {
+      view.beginPageTransition(selectedPage)
       view.pager.setCurrentItem(selectedPage, true)
+      if (view.pager.scrollState == ViewPager2.SCROLL_STATE_IDLE) {
+        view.onPagerScrollStateChanged(ViewPager2.SCROLL_STATE_IDLE)
+      }
     }
   }
 
   override fun setPageWithoutAnimation(view: CollapsiblePagerHost?, selectedPage: Int) {
     if (view != null && selectedPage in 0 until view.adapter.itemCount) {
+      view.beginPageTransition(selectedPage)
       view.pager.setCurrentItem(selectedPage, false)
+      view.onPagerScrollStateChanged(ViewPager2.SCROLL_STATE_IDLE)
     }
   }
 

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

@@ -255,6 +255,8 @@ class NativeScrollerView(context: Context) : FrameLayout(context) {
 
   internal fun cancelPendingScrollRestore() = pendingRestore.cancel()
 
+  internal fun hasPendingScrollRestore(): Boolean = pendingRestore.target != null
+
   internal fun setRefreshOffset(value: Int) {
     refreshOffset = value
     applyRefreshOffset()

package/android/src/test/java/com/reactnativepagerview/NativeScrollerPendingRestoreTest.kt

@@ -27,5 +27,16 @@ fun main() {
   restore.cancel()
   check(restore.target == null)
   check(restore.anchor(120) == 120)
+  // Cancellation clears the old target without requiring the reached offset to change.
+  restore.request(target = 640, reached = 120)
+  check(restore.anchor(120) == 640)
+  restore.cancel()
+  check(restore.target == null)
+  check(restore.anchor(120) == 120)
+  // A fresh request owns its target after cancellation.
+  restore.request(target = 320, reached = 120)
+  check(restore.target == 320)
+  restore.settle(reached = 320)
+  check(restore.target == null)
   println("Native scroller pending restore: clamp retry, partial growth, settle and cancel passed")
 }

package/docs/SPEC.md

@@ -3,6 +3,42 @@
 Existing PagerView and CollapsiblePagerView APIs are documented in README.md.
 The sections below define native coordination boundaries without new React props.
 
+## Smooth per-page screen restoration
+
+When nativeSmoothHeaderScrollEnabled is enabled with a collapsible header, each
+page owns its header collapse and body offset. For a settled position outside
+pull overscroll, Q = H + L, H = min(Q, C), and L = max(Q - C, 0), where C is
+the header-collapse distance. These are semantic coordinates, not new props.
+An unvisited page starts expanded
+at body start. Leaving a page preserves its expanded, partial or collapsed header
+and its body position; tap, swipe and programmatic selection restore the same
+complete screen state. Legacy mode and pagers without a collapsible header retain
+their existing behavior.
+
+Horizontal progress interpolates the shared header between immutable source and
+target snapshots. Native body geometry follows that header without obscured rows
+or blank gaps. Temporary transition offsets MUST NOT overwrite page snapshots.
+Non-adjacent commands use the original source and destination, not intermediate
+pages, as the header interpolation endpoints. Cancellation restores the source
+and all temporarily compensated pages before observation resumes.
+
+A scroll observer owns one page identity and generation independently of mutable
+selection. Detach, replacement and late notifications MUST NOT save another
+page's offset. Zero layout and unresolved replacement identity preserve pending
+restoration until an actual usable layout; settled content shrink still clamps to
+the legal range. This state is native UI-thread state, not persistent wallet data
+or per-frame JavaScript synchronization. Vertical scrolling, refresh, snapping
+and repeated-current-page selection retain their existing contracts.
+
+Android owned NativeScroller restoration keeps its intent while a posted request
+has not executed or native content is still too short to reach the saved offset.
+Only the same viewport, page key and attachment generation may reconcile an
+issued request. Once native restoration settles or is cancelled by touch, an
+imperative command or content replacement, the host resumes recording its live
+body offset. Existing pre-draw observation also reconciles a same-position command
+that emits no scroll notification. Zero-sized geometry retains the pending intent;
+no timeout infers that delayed content is permanently short.
+
 ## Independent NativeScroller migration
 
 Status: implemented in source. Both native builds pass. Android focused emulator
@@ -254,9 +290,11 @@ start a refresh gesture. Non-smooth refresh direction behavior remains unchanged
 iOS nested horizontal ownership MUST include enabled nonpaging horizontal-only
 ScrollViews, with content wider than bounds and no vertical content overflow.
 Both pan holding and failure dependencies MUST use the same eligibility. A
-failure dependency on the Pager guard MUST apply only to the horizontal pan;
+failure dependency on the Pager guard MUST apply only to the horizontal pan,
+both on the root Pager ScrollView and on eligible nested horizontal ScrollViews;
 independent non-pan recognizers, including stationary native long presses, MUST
-remain able to recognize before finger-up while Pager intent is pending. A
+remain able to deliver their target actions before finger-up while Pager intent
+is pending. A
 second touch in the pending Pager guard fails recognition; an already active
 Pager guard cancels and restores each held pan's original minimum touch count.
 
@@ -452,7 +490,8 @@ When restoring a retained page's cached vertical offset, the pager limits only
 the upper bound to the current content height, viewport and applied insets. A
 cache captured before rows were removed MUST NOT restore an offset below the new
 content bottom, including when removal occurs during a page transition. Valid
-deep offsets and the existing lower-bound/header alignment rules are unchanged.
+deep offsets and pull-overscroll behavior are preserved; smooth-header selection
+follows the per-page reading-position contract above.
 This check runs only on explicit restoration, not on scroll frames; UIKit pull
 overscroll and refresh settlement retain their existing ownership. An unmeasured
 zero-height viewport defers this upper-bound limit to a later restoration.