Unofficial YouTube Music / Spotify Premium client for Android, built in Liquid Glass. Audio effects, Spotify Connect, listening history, 8 languages. Rust core on librespot.
Kotlin alternativeandroidandroid-applicationclientglassmorphisminnertubelibrespotliquid-glassspotifyspotify-connectspotifyapiyoutube-musicyoutube-playerytdlnis
// Vendored from the Backdrop catalog app, Apache-2.0.
//
// https://github.com/Kyant0/AndroidLiquidGlass
// commit b18eb0ff12c616546a68c72e7d0097f1ab286c87
//
// These are the library author's own example components rather than part of the
// published artifact, so there is nothing to depend on — they have to be copied.
// Kept as close to upstream as possible (package line and a few Material
// swaps aside) so a later upstream fix can be diffed in; see LICENSE-backdrop.txt.
package dev.lelonio.square.ui.glass
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.spring
import androidx.compose.foundation.MutatorMutex
import androidx.compose.runtime.snapshotFlow
import androidx.compose.ui.Modifier
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.input.pointer.util.VelocityTracker
import androidx.compose.ui.unit.IntSize
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.flow.filter
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.launch
import kotlin.math.abs
import kotlin.time.Clock
class DampedDragAnimation(
private val animationScope: CoroutineScope,
val initialValue: Float,
val valueRange: ClosedRange<Float>,
val visibilityThreshold: Float,
val initialScale: Float,
val pressedScale: Float,
val onDragStarted: DampedDragAnimation.(position: Offset) -> Unit,
val onDragStopped: DampedDragAnimation.() -> Unit,
val onDrag: DampedDragAnimation.(size: IntSize, dragAmount: Offset) -> Unit,
) {
private val valueAnimationSpec =
spring(1f, 1000f, visibilityThreshold)
private val velocityAnimationSpec =
spring(0.5f, 300f, visibilityThreshold * 10f)
private val pressProgressAnimationSpec =
spring(1f, 1000f, 0.001f)
private val scaleXAnimationSpec =
spring(0.6f, 250f, 0.001f)
private val scaleYAnimationSpec =
spring(0.7f, 250f, 0.001f)
private val valueAnimation =
Animatable(initialValue, visibilityThreshold)
private val velocityAnimation =
Animatable(0f, 5f)
private val pressProgressAnimation =
Animatable(0f, 0.001f)
private val scaleXAnimation =
Animatable(initialScale, 0.001f)
private val scaleYAnimation =
Animatable(initialScale, 0.001f)
private val mutatorMutex = MutatorMutex()
private val velocityTracker = VelocityTracker()
val value: Float get() = valueAnimation.value
val progress: Float get() = (value - valueRange.start) / (valueRange.endInclusive - valueRange.start)
val targetValue: Float get() = valueAnimation.targetValue
val pressProgress: Float get() = pressProgressAnimation.value
val scaleX: Float get() = scaleXAnimation.value
val scaleY: Float get() = scaleYAnimation.value
val velocity: Float get() = velocityAnimation.value
val modifier: Modifier = Modifier.pointerInput(Unit) {
inspectDragGestures(
onDragStart = { down ->
onDragStarted(down.position)
press()
},
onDragEnd = {
onDragStopped()
release()
},
onDragCancel = {
onDragStopped()
release()
}
) { change, dragAmount ->
onDrag(size, dragAmount)
}
}
fun press() {
velocityTracker.resetTracking()
animationScope.launch {
launch { pressProgressAnimation.animateTo(1f, pressProgressAnimationSpec) }
launch { scaleXAnimation.animateTo(pressedScale, scaleXAnimationSpec) }
launch { scaleYAnimation.animateTo(pressedScale, scaleYAnimationSpec) }
}
}
fun release() {
animationScope.launch {
awaitFrame()
if (value != targetValue) {
val threshold = (valueRange.endInclusive - valueRange.start) * 0.025f
snapshotFlow { valueAnimation.value }
.filter { abs(it - valueAnimation.targetValue) < threshold }
.first()
}
launch { pressProgressAnimation.animateTo(0f, pressProgressAnimationSpec) }
launch { scaleXAnimation.animateTo(initialScale, scaleXAnimationSpec) }
launch { scaleYAnimation.animateTo(initialScale, scaleYAnimationSpec) }
}
}
fun updateValue(value: Float) {
val targetValue = value.coerceIn(valueRange)
animationScope.launch {
launch { valueAnimation.animateTo(targetValue, valueAnimationSpec) { updateVelocity() } }
}
}
fun animateToValue(value: Float) {
animationScope.launch {
mutatorMutex.mutate {
press()
val targetValue = value.coerceIn(valueRange)
launch { valueAnimation.animateTo(targetValue, valueAnimationSpec) }
if (velocity != 0f) {
launch { velocityAnimation.animateTo(0f, velocityAnimationSpec) }
}
release()
}
}
}
private fun updateVelocity() {
velocityTracker.addPosition(
Clock.System.now().toEpochMilliseconds(),
Offset(value, 0f)
)
val targetVelocity = velocityTracker.calculateVelocity().x / (valueRange.endInclusive - valueRange.start)
animationScope.launch { velocityAnimation.animateTo(targetVelocity, velocityAnimationSpec) }
}
}