在 Android 中使用 Handler 实现视图动画的无限循环与定时暂停

理解传统动画循环的局限性

在 android 中，我们通常通过 xml 或代码定义 animation 对象来为视图添加动态效果。例如，一个简单的旋转动画可能如下所示：

<!-- 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" />
</</set>

在这个 shake_animation.xml 定义中：

• android:duration="30"：表示单次旋转（从 -2 度到 2 度，或从 2 度到 -2 度）的持续时间为 30 毫秒。
• android:repeatCount="20"：表示动画会重复 20 次半周期。由于 rotate 从 -2 到 2 是一个半周期，再从 2 到 -2 是另一个半周期，所以 repeatCount="20" 实际上意味着 10 次完整的摇晃（从 -2 到 2 再回到 -2）。
• android:repeatMode="reverse"：表示每次重复时，动画会反向播放。

当我们将这个动画应用到一个视图上时，例如通过 viewToAnimate.startAnimation(shake);，它会立即执行这 10 次摇晃，总时长为 30ms * 20 = 600ms。然而，传统的 Animation 机制（如 repeatCount）只能控制动画在单次 startAnimation() 调用内部的重复次数。它无法实现动画播放结束后暂停一段时间，然后再重新开始整个动画周期的需求。如果我们需要动画在每次完整的播放后，等待一个较长的时间（例如 5 秒），然后再重新启动，Animation 自身的功能就显得不足了。

核心解决方案：Handler 与 postDelayed

为了实现动画的无限循环与定时暂停，我们需要引入 Android 的 Handler 和 Runnable 机制。Handler 允许我们将任务（Runnable）发送到消息队列中，并在指定的时间后执行这些任务。结合 postDelayed() 方法，我们可以精确控制动画的启动时机。

基本思路是：

1. 定义一个 Runnable，其中包含加载并启动动画的代码。
2. 使用 Handler.postDelayed() 首次调度这个 Runnable，设定第一次动画的延迟。
3. 在 Runnable 内部，动画启动后，再次使用 Handler.postDelayed() 调度自身，从而实现无限循环和每次循环间的暂停。

实现无限循环与定时暂停

以下是实现视图无限循环摇晃动画并带有定时暂停的代码示例：

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;

    // 假设动画总时长为 600ms (30ms * 20 repeatCount)
    private static final long ANIMATION_DURATION = 600; 
    // 动画结束后的暂停时间
    private static final long PAUSE_DURATION = 5000; // 5秒
    // 首次动画启动前的延迟
    private static final long INITIAL_DELAY = 5000; // 5秒

    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. 加载动画
                Animation shakeAnimation = AnimationUtils.loadAnimation(context, R.anim.shake_animation);
                // 2. 启动动画
                viewToAnimate.startAnimation(shakeAnimation);
                // 3. 调度下一次动画的启动
                // 下一次动画的启动时间 = 当前动画启动时间 + 动画总时长 + 暂停时长
                // 或者简单地，从当前Runnable执行开始，延迟 (动画总时长 + 暂停时长) 后再次执行Runnable
                animationHandler.postDelayed(this, ANIMATION_DURATION + PAUSE_DURATION);
            }
        };
    }

    /**
     * 启动无限循环动画
     */
    public void startInfiniteAnimation() {
        // 首次调度，在初始延迟后启动动画
        animationHandler.postDelayed(animationRunnable, INITIAL_DELAY);
    }

    /**
     * 停止无限循环动画，防止内存泄漏
     */
    public void stopInfiniteAnimation() {
        if (animationHandler != null && animationRunnable != null) {
            animationHandler.removeCallbacks(animationRunnable);
        }
    }
}

代码解释：

1. AnimationScheduler 类： 将动画调度逻辑封装在一个类中，便于管理和复用。
2. ANIMATION_DURATION 和 PAUSE_DURATION：
   • ANIMATION_DURATION 是 shake_animation.xml 中定义的动画实际播放的总时长（30ms * 20 = 600ms）。
   • PAUSE_DURATION 是我们希望在每次动画播放结束后，视图暂停的毫秒数（例如 5000ms = 5秒）。
3. Handler animationHandler = new Handler();： 创建一个 Handler 实例，它会关联到创建它的线程（通常是 UI 主线程）的消息队列。
4. Runnable animationRunnable：
   • Animation shakeAnimation = AnimationUtils.loadAnimation(context, R.anim.shake_animation);：在 Runnable 每次执行时加载并创建一个新的动画实例。
   • viewToAnimate.startAnimation(shakeAnimation);：启动动画。
   • animationHandler.postDelayed(this, ANIMATION_DURATION + PAUSE_DURATION);：这是实现循环的关键。它告诉 Handler 在 ANIMATION_DURATION + PAUSE_DURATION 毫秒后再次执行当前的 animationRunnable。
     • ANIMATION_DURATION 确保动画有足够的时间播放完毕。
     • PAUSE_DURATION 提供了动画结束后的额外暂停时间。
     • 因此，从一个动画开始到下一个动画开始的总间隔是 ANIMATION_DURATION + PAUSE_DURATION。实际的暂停时间是 PAUSE_DURATION。
5. startInfiniteAnimation()： 首次调用 postDelayed() 来启动整个循环。它使用 INITIAL_DELAY 设定第一次动画开始前的等待时间。
6. stopInfiniteAnimation()： 提供了停止循环动画的方法。调用 removeCallbacks(animationRunnable) 可以从 Handler 的消息队列中移除所有待处理的 animationRunnable 任务，从而停止后续的调度。

使用示例：

在 Activity 或 Fragment 中，您可以这样使用 AnimationScheduler：

无限画

千库网旗下AI绘画创作平台

43

查看详情

public class MyActivity extends AppCompatActivity {

    private AnimationScheduler scheduler;
    private View myItemView; // 假设这是您想摇晃的视图

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        myItemView = findViewById(R.id.my_item_view); // 替换为您的视图ID

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

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 非常重要：在Activity/Fragment销毁时停止动画，防止内存泄漏
        if (scheduler != null) {
            scheduler.stopInfiniteAnimation();
        }
    }
}

注意事项与最佳实践

1. Handler 内存泄漏：

   • Handler 会持有其所在 Activity 或 Fragment 的引用，如果 Runnable 中包含对这些组件的引用，并且 Runnable 被延迟执行，那么在 Activity 或 Fragment 被销毁时，Handler 仍然会持有它们的引用，导致内存泄漏。
   • 解决方案： 务必在 Activity 的 onDestroy() 或 Fragment 的 onDestroyView() 中调用 handler.removeCallbacks(runnable) 来移除所有待处理的任务。在上述 AnimationScheduler 示例中，stopInfiniteAnimation() 方法就是为此目的。
   • 更安全的做法是使用 WeakReference 来引用 Context 或 View，以避免直接引用导致的内存泄漏。

2. 动画持续时间与调度间隔的精确控制：

   • 如前所述，handler.postDelayed(runnable, delay) 中的 delay 是从 postDelayed 被调用时算起的。
   • 如果您希望动画结束后精确暂停 X 毫秒，那么 postDelayed 的第二个参数应该是 动画总时长 + X。
   • 在 AnimationScheduler 中，我们已经通过 ANIMATION_DURATION + PAUSE_DURATION 实现了这一点。

3. RecyclerView 中的应用：

   • 如果要在 RecyclerView 的多个列表项上实现这种效果，您可以在 RecyclerView.Adapter 的 onBindViewHolder() 方法中为每个需要动画的 ViewHolder 创建并启动一个 AnimationScheduler 实例。
   • 性能考虑： 对大量可见项同时运行复杂动画可能会影响性能。请确保动画本身足够轻量，并且在列表项滚动出屏幕时，停止对应的动画以节省资源。您可以在 onViewRecycled() 中调用 scheduler.stopInfiniteAnimation()。
   • 对于所有可见项的统一动画，可以考虑在 RecyclerView 外部通过一个全局 Handler 来触发，然后遍历当前可见的 ViewHolder 并启动动画，而不是每个 ViewHolder 都维护一个独立的 Handler。

4. 停止动画：

   • 除了在组件生命周期结束时停止动画，您可能还需要在用户交互或其他事件触发时停止动画。调用 scheduler.stopInfiniteAnimation() 即可。

5. 替代方案：ObjectAnimator 和 ValueAnimator：

   • 对于更复杂的动画需求，尤其是需要动画属性值而不是视图变换时，ObjectAnimator 和 ValueAnimator 提供了更强大的控制能力。它们可以直接操作视图的属性（如 rotation、alpha、translationX 等），并且可以更容易地实现动画监听和链式动画。
   • 虽然本教程使用了传统的 Animation，但 Handler 结合 ObjectAnimator 也能实现类似的无限循环和暂停效果，且通常更灵活。

总结

通过巧妙地结合 Handler 和 postDelayed 方法，我们可以克服传统 Android Animation 在循环控制上的局限性，实现视图动画的无限循环播放并带有自定义的暂停间隔。这种方法为创建更具交互性和吸引力的用户界面提供了强大的工具。在使用时，务必注意 Handler 的内存泄漏问题，并根据实际需求选择最合适的动画实现方式。

以上就是在 Android 中使用 Handler 实现视图动画的无限循环与定时暂停的详细内容，更多请关注php中文网其它相关文章！