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

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

@@ -123,7 +123,6 @@ 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()
@@ -131,23 +130,13 @@ 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
@@ -241,19 +230,6 @@ 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) {
@@ -410,80 +386,16 @@ 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
-    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")
-    }
+    if (savedOffset > 0) setHeaderOffset(headerHeightPx)
     postForCurrentAttachment {
       prepareAdjacentPages()
       attachPrimaryScrollObserver()
@@ -625,14 +537,9 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
 
   private fun setHeaderOffset(offset: Int) {
     // val next = offset.coerceIn(0, headerHeightPx)
-    val pending = nativeSmoothHeaderScrollEnabled && currentPageKey() in pendingPageRestores
-    val maximum = if (transitionHeaderOffsets != null || pending) headerHeightPx else maximumHeaderOffset()
-    val next = offset.coerceIn(0, maximum)
+    val next = offset.coerceIn(0, maximumHeaderOffset())
     if (headerOffsetPx == next) return
     headerOffsetPx = next
-    if (nativeSmoothHeaderScrollEnabled && transitionHeaderOffsets == null && !syntheticPageRestore && !pending) {
-      pageHeaderOffsets[currentPageKey()] = next
-    }
     applyHeaderOffset()
   }
 
@@ -749,17 +656,13 @@ 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(recordOffset = !nativeSmoothHeaderScrollEnabled)
+      detachPrimaryScrollObserver()
       // A replacement scroller starts at the beginning while retaining header collapse.
-      offsetDiag("primary-replacement-cache-before", previous)
-      if (!nativeSmoothHeaderScrollEnabled) pageOffsets[currentPageKey()] = 0
-      offsetDiag("primary-replacement-cache-after", previous)
+      pageOffsets[currentPageKey()] = 0
     }
     when (val scrollable = primaryScrollableForPage(selectedPage)) {
       is RecyclerView -> attachRecyclerObserver(scrollable)
@@ -769,33 +672,24 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   }
 
   private fun attachRecyclerObserver(recycler: RecyclerView) {
-    if (observedRecyclerView === recycler && observedRecyclerKey == currentPageKey()) {
+    if (observedRecyclerView === recycler) {
       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()
-        if (pageOffsets[currentPageKey()] != contentOffset) offsetDiag("recycler-cache-before-new=$contentOffset", recyclerView)
-        pageOffsets[key] = contentOffset
+        pageOffsets[currentPageKey()] = 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)
         }
       }
     }
@@ -811,11 +705,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     val recycler = observedRecyclerView
     val listener = observedScrollListener
     if (recycler != null) {
-      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)
+      if (recordOffset) pageOffsets[currentPageKey()] = recycler.computeVerticalScrollOffset()
       publishConsumedOffset(recycler, remove = true)
     }
     if (recycler != null && listener != null) recycler.removeOnScrollListener(listener)
@@ -826,37 +716,28 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
       )
     }
     observedRecyclerView = null
-    observedRecyclerKey = null
     observedScrollListener = null
   }
 
   private fun attachNativeScrollerObserver(scroller: ScrollView) {
-    if (observedNativeScroller === scroller && observedNativeScrollerKey == currentPageKey()) {
+    if (observedNativeScroller === scroller) {
       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
-        if (pageOffsets[currentPageKey()] != contentOffset) offsetDiag("scrollview-cache-before-new=$contentOffset", scroller)
-        pageOffsets[key] = contentOffset
+        pageOffsets[currentPageKey()] = contentOffset
         if (contentOffset > 0 && headerOffsetPx < headerHeightPx) {
-          offsetDiag("scrollview-positive-collapse-before", scroller)
           setHeaderOffset(headerHeightPx)
-          offsetDiag("scrollview-positive-collapse-after", scroller)
         }
       }
     }
@@ -873,11 +754,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private fun detachNativeScrollerObserver(recordOffset: Boolean) {
     val scroller = observedNativeScroller
     val listener = observedNativeScrollerListener
-    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 && recordOffset) pageOffsets[currentPageKey()] = scroller.scrollY
     if (scroller != null && listener != null) {
       removeScrollChangedListener(observedNativeScrollerTreeObserver, scroller, listener)
     }
@@ -888,7 +765,6 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
       )
     }
     observedNativeScroller = null
-    observedNativeScrollerKey = null
     observedNativeScrollerListener = null
     observedNativeScrollerTreeObserver = null
   }
@@ -917,23 +793,9 @@ 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 && 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)
+      if (ownedScrollerKeys[scroller] == key && scroller.isAttachedToWindow) {
+        scroller.host.restoreScrollOffset(pageOffsets[key] ?: 0)
       }
     }
   }
@@ -941,9 +803,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private fun restoreOwnedScrollerInsets(scroller: NativeScrollerViewport) {
     scroller.stopMotion()
     scroller.host.cancelPendingScrollRestore()
-    ownedScrollerKeys.remove(scroller)?.let { key ->
-      if (ownedScrollerRestoreRequests[key]?.first?.get() === scroller) ownedScrollerRestoreRequests.remove(key)
-    }
+    ownedScrollerKeys.remove(scroller)
     publishConsumedOffset(scroller, remove = true)
     scroller.host.setPagerInset(this, null)
   }
@@ -951,11 +811,9 @@ 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()
@@ -966,7 +824,9 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
           removeScrollChangedListener(null, scroller, this)
           return
         }
-        recordOwnedScrollerOffset(scroller, key)
+        val contentOffset = scroller.scrollY
+        pageOffsets[key] = contentOffset
+        if (contentOffset > 0 && headerOffsetPx < headerHeightPx) setHeaderOffset(headerHeightPx)
       }
     }
     observedOwnedScrollerListener = listener
@@ -975,37 +835,11 @@ 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)
-    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)
+    if (recordOffset) observedOwnedScrollerKey?.let { pageOffsets[it] = scroller.scrollY }
     observedOwnedScrollerListener?.let {
       removeScrollChangedListener(observedOwnedScrollerTreeObserver, scroller, it)
     }
@@ -1059,7 +893,6 @@ 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 ||
@@ -1068,16 +901,9 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
           if (restoredRecyclerKeys[recycler] == key) restoredRecyclerKeys.remove(recycler)
           return@post
         }
-        val saved = transitionPageOffsets?.get(key) ?: pageOffsets[key] ?: 0
+        val saved = 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)
       }
     }
   }
@@ -1123,7 +949,6 @@ 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 ||
@@ -1132,16 +957,8 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
           if (restoredScrollerKeys[scroller] == key) restoredScrollerKeys.remove(scroller)
           return@post
         }
-        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
-        }
+        val saved = pageOffsets[key] ?: 0
         if (scroller.scrollY != saved) scroller.scrollTo(scroller.scrollX, saved)
-        pendingPageRestores.remove(key)
-        offsetDiag("scrollview-restore-after", scroller, key)
       }
     }
   }
@@ -1582,10 +1399,6 @@ 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) {
@@ -1679,13 +1492,6 @@ 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}",
@@ -1705,15 +1511,6 @@ 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,7 +43,6 @@ 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))
       }
 
@@ -56,7 +55,6 @@ 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"
@@ -326,19 +324,13 @@ 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,8 +255,6 @@ 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,16 +27,5 @@ 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,42 +3,6 @@
 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
@@ -490,8 +454,7 @@ 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 pull-overscroll behavior are preserved; smooth-header selection
-follows the per-page reading-position contract above.
+deep offsets and the existing lower-bound/header alignment rules are unchanged.
 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.