The Animator API, is the parent class for this is the parent to alll animatable classes in android.animation package.

To support this, we must add a LifecycleObserver that will match the lifecycle of the animation to the lifecycle of where it is being displayed.

Animator "Lifecycle"

• An Animator can be paused - we should call this when the parent lifecycle enters the PAUSED state
• An Animator can be resumed - we should call this when the parent lifecycle enters the RESUMED state
• An Animator can be cancelled - we should do this when the parent lifecycle enters the DESTROYED state

When we cancel the Animator we should also call removeAllListeners, this will ensure no memory leaks.

The AnimatedVectorDrawable is a type of drawable that allows us to animated vector images.

To support this, we must add a LifecycleObserver that will match the lifecycle of the AnimatedVectorDrawable to the lifecycle of where it is being displayed.

AnimatedVectorDrawable "Lifecycle"

• An AnimatedVectorDrawable can be started - we should call this when the parent lifecycle enters the RESUMED state, neeed to identify if this is continues the animation from where it stopped
• An AnimatedVectorDrawable can be stopped - we should call this when the parent lifecycle enters the PAUSED state
• An AnimatedVectorDrawable can be reset - we do not need to use reset, we should handle pausing and starting but not dictate the state of the AnimatedVectorDrawable passed into here.

The AnimatedVectorDrawable can also have listeners attached to it, we should clear all set listeners that have been set up using the clearAnimationCallbacks function.

The purpose of the public API will be to provide a consistent API that allows users to erase any support animation API.

The API must provide the following pieces of information:

• Access to the LifecycleObserver (via ComponentActivity, Fragment or View?) and
• Access to an Animator for #1 or
• Access to an AnimationDrawable for #2 or
• Access to an AnimatedVectorDrawable for #3

The API will likely exist as an extension function on one of these types. Could something like a CoroutineScope be emulated?

Add an additional module that will provide lint rules to tell developers where their animation APIs haven't had their lifecycles correctly handled.

Inspiration from Timber.

Some animations provide information about if an animation can be repeated. If, the animation isn't set to be repeated, we should be able to safely unsubscribe our lifecycle observers and then "erase" the animations.

This is potentially risky, because a developer may manually repeat an animation (I don't think this should be done, an animation should be recreated).

Ask the animation about it's current state when we pass into the PAUSED lifecycle state. If it is not running, it should not be resumed. This state can be safely held within the relevant LifecycleObserver implementations.

• Handler animations
• Posting to be added to the next frame?

We don't want to break the public API, using the Binary Compatibility Validaor is the best way to do this.

An AnimationDrawable represents an animation composed of drawables, please see the documentation here.

Like most animations, these can be started and stopped. They may also have listeners attached to them. Eraser will attavch the AnimationDrawable lifecycle to the lifecycle of another Lifecycle.

AnimationDrawable "Lifecycle"

• An AnimationDrawable can be started - we should call this when the parent lifecycle enters the RESUMED state
• An AnimationDrawable can be stopped - we should call this when the parent lifecycle enters the PAUSED state