library: Add back topappbar snapAnimationSpec

YuKongA · YuKongA · commit 36b09f79cbf7 · 2025-03-14T20:52:22.000+08:00
diff --git a/miuix/src/commonMain/kotlin/top/yukonga/miuix/kmp/basic/LazyColumn.kt b/miuix/src/commonMain/kotlin/top/yukonga/miuix/kmp/basic/LazyColumn.kt
@@ -1,5 +1,6 @@
 package top.yukonga.miuix.kmp.basic
 
+import androidx.compose.foundation.gestures.FlingBehavior
 import androidx.compose.foundation.gestures.ScrollableDefaults
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.PaddingValues
@@ -16,7 +17,6 @@ import androidx.compose.ui.unit.dp
 import top.yukonga.miuix.kmp.utils.Platform
 import top.yukonga.miuix.kmp.utils.overScrollVertical
 import top.yukonga.miuix.kmp.utils.platform
-import top.yukonga.miuix.kmp.utils.rememberOverscrollFlingBehavior
 
 /**
  * A [LazyColumn] that supports over-scroll and top app bar scroll behavior.
@@ -38,14 +38,15 @@ fun LazyColumn(
     verticalArrangement: Arrangement.Vertical =
         if (!reverseLayout) Arrangement.Top else Arrangement.Bottom,
     horizontalAlignment: Alignment.Horizontal = Alignment.Start,
+    flingBehavior: FlingBehavior = ScrollableDefaults.flingBehavior(),
     userScrollEnabled: Boolean = true,
     isEnabledOverScroll: () -> Boolean = { platform() == Platform.Android },
     topAppBarScrollBehavior: ScrollBehavior? = null,
     content: LazyListScope.() -> Unit
 ) {
     val firstModifier = remember(isEnabledOverScroll) {
         if (isEnabledOverScroll.invoke()) {
-            modifier.overScrollVertical(onOverscroll = { topAppBarScrollBehavior?.isPinned = it }, isEnabled = isEnabledOverScroll)
+            modifier.overScrollVertical(isEnabled = isEnabledOverScroll)
         } else {
             modifier
         }
@@ -55,12 +56,6 @@ fun LazyColumn(
             firstModifier.nestedScroll(it.nestedScrollConnection)
         } ?: firstModifier
     }
-    val flingBehavior =
-        if (isEnabledOverScroll.invoke()) {
-            rememberOverscrollFlingBehavior { state }
-        } else {
-            ScrollableDefaults.flingBehavior()
-        }
 
     LazyColumn(
         modifier = finalModifier,
diff --git a/miuix/src/commonMain/kotlin/top/yukonga/miuix/kmp/basic/TopAppBar.kt b/miuix/src/commonMain/kotlin/top/yukonga/miuix/kmp/basic/TopAppBar.kt
@@ -6,6 +6,7 @@ import androidx.compose.animation.core.DecayAnimationSpec
 import androidx.compose.animation.core.Spring
 import androidx.compose.animation.core.animateDecay
 import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.animateTo
 import androidx.compose.animation.core.spring
 import androidx.compose.animation.core.tween
 import androidx.compose.animation.rememberSplineBasedDecay
@@ -212,7 +213,7 @@ fun SmallTopAppBar(
 fun MiuixScrollBehavior(
     state: TopAppBarState = rememberTopAppBarState(),
     canScroll: () -> Boolean = { true },
-    snapAnimationSpec: AnimationSpec<Float>? = spring(stiffness = Spring.StiffnessMediumLow),
+    snapAnimationSpec: AnimationSpec<Float>? = spring(stiffness = Spring.StiffnessMedium),
     flingAnimationSpec: DecayAnimationSpec<Float>? = rememberSplineBasedDecay()
 ): ScrollBehavior =
     remember(state, canScroll, snapAnimationSpec, flingAnimationSpec) {
@@ -363,7 +364,7 @@ interface ScrollBehavior {
      * A pinned app bar will stay fixed in place when content is scrolled and will not react to any
      * drag gestures.
      */
-    var isPinned: Boolean
+    val isPinned: Boolean
 
     /**
      * An optional [AnimationSpec] that defines how the top app bar snaps to either fully collapsed
@@ -402,17 +403,17 @@ interface ScrollBehavior {
  *   [ExitUntilCollapsedScrollBehavior]
  */
 private class ExitUntilCollapsedScrollBehavior(
-    override var isPinned: Boolean = false,
     override val state: TopAppBarState,
     override val snapAnimationSpec: AnimationSpec<Float>?,
     override val flingAnimationSpec: DecayAnimationSpec<Float>?,
     val canScroll: () -> Boolean = { true }
 ) : ScrollBehavior {
+    override val isPinned: Boolean = false
     override var nestedScrollConnection =
         object : NestedScrollConnection {
             override fun onPreScroll(available: Offset, source: NestedScrollSource): Offset {
-                // Don't intercept if scrolling down & if is pinned.
-                if (!canScroll() || available.y > 0f || isPinned) return Offset.Zero
+                // Don't intercept if scrolling down.
+                if (!canScroll() || available.y > 0f) return Offset.Zero
 
                 val prevHeightOffset = state.heightOffset
                 state.heightOffset += available.y
@@ -459,7 +460,7 @@ private class ExitUntilCollapsedScrollBehavior(
             override suspend fun onPostFling(consumed: Velocity, available: Velocity): Velocity {
                 val superConsumed = super.onPostFling(consumed, available)
                 return superConsumed +
-                        settleAppBar(state, available.y, flingAnimationSpec)
+                        settleAppBar(state, available.y, flingAnimationSpec, snapAnimationSpec)
             }
         }
 }
@@ -471,7 +472,8 @@ private class ExitUntilCollapsedScrollBehavior(
 private suspend fun settleAppBar(
     state: TopAppBarState,
     velocity: Float,
-    flingAnimationSpec: DecayAnimationSpec<Float>?
+    flingAnimationSpec: DecayAnimationSpec<Float>?,
+    snapAnimationSpec: AnimationSpec<Float>?,
 ): Velocity {
     // Check if the app bar is completely collapsed/expanded. If so, no need to settle the app bar,
     // and just return Zero Velocity.
@@ -485,20 +487,33 @@ private suspend fun settleAppBar(
     // continue the motion to expand or collapse the app bar.
     if (flingAnimationSpec != null && abs(velocity) > 1f) {
         var lastValue = 0f
-        AnimationState(
-            initialValue = 0f,
-            initialVelocity = velocity,
-        )
-            .animateDecay(flingAnimationSpec) {
-                val delta = value - lastValue
-                val initialHeightOffset = state.heightOffset
-                state.heightOffset = initialHeightOffset + delta
-                val consumed = abs(initialHeightOffset - state.heightOffset)
-                lastValue = value
-                remainingVelocity = this.velocity
-                // avoid rounding errors and stop if anything is unconsumed
-                if (abs(delta - consumed) > 0.5f) this.cancelAnimation()
+        AnimationState(initialValue = 0f, initialVelocity = velocity).animateDecay(
+            flingAnimationSpec
+        ) {
+            val delta = value - lastValue
+            val initialHeightOffset = state.heightOffset
+            state.heightOffset = initialHeightOffset + delta
+            val consumed = abs(initialHeightOffset - state.heightOffset)
+            lastValue = value
+            remainingVelocity = this.velocity
+            // avoid rounding errors and stop if anything is unconsumed
+            if (abs(delta - consumed) > 0.5f) this.cancelAnimation()
+        }
+    }
+    // Snap if animation specs were provided.
+    if (snapAnimationSpec != null) {
+        if (state.heightOffset < 0 && state.heightOffset > state.heightOffsetLimit) {
+            AnimationState(initialValue = state.heightOffset).animateTo(
+                if (state.collapsedFraction < 0.5f) {
+                    0f
+                } else {
+                    state.heightOffsetLimit
+                },
+                animationSpec = snapAnimationSpec,
+            ) {
+                state.heightOffset = value
             }
+        }
     }
 
     return Velocity(0f, velocity - remainingVelocity)
diff --git a/miuix/src/commonMain/kotlin/top/yukonga/miuix/kmp/utils/Overscroll.kt b/miuix/src/commonMain/kotlin/top/yukonga/miuix/kmp/utils/Overscroll.kt
@@ -1,19 +1,9 @@
 package top.yukonga.miuix.kmp.utils
 
 import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.AnimationState
 import androidx.compose.animation.core.AnimationVector1D
-import androidx.compose.animation.core.DecayAnimationSpec
 import androidx.compose.animation.core.Spring.StiffnessMediumLow
-import androidx.compose.animation.core.animateDecay
-import androidx.compose.animation.core.exponentialDecay
 import androidx.compose.animation.core.spring
-import androidx.compose.animation.rememberSplineBasedDecay
-import androidx.compose.foundation.gestures.FlingBehavior
-import androidx.compose.foundation.gestures.ScrollScope
-import androidx.compose.foundation.gestures.ScrollableState
-import androidx.compose.foundation.lazy.LazyListState
-import androidx.compose.foundation.lazy.LazyRow
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.Stable
 import androidx.compose.runtime.getValue
@@ -33,7 +23,6 @@ import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.unit.Velocity
 import kotlinx.coroutines.launch
-import top.yukonga.miuix.kmp.basic.LazyColumn
 import kotlin.math.abs
 import kotlin.math.exp
 import kotlin.math.sign
@@ -87,9 +76,8 @@ fun Modifier.overScrollVertical(
     scrollEasing: ((currentOffset: Float, newOffset: Float) -> Float)? = null,
     springStiff: Float = OutBoundSpringStiff,
     springDamp: Float = OutBoundSpringDamp,
-    onOverscroll: ((Boolean) -> Unit)? = null,
     isEnabled: () -> Boolean = { platform() == Platform.Android }
-): Modifier = overScrollOutOfBound(isVertical = true, nestedScrollToParent, scrollEasing, springStiff, springDamp, onOverscroll, isEnabled)
+): Modifier = overScrollOutOfBound(isVertical = true, nestedScrollToParent, scrollEasing, springStiff, springDamp, isEnabled)
 
 /**
  * @see overScrollOutOfBound
@@ -100,9 +88,8 @@ fun Modifier.overScrollHorizontal(
     scrollEasing: ((currentOffset: Float, newOffset: Float) -> Float)? = null,
     springStiff: Float = OutBoundSpringStiff,
     springDamp: Float = OutBoundSpringDamp,
-    onOverscroll: ((Boolean) -> Unit)? = null,
     isEnabled: () -> Boolean = { platform() == Platform.Android }
-): Modifier = overScrollOutOfBound(isVertical = false, nestedScrollToParent, scrollEasing, springStiff, springDamp, onOverscroll, isEnabled)
+): Modifier = overScrollOutOfBound(isVertical = false, nestedScrollToParent, scrollEasing, springStiff, springDamp, isEnabled)
 
 /**
  * OverScroll effect for scrollable Composable.
@@ -118,7 +105,6 @@ fun Modifier.overScrollHorizontal(
  * The current default easing comes from iOS, you don't need to modify it!
  * @param springStiff springStiff for overscroll effect，For better user experience, the new value is not recommended to be higher than[StiffnessMediumLow]
  * @param springDamp springDamp for overscroll effect，generally do not need to set。
- * @param onOverscroll Callback when the overscroll state changes, the parameter is whether the current state is Overscrolling.
  * @param isEnabled Whether to enable Overscroll effect, default is true.
  */
 @Stable
@@ -129,11 +115,9 @@ fun Modifier.overScrollOutOfBound(
     scrollEasing: ((currentOffset: Float, newOffset: Float) -> Float)?,
     springStiff: Float = OutBoundSpringStiff,
     springDamp: Float = OutBoundSpringDamp,
-    onOverscroll: ((Boolean) -> Unit)? = null,
     isEnabled: () -> Boolean = { platform() == Platform.Android }
 ): Modifier = composed {
     if (!isEnabled()) return@composed this
-    val onOverscroll by rememberUpdatedState(onOverscroll)
     val nestedScrollToParent by rememberUpdatedState(nestedScrollToParent)
     val scrollEasing by rememberUpdatedState(scrollEasing ?: DefaultParabolaScrollEasing)
     val springStiff by rememberUpdatedState(springStiff)
@@ -174,15 +158,13 @@ fun Modifier.overScrollOutOfBound(
                 // sign changed, coerce to start scrolling and exit
                 return if (sign(offset) != sign(offsetAtLast)) {
                     offset = 0f
-                    onOverscroll?.invoke(false)
                     if (isVertical) {
                         Offset(x = available.x - realAvailable.x, y = available.y - realAvailable.y + realOffset)
                     } else {
                         Offset(x = available.x - realAvailable.x + realOffset, y = available.y - realAvailable.y)
                     }
                 } else {
                     offset = offsetAtLast
-                    onOverscroll?.invoke(true)
                     if (isVertical) {
                         Offset(x = available.x - realAvailable.x, y = available.y)
                     } else {
@@ -194,14 +176,13 @@ fun Modifier.overScrollOutOfBound(
             override fun onPostScroll(consumed: Offset, available: Offset, source: NestedScrollSource): Offset {
                 // Found fling behavior in the wrong direction.
                 if (source != NestedScrollSource.UserInput) {
-                    return dispatcher.dispatchPreScroll(available, source)
+                    return dispatcher.dispatchPostScroll(consumed, available, source)
                 }
                 val realAvailable = when {
                     nestedScrollToParent -> available - dispatcher.dispatchPostScroll(consumed, available, source)
                     else -> available
                 }
                 offset = scrollEasing(offset, if (isVertical) realAvailable.y else realAvailable.x)
-                onOverscroll?.invoke(abs(offset) > visibilityThreshold)
                 return if (isVertical) {
                     Offset(x = available.x - realAvailable.x, y = available.y)
                 } else {
@@ -210,7 +191,6 @@ fun Modifier.overScrollOutOfBound(
             }
 
             override suspend fun onPreFling(available: Velocity): Velocity {
-                onOverscroll?.invoke(false)
                 if (::lastFlingAnimator.isInitialized && lastFlingAnimator.isRunning) {
                     lastFlingAnimator.stop()
                 }
@@ -240,7 +220,6 @@ fun Modifier.overScrollOutOfBound(
             }
 
             override suspend fun onPostFling(consumed: Velocity, available: Velocity): Velocity {
-                onOverscroll?.invoke(false)
                 val realAvailable = when {
                     nestedScrollToParent -> available - dispatcher.dispatchPostFling(consumed, available)
                     else -> available
@@ -265,55 +244,3 @@ fun Modifier.overScrollOutOfBound(
             if (isVertical) translationY = offset else translationX = offset
         }
 }
-
-
-/**
- * You should use it with [overScrollVertical]
- * @param decaySpec You can use instead [rememberSplineBasedDecay]
- * @param getScrollState Pass in your [ScrollableState], for [LazyColumn]/[LazyRow] , it's [LazyListState]
- */
-@Composable
-fun rememberOverscrollFlingBehavior(
-    decaySpec: DecayAnimationSpec<Float> = exponentialDecay(),
-    getScrollState: () -> ScrollableState,
-): FlingBehavior = remember(decaySpec, getScrollState) {
-    object : FlingBehavior {
-        /**
-         * - We should check it every frame of fling
-         * - Should stop fling when returning true and return the remaining speed immediately.
-         * - Without this detection, scrollBy() will continue to consume velocity,
-         * which will cause a velocity error in nestedScroll.
-         */
-        private val Float.canNotBeConsumed: Boolean // this is Velocity
-            get() {
-                val state = getScrollState()
-                return !(this < 0 && state.canScrollBackward || this > 0 && state.canScrollForward)
-            }
-
-        override suspend fun ScrollScope.performFling(initialVelocity: Float): Float {
-            if (initialVelocity.canNotBeConsumed) {
-                return initialVelocity
-            }
-            return if (abs(initialVelocity) > 1f) {
-                var velocityLeft = initialVelocity
-                var lastValue = 0f
-                AnimationState(
-                    initialValue = 0f,
-                    initialVelocity = initialVelocity,
-                ).animateDecay(decaySpec) {
-                    val delta = value - lastValue
-                    val consumed = scrollBy(delta)
-                    lastValue = value
-                    velocityLeft = this.velocity
-                    // avoid rounding errors and stop if anything is unconsumed
-                    if (abs(delta - consumed) > 0.5f || velocityLeft.canNotBeConsumed) {
-                        cancelAnimation()
-                    }
-                }
-                velocityLeft
-            } else {
-                initialVelocity
-            }
-        }
-    }
-}
