@onekeyfe/react-native-pager-view 3.0.172 → 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,51 +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 class PageRestoreRequest(view: View, val pageIndex: Int, val generation: Int) {
-    val view = WeakReference(view)
-  }
-  private val pageRestoreRequests = HashMap<String, PageRestoreRequest>()
-
-  private fun registerPageRestore(key: String, view: View, pageIndex: Int): PageRestoreRequest? {
-    if (!nativeSmoothHeaderScrollEnabled) return null
-    val previous = pageRestoreRequests[key]?.view?.get()
-    if (previous is NativeScrollerViewport && previous !== view) previous.host.cancelPendingScrollRestore()
-    ownedScrollerRestoreRequests.remove(key)
-    return PageRestoreRequest(view, pageIndex, attachmentGeneration).also {
-      pageRestoreRequests[key] = it
-      pendingPageRestores.add(key)
-    }
-  }
-
-  private fun isCurrentPageRestore(key: String, request: PageRestoreRequest?): Boolean =
-    !nativeSmoothHeaderScrollEnabled || (request != null && pageRestoreRequests[key] === request &&
-      key in pendingPageRestores && request.generation == attachmentGeneration &&
-      pageKey(request.pageIndex) == key)
-
-  private fun clearPageRestoreForView(key: String, view: View, request: PageRestoreRequest? = null) {
-    if (request != null && pageRestoreRequests[key] !== request) return
-    if (pageRestoreRequests[key]?.view?.get() !== view) return
-    pageRestoreRequests.remove(key)
-    pendingPageRestores.remove(key)
-    ownedScrollerRestoreRequests.remove(key)
-  }
   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
@@ -228,18 +189,6 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   var headerOffsetPx = 0
     private set
   var pageKeys: List<String> = emptyList()
-    set(value) {
-      if (field == value) return
-      pageRestoreRequests.entries.toList().forEach { (key, request) ->
-        if ((value.getOrNull(request.pageIndex) ?: "page-${request.pageIndex}") != key) {
-          (request.view.get() as? NativeScrollerViewport)?.host?.cancelPendingScrollRestore()
-          pageRestoreRequests.remove(key)
-          pendingPageRestores.remove(key)
-          ownedScrollerRestoreRequests.remove(key)
-        }
-      }
-      field = value
-    }
   var retainedPages: String = "[]"
   var onHeaderOffsetChanged: (() -> Unit)? = null
   var nativeSmoothHeaderScrollEnabled = false
@@ -281,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) {
@@ -428,9 +364,6 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   fun removeAllReactChildren() {
     releaseRefreshForeground()
     detachPrimaryScrollObserver()
-    pageRestoreRequests.clear()
-    pendingPageRestores.clear()
-    ownedScrollerRestoreRequests.clear()
     // Weak keys may disappear after size is read; Collection.toArray tolerates this.
     for (recycler in originalRecyclerPadding.keys.toTypedArray()) {
       restoreRecyclerInsets(recycler)
@@ -453,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()
@@ -668,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()
   }
 
@@ -792,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)
@@ -812,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)
         }
       }
     }
@@ -854,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)
@@ -869,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)
         }
       }
     }
@@ -916,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)
     }
@@ -931,7 +765,6 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
       )
     }
     observedNativeScroller = null
-    observedNativeScrollerKey = null
     observedNativeScrollerListener = null
     observedNativeScrollerTreeObserver = null
   }
@@ -960,21 +793,9 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     val key = pageKey(pageIndex)
     if (ownedScrollerKeys[scroller] == key) return
     ownedScrollerKeys[scroller] = key
-    val restoreRequest = registerPageRestore(key, scroller, pageIndex)
-    if (nativeSmoothHeaderScrollEnabled) ownedScrollerRestoreRequests[key] = WeakReference(scroller) to null
-    val generation = attachmentGeneration
     postForCurrentAttachment {
-      if (isCurrentPageRestore(key, restoreRequest) && 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)
       }
     }
   }
@@ -982,10 +803,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private fun restoreOwnedScrollerInsets(scroller: NativeScrollerViewport) {
     scroller.stopMotion()
     scroller.host.cancelPendingScrollRestore()
-    ownedScrollerKeys.remove(scroller)?.let { key ->
-      clearPageRestoreForView(key, scroller)
-      if (ownedScrollerRestoreRequests[key]?.first?.get() === scroller) ownedScrollerRestoreRequests.remove(key)
-    }
+    ownedScrollerKeys.remove(scroller)
     publishConsumedOffset(scroller, remove = true)
     scroller.host.setPagerInset(this, null)
   }
@@ -993,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()
@@ -1008,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
@@ -1017,36 +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
-      clearPageRestoreForView(key, scroller)
-    }
-    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)
     }
@@ -1100,32 +893,17 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     val key = pageKey(pageIndex)
     if (restoredRecyclerKeys[recycler] != key) {
       restoredRecyclerKeys[recycler] = key
-      val restoreRequest = registerPageRestore(key, recycler, pageIndex)
       val generation = attachmentGeneration
       recycler.post {
-        if (!isCurrentPageRestore(key, restoreRequest)) {
-          offsetDiag("post-skip-cancelled-page=$pageIndex", recycler, key)
-          return@post
-        }
         if (!isAttachedToWindow || generation != attachmentGeneration ||
           restoredRecyclerKeys[recycler] != key ||
           originalRecyclerPadding[recycler] !== original) {
           if (restoredRecyclerKeys[recycler] == key) restoredRecyclerKeys.remove(recycler)
-          clearPageRestoreForView(key, recycler, restoreRequest)
           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)
-          if (pageRestoreRequests[key] === restoreRequest) pageRestoreRequests.remove(key)
-          return@post
-        }
         if (saved != current) recycler.scrollBy(0, saved - current)
-        if (nativeSmoothHeaderScrollEnabled) clearPageRestoreForView(key, recycler, restoreRequest)
-        else pendingPageRestores.remove(key)
-        offsetDiag("recycler-restore-after", recycler, key)
       }
     }
   }
@@ -1171,32 +949,16 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     val key = pageKey(pageIndex)
     if (restoredScrollerKeys[scroller] != key) {
       restoredScrollerKeys[scroller] = key
-      val restoreRequest = registerPageRestore(key, scroller, pageIndex)
       val generation = attachmentGeneration
       scroller.post {
-        if (!isCurrentPageRestore(key, restoreRequest)) {
-          offsetDiag("post-skip-cancelled-page=$pageIndex", scroller, key)
-          return@post
-        }
         if (!isAttachedToWindow || generation != attachmentGeneration ||
           restoredScrollerKeys[scroller] != key ||
           originalScrollerPadding[scroller] !== original) {
           if (restoredScrollerKeys[scroller] == key) restoredScrollerKeys.remove(scroller)
-          clearPageRestoreForView(key, scroller, restoreRequest)
-          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)
-          if (pageRestoreRequests[key] === restoreRequest) pageRestoreRequests.remove(key)
           return@post
         }
+        val saved = pageOffsets[key] ?: 0
         if (scroller.scrollY != saved) scroller.scrollTo(scroller.scrollX, saved)
-        if (nativeSmoothHeaderScrollEnabled) clearPageRestoreForView(key, scroller, restoreRequest)
-        else pendingPageRestores.remove(key)
-        offsetDiag("scrollview-restore-after", scroller, key)
       }
     }
   }
@@ -1255,7 +1017,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     publishConsumedOffset(recycler, remove = true)
     val original = originalRecyclerPadding.remove(recycler) ?: return
     updateRecyclerPaddingOwnership(recycler, original)
-    restoredRecyclerKeys.remove(recycler)?.let { clearPageRestoreForView(it, recycler) }
+    restoredRecyclerKeys.remove(recycler)
     recycler.clipToPadding = original.clipToPadding
     recycler.setPadding(original.left, original.top, original.right, original.bottom)
   }
@@ -1263,7 +1025,7 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
   private fun restoreNativeScrollerInsets(scroller: ScrollView) {
     val original = originalScrollerPadding.remove(scroller) ?: return
     updateScrollerPaddingOwnership(scroller, original)
-    restoredScrollerKeys.remove(scroller)?.let { clearPageRestoreForView(it, scroller) }
+    restoredScrollerKeys.remove(scroller)
     if (scroller is ReactScrollView) {
       val state = scroller.reactScrollViewScrollState
       scroller.setScrollAwayPaddingEnabledUnstable(
@@ -1637,11 +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) {
-      pageRestoreRequests.remove(currentPageKey())
-      pendingPageRestores.remove(currentPageKey())
-      ownedScrollerRestoreRequests.remove(currentPageKey())
-    }
   }
 
   override fun onStopNestedScroll(target: View, type: Int) {
@@ -1735,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}",
@@ -1761,18 +1511,6 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
     nestedNativeGestureStarted = false
     viewTreeObserver.removeOnPreDrawListener(pageContentLayoutListener)
     detachPrimaryScrollObserver()
-    pageRestoreRequests.clear()
-    pendingPageRestores.clear()
-    ownedScrollerRestoreRequests.clear()
-    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")
 }