ui: migrate motion to m3

Author: OxygenCobalt

app/src/main/java/org/oxycblt/auxio/home/ThemedSpeedDialView.kt

@@ -18,35 +18,37 @@
 
 package org.oxycblt.auxio.home
 
-import android.animation.Animator
-import android.animation.AnimatorListenerAdapter
-import android.animation.AnimatorSet
-import android.animation.ObjectAnimator
+import android.animation.ArgbEvaluator
+import android.graphics.Canvas
+import android.graphics.ColorFilter
+import android.graphics.PixelFormat
+import android.graphics.PorterDuff
+import android.graphics.Rect
+import android.graphics.drawable.Drawable
 import android.content.Context
 import android.content.res.ColorStateList
-import android.graphics.drawable.Drawable
-import android.graphics.drawable.RotateDrawable
 import android.os.Bundle
 import android.os.Parcelable
 import android.util.AttributeSet
-import android.util.Property
-import android.view.View
-import android.widget.ImageView
 import android.widget.TextView
 import androidx.annotation.AttrRes
 import androidx.annotation.FloatRange
 import androidx.core.os.BundleCompat
 import androidx.core.view.setMargins
 import androidx.core.view.updateLayoutParams
 import androidx.core.widget.TextViewCompat
+import androidx.dynamicanimation.animation.FloatValueHolder
+import androidx.dynamicanimation.animation.SpringAnimation
+import androidx.dynamicanimation.animation.SpringForce
+import com.google.android.material.R as MR
+import com.google.android.material.motion.MotionUtils
 import com.google.android.material.shape.MaterialShapeDrawable
 import com.leinardi.android.speeddial.FabWithLabelView
 import com.leinardi.android.speeddial.SpeedDialActionItem
 import com.leinardi.android.speeddial.SpeedDialView
 import kotlin.math.roundToInt
 import kotlinx.parcelize.Parcelize
 import org.oxycblt.auxio.R
-import org.oxycblt.auxio.ui.AnimConfig
 import org.oxycblt.auxio.util.getAttrColorCompat
 import org.oxycblt.auxio.util.getAttrResourceId
 import org.oxycblt.auxio.util.getDimen
@@ -65,9 +67,23 @@ import org.oxycblt.auxio.util.getDimenPixels
  * @author Hai Zhang, Alexander Capehart (OxygenCobalt)
  */
 class ThemedSpeedDialView : SpeedDialView {
-    private var mainFabAnimator: Animator? = null
+    private var mainFabAnimation: MainFabAnimation? = null
     private val spacingSmall = context.getDimenPixels(R.dimen.spacing_small)
     private var innerChangeListener: ((Boolean) -> Unit)? = null
+    private val mainFabDrawable = RotatingDrawable(checkNotNull(mainFab.drawable).mutate())
+    private val mainFabSpatialSpring =
+        MotionUtils.resolveThemeSpringForce(
+            context,
+            MR.attr.motionSpringFastSpatial,
+            MR.style.Motion_Material3_Spring_Standard_Fast_Spatial,
+        )
+    private val mainFabEffectsSpring =
+        MotionUtils.resolveThemeSpringForce(
+            context,
+            MR.attr.motionSpringFastEffects,
+            MR.style.Motion_Material3_Spring_Standard_Fast_Effects,
+        )
+    private val argbEvaluator = ArgbEvaluator()
 
     constructor(context: Context) : super(context)
 
@@ -79,8 +95,6 @@ class ThemedSpeedDialView : SpeedDialView {
         @AttrRes defStyleAttr: Int,
     ) : super(context, attrs, defStyleAttr)
 
-    private val stationaryConfig = AnimConfig.of(context, AnimConfig.STANDARD, AnimConfig.MEDIUM2)
-
     init {
         // Work around ripple bug on Android 12 when useCompatPadding = true.
         // @see https://github.com/material-components/material-components-android/issues/2617
@@ -107,18 +121,15 @@ class ThemedSpeedDialView : SpeedDialView {
                 .defaultColor
 
         // Always use our own animation to fix the library issue that ripple is rotated as well.
-        val mainFabDrawable =
-            RotateDrawable().apply {
-                drawable = mainFab.drawable
-                toDegrees = 45f + 90f
-            }
         mainFabAnimationRotateAngle = 0f
         setMainFabClosedDrawable(mainFabDrawable)
+        setMainFabOpenedDrawable(null)
         setOnChangeListener(
             object : OnChangeListener {
                 override fun onMainActionSelected(): Boolean = false
 
                 override fun onToggleChanged(isOpen: Boolean) {
+                    mainFabAnimation?.cancel()
                     mainFab.backgroundTintList =
                         ColorStateList.valueOf(
                             if (isOpen) mainFabClosedBackgroundColor
@@ -128,67 +139,83 @@ class ThemedSpeedDialView : SpeedDialView {
                         ColorStateList.valueOf(
                             if (isOpen) mainFabClosedIconColor else mainFabOpenedIconColor
                         )
-                    mainFabAnimator?.cancel()
-                    mainFabAnimator =
-                        createMainFabAnimator(isOpen).apply {
-                            addListener(
-                                object : AnimatorListenerAdapter() {
-                                    override fun onAnimationEnd(animation: Animator) {
-                                        mainFabAnimator = null
-                                    }
-                                }
-                            )
-                            start()
-                        }
+                    mainFabAnimation = createMainFabAnimation(isOpen).apply { start() }
                     innerChangeListener?.invoke(isOpen)
                 }
             }
         )
     }
 
-    private fun createMainFabAnimator(isOpen: Boolean): Animator {
-        val totalDuration = stationaryConfig.duration
-        val partialDuration = totalDuration / 2 // This is half of the total duration
-        val delay = totalDuration / 4 // This is one fourth of the total duration
+    private fun createMainFabAnimation(isOpen: Boolean): MainFabAnimation {
+        val targetBackgroundTint =
+            if (isOpen) mainFabOpenedBackgroundColor else mainFabClosedBackgroundColor
+        val targetImageTint = if (isOpen) mainFabOpenedIconColor else mainFabClosedIconColor
 
-        val backgroundTintAnimator =
-            ObjectAnimator.ofArgb(
-                    mainFab,
-                    VIEW_PROPERTY_BACKGROUND_TINT,
-                    if (isOpen) mainFabOpenedBackgroundColor else mainFabClosedBackgroundColor,
-                )
-                .apply {
-                    startDelay = delay
-                    duration = partialDuration
-                }
+        val backgroundTintAnimation =
+            createColorSpringAnimation(
+                startColor =
+                    if (isOpen) mainFabClosedBackgroundColor else mainFabOpenedBackgroundColor,
+                endColor = targetBackgroundTint,
+            ) { mainFab.backgroundTintList = ColorStateList.valueOf(it) }
+        val imageTintAnimation =
+            createColorSpringAnimation(
+                startColor = if (isOpen) mainFabClosedIconColor else mainFabOpenedIconColor,
+                endColor = targetImageTint,
+            ) { mainFab.imageTintList = ColorStateList.valueOf(it) }
+        val rotationAnimation =
+            createSpringAnimation(
+                startValue = mainFabDrawable.rotationDegrees,
+                finalValue = if (isOpen) MAIN_FAB_OPEN_ROTATION_DEGREES else 0f,
+                springTemplate = mainFabSpatialSpring,
+                minimumVisibleChange = MAIN_FAB_ROTATION_MIN_VISIBLE_CHANGE,
+                dampingRatioOverride = MAIN_FAB_ROTATION_DAMPING_RATIO_OVERRIDE,
+            ) { mainFabDrawable.rotationDegrees = it }
 
-        val imageTintAnimator =
-            ObjectAnimator.ofArgb(
-                    mainFab,
-                    IMAGE_VIEW_PROPERTY_IMAGE_TINT,
-                    if (isOpen) mainFabOpenedIconColor else mainFabClosedIconColor,
-                )
-                .apply {
-                    startDelay = delay
-                    duration = partialDuration
-                }
+        return MainFabAnimation(
+            listOf(backgroundTintAnimation, imageTintAnimation, rotationAnimation)
+        ) {
+            mainFabAnimation = null
+        }
+    }
 
-        val levelAnimator =
-            ObjectAnimator.ofInt(
-                    mainFab.drawable,
-                    DRAWABLE_PROPERTY_LEVEL,
-                    if (isOpen) 10000 else 0,
-                )
-                .apply { duration = totalDuration }
+    private fun createColorSpringAnimation(
+        startColor: Int,
+        endColor: Int,
+        update: (Int) -> Unit,
+    ): SpringAnimation =
+        createSpringAnimation(
+            startValue = 0f,
+            finalValue = 1f,
+            springTemplate = mainFabEffectsSpring,
+            minimumVisibleChange = MAIN_FAB_COLOR_PROGRESS_MIN_VISIBLE_CHANGE,
+        ) { progress ->
+            val color =
+                argbEvaluator.evaluate(progress.coerceIn(0f, 1f), startColor, endColor) as Int
+            update(color)
+        }
 
-        val animatorSet =
-            AnimatorSet().apply {
-                playTogether(backgroundTintAnimator, imageTintAnimator, levelAnimator)
-                interpolator = stationaryConfig.interpolator
+    private fun createSpringAnimation(
+        startValue: Float,
+        finalValue: Float,
+        springTemplate: SpringForce,
+        minimumVisibleChange: Float,
+        dampingRatioOverride: Float? = null,
+        update: (Float) -> Unit,
+    ): SpringAnimation =
+        SpringAnimation(FloatValueHolder(startValue)).apply {
+            spring =
+                SpringForce().apply {
+                    dampingRatio = dampingRatioOverride ?: springTemplate.dampingRatio
+                    stiffness = springTemplate.stiffness
+                    finalPosition = finalValue
+                }
+            setStartValue(startValue)
+            setMinimumVisibleChange(minimumVisibleChange)
+            addUpdateListener { _, value, _ -> update(value) }
+            addEndListener { _, canceled, value, _ ->
+                update(if (canceled) value else finalValue)
             }
-        animatorSet.start()
-        return animatorSet
-    }
+        }
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
@@ -304,34 +331,140 @@ class ThemedSpeedDialView : SpeedDialView {
         innerChangeListener = listener
     }
 
-    companion object {
-        private val VIEW_PROPERTY_BACKGROUND_TINT =
-            object : Property<View, Int>(Int::class.java, "backgroundTint") {
-                override fun get(view: View): Int = view.backgroundTintList!!.defaultColor
+    @Parcelize
+    private class State(val superState: Parcelable?, val isOpen: Boolean) : Parcelable
+
+    private class MainFabAnimation(
+        private val animations: List<SpringAnimation>,
+        private val onEnd: () -> Unit,
+    ) {
+        private var remainingAnimations = animations.size
+        private var finished = false
 
-                override fun set(view: View, value: Int?) {
-                    view.backgroundTintList = ColorStateList.valueOf(value!!)
+        init {
+            animations.forEach { animation ->
+                animation.addEndListener { _, _, _, _ ->
+                    if (finished) {
+                        return@addEndListener
+                    }
+                    remainingAnimations -= 1
+                    if (remainingAnimations == 0) {
+                        finished = true
+                        onEnd()
+                    }
                 }
             }
+        }
 
-        private val IMAGE_VIEW_PROPERTY_IMAGE_TINT =
-            object : Property<ImageView, Int>(Int::class.java, "imageTint") {
-                override fun get(view: ImageView): Int = view.imageTintList!!.defaultColor
+        fun start() {
+            animations.forEach { animation ->
+                animation.animateToFinalPosition(animation.spring.finalPosition)
+            }
+        }
 
-                override fun set(view: ImageView, value: Int?) {
-                    view.imageTintList = ColorStateList.valueOf(value!!)
-                }
+        fun cancel() {
+            if (finished) {
+                return
             }
+            finished = true
+            animations.forEach { it.cancel() }
+            onEnd()
+        }
+    }
+}
 
-        private val DRAWABLE_PROPERTY_LEVEL =
-            object : Property<Drawable, Int>(Int::class.java, "level") {
-                override fun get(drawable: Drawable): Int = drawable.level
+private class RotatingDrawable(
+    drawable: Drawable,
+) : Drawable(), Drawable.Callback {
+    private var wrappedDrawable = drawable
 
-                override fun set(drawable: Drawable, value: Int?) {
-                    drawable.level = value!!
-                }
+    var rotationDegrees = 0f
+        set(value) {
+            if (field == value) {
+                return
             }
+            field = value
+            invalidateSelf()
+        }
+
+    init {
+        wrappedDrawable.callback = this
+    }
+
+    override fun draw(canvas: Canvas) {
+        if (bounds.isEmpty) {
+            return
+        }
+
+        val saveCount = canvas.save()
+        canvas.rotate(rotationDegrees, bounds.exactCenterX(), bounds.exactCenterY())
+        wrappedDrawable.draw(canvas)
+        canvas.restoreToCount(saveCount)
+    }
+
+    override fun onBoundsChange(bounds: Rect) {
+        wrappedDrawable.bounds = bounds
+    }
+
+    override fun onStateChange(state: IntArray): Boolean {
+        val changed = wrappedDrawable.setState(state)
+        if (changed) {
+            invalidateSelf()
+        }
+        return changed
+    }
+
+    override fun isStateful(): Boolean = wrappedDrawable.isStateful
+
+    override fun getPadding(padding: Rect): Boolean = wrappedDrawable.getPadding(padding)
+
+    override fun getIntrinsicWidth(): Int = wrappedDrawable.intrinsicWidth
+
+    override fun getIntrinsicHeight(): Int = wrappedDrawable.intrinsicHeight
+
+    override fun setAlpha(alpha: Int) {
+        wrappedDrawable.alpha = alpha
+    }
+
+    override fun getAlpha(): Int = wrappedDrawable.alpha
+
+    override fun setColorFilter(colorFilter: ColorFilter?) {
+        wrappedDrawable.colorFilter = colorFilter
+    }
+
+    override fun getOpacity(): Int = PixelFormat.TRANSLUCENT
+
+    override fun setTint(tintColor: Int) {
+        wrappedDrawable.setTint(tintColor)
+    }
+
+    override fun setTintList(tint: ColorStateList?) {
+        wrappedDrawable.setTintList(tint)
+    }
+
+    override fun setTintMode(tintMode: PorterDuff.Mode?) {
+        wrappedDrawable.setTintMode(tintMode)
     }
 
-    @Parcelize private class State(val superState: Parcelable?, val isOpen: Boolean) : Parcelable
+    override fun setVisible(visible: Boolean, restart: Boolean): Boolean =
+        super.setVisible(visible, restart) || wrappedDrawable.setVisible(visible, restart)
+
+    override fun onLevelChange(level: Int): Boolean = wrappedDrawable.setLevel(level)
+
+    override fun invalidateDrawable(who: Drawable) {
+        invalidateSelf()
+    }
+
+    override fun scheduleDrawable(who: Drawable, what: Runnable, `when`: Long) {
+        scheduleSelf(what, `when`)
+    }
+
+    override fun unscheduleDrawable(who: Drawable, what: Runnable) {
+        unscheduleSelf(what)
+    }
 }
+
+private const val MAIN_FAB_OPEN_ROTATION_DEGREES = 135f
+private const val MAIN_FAB_ROTATION_MIN_VISIBLE_CHANGE = 0.1f
+private const val MAIN_FAB_ROTATION_DAMPING_RATIO_OVERRIDE = 0.6f
+private const val MAIN_FAB_COLOR_PROGRESS_MIN_VISIBLE_CHANGE = 1f / 255f