How to disable Spring Animation for Espresso Tests?

Question

I'm using the Android spring animation in my project (see here). However, these animations are getting in the way of my espresso tests.

I already tried to disable these animations using the developer options in the phone, but they seem to not be affected by these settings.

Is there any way how I can disable them just for tests?

Answer 1

After struggling with a flaky test due to SpringAnimations I came up with three solutions:

Solution 1: Add a function that wraps creating your SpringAnimations

This is the most invasive in terms of changing existing code, but least complex method to follow:

You can check if animations are disabled at runtime:

 fun animationsDisabled() =
    Settings.Global.getFloat(
            contentResolver,
            Settings.Global.ANIMATOR_DURATION_SCALE, 1.0f,
    ) == 0.0f

Then selectively return a dummy animation that immediately finishes while also setting the value to it's final state:

 fun <K : View?> createAnimation(
    target: K,
    property: FloatPropertyCompat<K>,
    finalValue: Float
) = if (animationsDisabled() == false) {
        SpringAnimation(target, property, finalValue).apply {
            spring.dampingRatio = dampingRatio
            spring.stiffness = stiffness
        }
    } else {
        property.setValue(target, finalValue)
        SpringAnimation(FloatValueHolder(0f)).apply{
            spring = SpringForce(100f)
            spring.dampingRatio = dampingRatio
            spring.stiffness = stiffness
            addUpdateListener { _, _, _ -> skipToEnd() }
        }
   }
}

Solution 2: Create an IdlingResource that tells Espresso if a DynamicAnimation is running

SpringAnimation and FlingAnimation both extend from DynamicAnimation, the class which is ignoring the system Animation Scale and causing issues here.

This solution isn't the prettiest as it uses reflection, but the implementation details it relies on haven't changed since DynamicAnimation was introduced.

Based on DataBindingIdlingResource:

import android.view.View
import androidx.dynamicanimation.animation.DynamicAnimation
import androidx.test.espresso.IdlingResource
import androidx.test.ext.junit.rules.ActivityScenarioRule
import java.util.UUID


 // An espresso idling resource implementation that reports idle status for all DynamicAnimation instances
class DynamicAnimationIdlingResource(private val activityScenarioRule: ActivityScenarioRule<*>) :
    IdlingResource {
    // list of registered callbacks
    private val idlingCallbacks = mutableListOf<IdlingResource.ResourceCallback>()

    // give it a unique id to workaround an espresso bug where you cannot register/unregister
    // an idling resource w/ the same name.
    private val id = UUID.randomUUID().toString()

    // holds whether isIdle is called and the result was false. We track this to avoid calling
    // onTransitionToIdle callbacks if Espresso never thought we were idle in the first place.
    private var wasNotIdle = false

    override fun getName() = "DynamicAnimation $id"

    override fun isIdleNow(): Boolean {
        val idle = !getDynamicAnimations().any { it.isRunning }
        @Suppress("LiftReturnOrAssignment")
        if (idle) {
            if (wasNotIdle) {
                // notify observers to avoid espresso race detector
                idlingCallbacks.forEach { it.onTransitionToIdle() }
            }
            wasNotIdle = false
        } else {
            wasNotIdle = true
            activityScenarioRule.scenario.onActivity {
                it.findViewById<View>(android.R.id.content)
                        .postDelayed({ isIdleNow }, 16)
            }
        }

        return idle
    }

    override fun registerIdleTransitionCallback(callback: IdlingResource.ResourceCallback) {
        idlingCallbacks.add(callback)
    }

    /**
     * Find all binding classes in all currently available fragments.
     */
    private fun getDynamicAnimations(): List<DynamicAnimation<*>> {
        val dynamicAnimations = mutableListOf<DynamicAnimation<*>>()
        val animationHandlerClass = Class
                .forName("androidx.dynamicanimation.animation.AnimationHandler")
        val animationHandler =
                animationHandlerClass
                        .getDeclaredMethod("getInstance")
                        .invoke(null)
        val animationCallbacksField =
                animationHandlerClass
                        .getDeclaredField("mAnimationCallbacks").apply {
                            isAccessible = true
                        }

        val animationCallbacks =
                animationCallbacksField.get(animationHandler) as ArrayList<*>
        animationCallbacks.forEach {
            if (it is DynamicAnimation<*>) {
                dynamicAnimations.add(it)
            }
        }
        return dynamicAnimations
    }
}

For convenience a matching test rule:

/**
 * A JUnit rule that registers an idling resource for all animations that use DynamicAnimations.
 */
class DynamicAnimationIdlingResourceRule(activityScenarioRule: ActivityScenarioRule<*>) : TestWatcher() {
    private val idlingResource = DynamicAnimationIdlingResource(activityScenarioRule)

    override fun finished(description: Description?) {
        IdlingRegistry.getInstance().unregister(idlingResource)
        super.finished(description)
    }

    override fun starting(description: Description?) {
        IdlingRegistry.getInstance().register(idlingResource)
        super.starting(description)
    }
}

This isn't the perfect solution since it will still cause your tests to wait for animations despite changing the animation scale globally

If you have infinite animations based on SpringAnimations (by setting Damping to zero), this won't work as it'll always report to Espresso that an animation is running. You could work around that by casting the DynamicAnimation to a SpringAnimation and checking if Damping was set, but I felt like that's a rare enough case to not complicate things.

Solution 3: Force all SpringAnimations to skip to their last frame

Another reflection based solution, but this one completely disables the SpringAnimations. The trade-off is that theoretically Espresso can still try to interact in the 1 frame window between a SpringAnimation being asked to end, and it actually ending.

In practice I had to rerun the test hundreds of times in a row to get this to happen, at which point the animation may not even be the source of flakiness. So the trade-off is probably worth it if the animations are dragging down how long your tests take to complete:

private fun disableSpringAnimations() {
    val animationHandlerClass = Class
            .forName("androidx.dynamicanimation.animation.AnimationHandler")
    val animationHandler =
            animationHandlerClass
                    .getDeclaredMethod("getInstance")
                    .invoke(null)
    val animationCallbacksField =
            animationHandlerClass
                    .getDeclaredField("mAnimationCallbacks").apply {
                        isAccessible = true
                    }

    CoroutineScope(Dispatchers.IO).launch {
        while (true) {
            withContext(Dispatchers.Main) {
                val animationCallbacks =
                        animationCallbacksField.get(animationHandler) as ArrayList<*>
                animationCallbacks.forEach {
                    val animation = it as? SpringAnimation
                    if (animation?.isRunning == true && animation.canSkipToEnd()) {
                        animation.skipToEnd()
                        animation.doAnimationFrame(100000L)
                    }
                }
            }

            delay(16L)
        }
    }
}

Call this method in your @Before annotated function to have it run before each test.

In the SpringAnimation implementation, skipToEnd sets a flag that is not checked until the next call to doAnimationFrame, hence the animation.doAnimationFrame(100000L) call.