This tutorial explains in detail how to use the Handler and postDelayed methods to create an infinite loop animation effect with a custom pause interval for views (such as RecyclerView list items) in Android applications. By combining XML animation definitions and Java/Kotlin code, we will implement the animation to pause for a specified time after each playback, and then automatically restart, thereby avoiding the limitations of the traditional Animation loop mode.

Understand the limitations of traditional animation loops

In Android, we usually define Animation objects through XML or code to add dynamic effects to views. For example, a simple rotation animation might look like this:

 <!-- res/anim/shake_animation.xml -->
<set xmlns:android="http://schemas.android.com/apk/res/android">
    <rotate android:duration="30" android:fromdegrees="-2" android:pivotx="50%" android:pivoty="50%" android:repeatcount="20" android:repeatmode="reverse" android:todegrees="2"></rotate>
</set>

In this shake_animation.xml definition:

• android:duration="30": Indicates that the duration of a single rotation (from -2 degrees to 2 degrees, or from 2 degrees to -2 degrees) is 30 milliseconds.
• android:repeatCount="20": Indicates that the animation will repeat 20 half-cycles. Since rotate goes from -2 to 2 in one half cycle, and from 2 to -2 in another half cycle, repeatCount="20" actually means 10 complete shakes (from -2 to 2 and back to -2).
• android:repeatMode="reverse": Indicates that the animation will play in reverse every time it is repeated.

When we apply this animation to a view, for example through viewToAnimate.startAnimation(shake);, it will immediately perform these 10 shakes, with a total duration of 30ms * 20 = 600ms. However, traditional Animation mechanisms (such as repeatCount) can only control the number of times the animation is repeated within a single startAnimation() call. It cannot realize the need to pause for a period of time after the animation is played, and then restart the entire animation cycle. If we need to wait for a long time (for example, 5 seconds) before restarting the animation after each complete playback, the function of Animation itself will be insufficient.

Core solution: Handler and postDelayed

In order to achieve infinite looping and regular pause of animation, we need to introduce Android's Handler and Runnable mechanisms. Handler allows us to send tasks (Runnable) to the message queue and execute these tasks after a specified time. Combined with the postDelayed() method, we can precisely control the startup timing of the animation.

The basic idea is:

1. Define a Runnable that contains the code to load and start the animation.
2. Use Handler.postDelayed() to schedule this Runnable for the first time and set the delay for the first animation.
3. Inside the Runnable, after the animation starts, it uses Handler.postDelayed() to schedule itself again, thereby achieving infinite loops and pauses between each loop.

Implement infinite loops and timed pauses

The following is a code example that implements an infinite loop shaking animation of a view with a timed pause:

 import android.content.Context;
import android.os.Handler;
import android.view.View;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;

public class AnimationScheduler {

    private final Context context;
    private final View viewToAnimate;
    private Handler animationHandler;
    private Runnable animationRunnable;

    // Assume the total animation duration is 600ms (30ms * 20 repeatCount)
    private static final long ANIMATION_DURATION = 600; 
    // Pause time after the animation ends private static final long PAUSE_DURATION = 5000; // 5 seconds // Delay before the first animation starts private static final long INITIAL_DELAY = 5000; // 5 seconds public AnimationScheduler(Context context, View viewToAnimate) {
        this.context = context;
        this.viewToAnimate = viewToAnimate;
        this.animationHandler = new Handler();
        initAnimationRunnable();
    }

    private void initAnimationRunnable() {
        animationRunnable = new Runnable() {
            @Override
            public void run() {
                // 1. Load animation Animation shakeAnimation = AnimationUtils.loadAnimation(context, R.anim.shake_animation);
                // 2. Start animation viewToAnimate.startAnimation(shakeAnimation);
                // 3. Schedule the start of the next animation // The start time of the next animation = the current animation start time, the total animation duration, and the pause duration // Or simply, start from the current Runnable execution, delay (the total animation duration, pause duration) and then execute the Runnable again
                animationHandler.postDelayed(this, ANIMATION_DURATION PAUSE_DURATION);
            }
        };
    }

    /**
     *Start infinite loop animation*/
    public void startInfiniteAnimation() {
        // First dispatch, start animation after initial delay animationHandler.postDelayed(animationRunnable, INITIAL_DELAY);
    }

    /**
     * Stop infinite loop animation to prevent memory leaks */
    public void stopInfiniteAnimation() {
        if (animationHandler != null && animationRunnable != null) {
            animationHandler.removeCallbacks(animationRunnable);
        }
    }
}

Code explanation:

1. AnimationScheduler class: Encapsulates animation scheduling logic in a class for easy management and reuse.
2. ANIMATION_DURATION and PAUSE_DURATION:
   • ANIMATION_DURATION is the total duration of actual playback of the animation defined in shake_animation.xml (30ms * 20 = 600ms).
   • PAUSE_DURATION is the number of milliseconds we want the view to pause after each animation ends (for example, 5000ms = 5 seconds).
3. Handler animationHandler = new Handler();: Create a Handler instance, which will be associated with the message queue of the thread that created it (usually the UI main thread).
4. Runnable animationRunnable:
   • Animation shakeAnimation = AnimationUtils.loadAnimation(context, R.anim.shake_animation);: Load and create a new animation instance every time Runnable is executed.
   • viewToAnimate.startAnimation(shakeAnimation);: Start animation.
   • animationHandler.postDelayed(this, ANIMATION_DURATION PAUSE_DURATION);: This is the key to implementing the loop. It tells the Handler to execute the current animationRunnable again after ANIMATION_DURATION PAUSE_DURATION milliseconds.
     • ANIMATION_DURATION ensures that the animation has enough time to complete.
     • PAUSE_DURATION provides additional pause time after the animation ends.
     • Therefore, the total interval from the start of one animation to the start of the next is ANIMATION_DURATION PAUSE_DURATION. The actual pause time is PAUSE_DURATION.
5. startInfiniteAnimation(): Call postDelayed() for the first time to start the entire loop. It uses INITIAL_DELAY to set the wait time before the first animation starts.
6. stopInfiniteAnimation(): Provides a method to stop loop animation. Calling removeCallbacks(animationRunnable) can remove all pending animationRunnable tasks from the Handler's message queue, thereby stopping subsequent scheduling.

Usage example:

In an Activity or Fragment, you can use AnimationScheduler like this:

 public class MyActivity extends AppCompatActivity {

    private AnimationScheduler scheduler;
    private View myItemView; // Assuming this is the view you want to shake @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        myItemView = findViewById(R.id.my_item_view); // Replace with your view ID

        scheduler = new AnimationScheduler(this, myItemView);
        scheduler.startInfiniteAnimation();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // Very important: stop animation when Activity/Fragment is destroyed to prevent memory leaks if (scheduler != null) {
            scheduler.stopInfiniteAnimation();
        }
    }
}

Things to note and best practices

1. Handler memory leak:

   • The Handler will hold a reference to the Activity or Fragment in which it is located. If the Runnable contains references to these components and the Runnable is delayed, then when the Activity or Fragment is destroyed, the Handler will still hold their references, causing a memory leak.
   • Solution: Be sure to call handler.removeCallbacks(runnable) in Activity's onDestroy() or Fragment's onDestroyView() to remove all pending tasks. In the AnimationScheduler example above, the stopInfiniteAnimation() method serves this purpose.
   • A safer approach is to use WeakReference to reference the Context or View to avoid memory leaks caused by direct references.

2. Precise control of animation duration and scheduling intervals:

   • As mentioned before, the delay in handler.postDelayed(runnable, delay) is calculated from when postDelayed is called.
   • If you want the animation to pause for exactly X milliseconds after it ends, the second argument to postDelayed should be X the total duration of the animation.
   • In AnimationScheduler we have achieved this via ANIMATION_DURATION PAUSE_DURATION.

3. Application in RecyclerView:

   • If you want to achieve this effect on multiple list items of RecyclerView, you can create and start an AnimationScheduler instance for each ViewHolder that needs animation in the onBindViewHolder() method of RecyclerView.Adapter.
   • Performance considerations: Running complex animations on a large number of visible items simultaneously may impact performance. Make sure the animation itself is lightweight enough, and stop the corresponding animation when the list item scrolls off the screen to save resources. You can call scheduler.stopInfiniteAnimation() in onViewRecycled().
   • For unified animation of all visible items, you can consider triggering it through a global Handler outside RecyclerView, and then traverse the currently visible ViewHolder and start the animation, instead of maintaining an independent Handler for each ViewHolder.

4. Stop animation:

   • In addition to stopping animations at the end of the component's life cycle, you may also want to stop animations when user interaction or other events are triggered. Just call scheduler.stopInfiniteAnimation().

5. Alternatives: ObjectAnimator and ValueAnimator:

   • For more complex animation needs, especially when you need to animate property values ??rather than view transformations, ObjectAnimator and ValueAnimator provide more powerful control capabilities. They can directly manipulate the properties of the view (such as rotation, alpha, translationX, etc.), and can more easily implement animation monitoring and chained animations.
   • Although this tutorial uses traditional Animation, Handler combined with ObjectAnimator can also achieve similar infinite loop and pause effects, and is usually more flexible.

Summarize

By cleverly combining the Handler and postDelayed methods, we can overcome the limitations of traditional Android Animation in loop control and achieve infinite loop playback of view animations with custom pause intervals. This approach provides a powerful tool for creating more interactive and engaging user interfaces. When using it, be sure to pay attention to the memory leak problem of Handler and choose the most appropriate animation implementation method according to actual needs.

The above is the detailed content of Use Handler to implement infinite loop and timed pause of view animation in Android. For more information, please follow other related articles on the PHP Chinese website!