创建自定义触觉效果

本页面介绍了如何在 Android 应用中使用不同的触觉 API 创建自定义效果的示例。由于本页面的许多信息都依赖于对振动执行器工作原理的深入了解，因此建议您阅读振动执行器入门。

本页面包含以下示例。

自定义振动模式
- 斜坡模式：从平滑开始的模式。
- 重复模式：没有结束的模式。
- 带有回退的模式：回退演示。
振动组合
- 阻力：具有动态强度的拖动效果。
- 扩展：先上升后下降的效果。
- 摇晃：使用 SPIN 原语的摇晃效果。
- 弹跳：使用 THUD 原语的弹跳效果。

有关其他示例，请参阅为事件添加触觉反馈，并始终遵循触觉设计原则。

使用回退处理设备兼容性

实现任何自定义效果时，请考虑以下事项

效果所需的设备功能
设备无法播放效果时的处理方法

Android 触觉 API 参考提供了有关如何检查对触觉中涉及的组件的支持的详细信息，以便你的应用能够提供一致的整体体验。

根据你的用例，你可能希望禁用自定义效果或根据不同的潜在功能提供替代的自定义效果。

规划以下高级别的设备功能类别

如果你使用的是触觉原语：支持自定义效果所需的这些原语的设备。（有关原语的详细信息，请参阅下一节。）
具有振幅控制的设备。
具有基本振动支持（开/关）的设备——换句话说，缺乏振幅控制的设备。

如果你的应用的触觉效果选择考虑了这些类别，那么其触觉用户体验对于任何单个设备都应该保持可预测。

触觉原语的使用

Android 包含多个触觉原语，其振幅和频率都各不相同。你可以单独使用一个原语，也可以将多个原语组合起来，以实现丰富的触觉效果。

对于两个原语之间可辨别的间隙，请使用 50 毫秒或更长的延迟，并根据原语持续时间（如果可能）。
使用比例差异至少为 1.4 的比例，这样可以更好地感知强度差异。
使用 0.5、0.7 和 1.0 的比例来创建原语的低、中和高强度版本。

注意： 0.0 的 scale 参数表示最小可感知振动，而不是关闭。

创建自定义振动模式

振动模式通常用于注意触觉，例如通知和铃声。 Vibrator 服务可以播放长时间的振动模式，这些模式会随着时间的推移改变振动幅度。这种效果被称为波形。

波形效果很容易察觉，但如果在安静的环境中播放，突然的长振动可能会让用户感到惊讶。如果太快地斜坡到目标振幅，也可能会产生可听见的嗡嗡声。设计波形模式的建议是使振幅过渡平滑，以创建斜坡上升和下降效果。

示例：斜坡模式

波形表示为 VibrationEffect，具有三个参数

时间：每个波形段的持续时间数组（以毫秒为单位）。
振幅：第一个参数中指定的每个持续时间的所需振动振幅，用 0 到 255 之间的整数值表示，其中 0 表示振动器“关闭”，255 表示设备的最大振幅。
重复索引：第一个参数中指定的数组中的索引，从该索引开始重复波形，或者如果应仅播放一次模式，则为 -1。

这是一个示例波形，它脉冲两次，两次脉冲之间有 350 毫秒的暂停。第一次脉冲是平滑地斜坡到最大振幅，第二次脉冲是快速斜坡以保持最大振幅。负重复索引值定义了结束时的停止。

Kotlin

val timings: LongArray = longArrayOf(50, 50, 50, 50, 50, 100, 350, 25, 25, 25, 25, 200)
val amplitudes: IntArray = intArrayOf(33, 51, 75, 113, 170, 255, 0, 38, 62, 100, 160, 255)
val repeatIndex = -1 // Do not repeat.

vibrator.vibrate(VibrationEffect.createWaveform(timings, amplitudes, repeatIndex))

Java

long[] timings = new long[] { 50, 50, 50, 50, 50, 100, 350, 25, 25, 25, 25, 200 };
int[] amplitudes = new int[] { 33, 51, 75, 113, 170, 255, 0, 38, 62, 100, 160, 255 };
int repeatIndex = -1; // Do not repeat.

vibrator.vibrate(VibrationEffect.createWaveform(timings, amplitudes, repeatIndex));

示例：重复模式

波形也可以重复播放，直到取消。创建重复波形的方法是设置一个非负的“repeat”参数。当你播放重复波形时，振动会一直持续，直到在服务中明确取消。

Kotlin

void startVibrating() {
  val timings: LongArray = longArrayOf(50, 50, 100, 50, 50)
  val amplitudes: IntArray = intArrayOf(64, 128, 255, 128, 64)
  val repeat = 1 // Repeat from the second entry, index = 1.
  VibrationEffect repeatingEffect = VibrationEffect.createWaveform(timings, amplitudes, repeat)
  // repeatingEffect can be used in multiple places.

  vibrator.vibrate(repeatingEffect)
}

void stopVibrating() {
  vibrator.cancel()
}

Java

void startVibrating() {
  long[] timings = new long[] { 50, 50, 100, 50, 50 };
  int[] amplitudes = new int[] { 64, 128, 255, 128, 64 };
  int repeat = 1; // Repeat from the second entry, index = 1.
  VibrationEffect repeatingEffect = VibrationEffect.createWaveform(timings, amplitudes, repeat);
  // repeatingEffect can be used in multiple places.

  vibrator.vibrate(repeatingEffect);
}

void stopVibrating() {
  vibrator.cancel();
}

这对需要用户操作来确认的间歇性事件非常有用。此类事件的示例包括来电和触发警报。

示例：带有回退的模式

控制振动振幅是硬件相关功能。在没有此功能的低端设备上播放波形会导致它在振幅数组中每个正条目处以最大振幅振动。如果你的应用需要适应此类设备，则建议确保你的模式在以这种方式播放时不会产生嗡嗡声，或者设计更简单的 ON/OFF 模式，可以作为回退播放。

Kotlin

if (vibrator.hasAmplitudeControl()) {
  vibrator.vibrate(VibrationEffect.createWaveform(smoothTimings, amplitudes, smoothRepeatIdx))
} else {
  vibrator.vibrate(VibrationEffect.createWaveform(onOffTimings, onOffRepeatIdx))
}

Java

if (vibrator.hasAmplitudeControl()) {
  vibrator.vibrate(VibrationEffect.createWaveform(smoothTimings, amplitudes, smoothRepeatIdx));
} else {
  vibrator.vibrate(VibrationEffect.createWaveform(onOffTimings, onOffRepeatIdx));
}

创建振动组合

本节介绍如何将它们组合成更长、更复杂的自定义效果，并在此基础上探索使用更高级硬件功能的丰富触觉。你可以使用振幅和频率不同的效果组合，在具有更宽频率带宽的触觉执行器的设备上创建更复杂的触觉效果。

用于创建自定义振动模式的过程（在本页面的前面部分介绍）解释了如何控制振动振幅以创建平滑的斜坡上升和下降效果。丰富的触觉在此概念的基础上，探索设备振动器的更宽频率范围，使效果更加平滑。这些波形在创建渐强或渐弱效果方面特别有效。

本页面的前面部分介绍了组合原语，它们由设备制造商实现。它们提供清晰、简短和愉快的振动，符合触觉原则，用于清晰的触觉。有关这些功能及其工作原理的更多详细信息，请参阅振动执行器入门。

Android 不会为包含不支持原语的组合提供回退。我们建议你执行以下步骤

在激活高级触觉之前，请检查给定设备是否支持你使用的所有原语。
禁用不支持的一致体验集，而不仅仅是缺少原语的效果。有关如何检查设备支持的更多信息，如下所示。

你可以使用 VibrationEffect.Composition 创建组合的振动效果。以下是如何创建缓慢上升效果，然后是快速点击效果的示例

Kotlin

vibrator.vibrate(
    VibrationEffect.startComposition().addPrimitive(
      VibrationEffect.Composition.PRIMITIVE_SLOW_RISE
    ).addPrimitive(
      VibrationEffect.Composition.PRIMITIVE_CLICK
    ).compose()
  )

Java

vibrator.vibrate(
    VibrationEffect.startComposition()
        .addPrimitive(VibrationEffect.Composition.PRIMITIVE_SLOW_RISE)
        .addPrimitive(VibrationEffect.Composition.PRIMITIVE_CLICK)
        .compose());

组合是通过将要按顺序播放的原语添加到其中来创建的。每个原语也是可缩放的，因此你可以控制每个原语生成的振动振幅。比例定义为 0 到 1 之间的值，其中 0 实际上映射到原语可以（勉强）被用户感知到的最小振幅。

如果你想创建相同原语的弱和强版本，建议比例差异至少为 1.4，这样可以更容易地感知强度差异。不要尝试创建相同原语的超过三个强度级别，因为它们在感知上没有区别。例如，使用 0.5、0.7 和 1.0 的比例来创建原语的低、中和高强度版本。

组合还可以指定要在连续原语之间添加的延迟。此延迟以毫秒表示，从前一个原语结束时开始计算。通常，两个原语之间的 5 到 10 毫秒间隙太短而无法检测到。如果你想在两个原语之间创建可辨别的间隙，请考虑使用 50 毫秒或更长的间隙。以下是如何创建包含延迟的组合的示例

Kotlin

val delayMs = 100
vibrator.vibrate(
    VibrationEffect.startComposition().addPrimitive(
      VibrationEffect.Composition.PRIMITIVE_SPIN, 0.8f
    ).addPrimitive(
      VibrationEffect.Composition.PRIMITIVE_SPIN, 0.6f
    ).addPrimitive(
      VibrationEffect.Composition.PRIMITIVE_THUD, 1.0f, delayMs
    ).compose()
  )

Java

int delayMs = 100;
vibrator.vibrate(
    VibrationEffect.startComposition()
        .addPrimitive(VibrationEffect.Composition.PRIMITIVE_SPIN, 0.8f)
        .addPrimitive(VibrationEffect.Composition.PRIMITIVE_SPIN, 0.6f)
        .addPrimitive(VibrationEffect.Composition.PRIMITIVE_THUD, 1.0f, delayMs)
        .compose());

以下 API 可用于验证设备对特定原语的支持

Kotlin

val primitive = VibrationEffect.Composition.PRIMITIVE_LOW_TICK

if (vibrator.areAllPrimitivesSupported(primitive)) {
  vibrator.vibrate(VibrationEffect.startComposition().addPrimitive(primitive).compose())
} else {
  // Play a predefined effect or custom pattern as a fallback.
}

Java

int primitive = VibrationEffect.Composition.PRIMITIVE_LOW_TICK;

if (vibrator.areAllPrimitivesSupported(primitive)) {
  vibrator.vibrate(VibrationEffect.startComposition().addPrimitive(primitive).compose());
} else {
  // Play a predefined effect or custom pattern as a fallback.
}

也可以检查多个原语，然后根据设备支持级别决定使用哪些原语进行组合

Kotlin

val effects: IntArray = intArrayOf(
  VibrationEffect.Composition.PRIMITIVE_LOW_TICK,
  VibrationEffect.Composition.PRIMITIVE_TICK,
  VibrationEffect.Composition.PRIMITIVE_CLICK
)
val supported: BooleanArray = vibrator.arePrimitivesSupported(primitives);

Java

int[] primitives = new int[] {
  VibrationEffect.Composition.PRIMITIVE_LOW_TICK,
  VibrationEffect.Composition.PRIMITIVE_TICK,
  VibrationEffect.Composition.PRIMITIVE_CLICK
};
boolean[] supported = vibrator.arePrimitivesSupported(effects);

示例：阻力（带低滴答声）

您可以控制基本振动的幅度，以向正在进行的动作传达有用的反馈。紧密间隔的刻度值可用于创建基本振动的平滑渐强效果。连续基本振动之间的延迟也可以根据用户交互动态设置。以下示例说明了由拖动手势控制并增强触觉的视图动画。

Animation of a circle being dragged down

Kotlin

@Composable
fun ResistScreen() {
  // Control variables for the dragging of the indicator.
  var isDragging by remember { mutableStateOf(false) }
  var dragOffset by remember { mutableStateOf(0f) }

  // Only vibrates while the user is dragging
  if (isDragging) {
    LaunchedEffect(Unit) {
      // Continuously run the effect for vibration to occur even when the view
      // is not being drawn, when user stops dragging midway through gesture.
      while (true) {
        // Calculate the interval inversely proportional to the drag offset.
        val vibrationInterval = calculateVibrationInterval(dragOffset)
        // Calculate the scale directly proportional to the drag offset.
        val vibrationScale = calculateVibrationScale(dragOffset)

        delay(vibrationInterval)
        vibrator.vibrate(
          VibrationEffect.startComposition().addPrimitive(
            VibrationEffect.Composition.PRIMITIVE_LOW_TICK,
            vibrationScale
          ).compose()
        )
      }
    }
  }

  Screen() {
    Column(
      Modifier
        .draggable(
          orientation = Orientation.Vertical,
          onDragStarted = {
            isDragging = true
          },
          onDragStopped = {
            isDragging = false
          },
          state = rememberDraggableState { delta ->
            dragOffset += delta
          }
        )
    ) {
      // Build the indicator UI based on how much the user has dragged it.
      ResistIndicator(dragOffset)
    }
  }
}

Java

class DragListener implements View.OnTouchListener {
  // Control variables for the dragging of the indicator.
  private int startY;
  private int vibrationInterval;
  private float vibrationScale;

  @Override
  public boolean onTouch(View view, MotionEvent event) {
    switch (event.getAction()) {
      case MotionEvent.ACTION_DOWN:
        startY = event.getRawY();
        vibrationInterval = calculateVibrationInterval(0);
        vibrationScale = calculateVibrationScale(0);
        startVibration();
        break;
      case MotionEvent.ACTION_MOVE:
        float dragOffset = event.getRawY() - startY;
        // Calculate the interval inversely proportional to the drag offset.
        vibrationInterval = calculateVibrationInterval(dragOffset);
        // Calculate the scale directly proportional to the drag offset.
        vibrationScale = calculateVibrationScale(dragOffset);
        // Build the indicator UI based on how much the user has dragged it.
        updateIndicator(dragOffset);
        break;
      case MotionEvent.ACTION_CANCEL:
      case MotionEvent.ACTION_UP:
        // Only vibrates while the user is dragging
        cancelVibration();
        break;
    }
    return true;
  }

  private void startVibration() {
    vibrator.vibrate(
          VibrationEffect.startComposition()
            .addPrimitive(VibrationEffect.Composition.PRIMITIVE_LOW_TICK, vibrationScale)
            .compose());

    // Continuously run the effect for vibration to occur even when the view
    // is not being drawn, when user stops dragging midway through gesture.
    handler.postDelayed(this::startVibration, vibrationInterval);
  }

  private void cancelVibration() {
    handler.removeCallbacksAndMessages(null);
  }
}

示例：展开（伴随上升和下降）

有两种基本振动可用于提高感知振动强度：PRIMITIVE_QUICK_RISE 和 PRIMITIVE_SLOW_RISE。它们都达到相同的目标，但持续时间不同。只有一个用于下降的基本振动，即 PRIMITIVE_QUICK_FALL。这些基本振动协同工作可以创建强度增加然后逐渐消失的波形段。您可以对齐缩放的基本振动，以防止它们之间出现突然的幅度跳跃，这也有助于延长整个效果的持续时间。从感知上讲，人们总是比下降部分更注意到上升部分，因此使上升部分比下降部分短可以用来将重点转移到下降部分。

以下是如何将这种组合应用于扩展和折叠圆形的示例。上升效果可以增强动画期间的扩展感。上升和下降效果的组合有助于强调动画结束时的折叠。

Kotlin

enum class ExpandShapeState {
    Collapsed,
    Expanded
}

@Composable
fun ExpandScreen() {
  // Control variable for the state of the indicator.
  var currentState by remember { mutableStateOf(ExpandShapeState.Collapsed) }

  // Animation between expanded and collapsed states.
  val transitionData = updateTransitionData(currentState)

  Screen() {
    Column(
      Modifier
        .clickable(
          {
            if (currentState == ExpandShapeState.Collapsed) {
              currentState = ExpandShapeState.Expanded
              vibrator.vibrate(
                VibrationEffect.startComposition().addPrimitive(
                  VibrationEffect.Composition.PRIMITIVE_SLOW_RISE,
                  0.3f
                ).addPrimitive(
                  VibrationEffect.Composition.PRIMITIVE_QUICK_FALL,
                  0.3f
                ).compose()
              )
            } else {
              currentState = ExpandShapeState.Collapsed
              vibrator.vibrate(
                VibrationEffect.startComposition().addPrimitive(
                  VibrationEffect.Composition.PRIMITIVE_SLOW_RISE
                ).compose()
              )
          }
        )
    ) {
      // Build the indicator UI based on the current state.
      ExpandIndicator(transitionData)
    }
  }
}

Java

class ClickListener implements View.OnClickListener {
  private final Animation expandAnimation;
  private final Animation collapseAnimation;
  private boolean isExpanded;

  ClickListener(Context context) {
    expandAnimation = AnimationUtils.loadAnimation(context, R.anim.expand);
    expandAnimation.setAnimationListener(new Animation.AnimationListener() {

      @Override
      public void onAnimationStart(Animation animation) {
        vibrator.vibrate(
          VibrationEffect.startComposition()
            .addPrimitive(VibrationEffect.Composition.PRIMITIVE_SLOW_RISE, 0.3f)
            .addPrimitive(VibrationEffect.Composition.PRIMITIVE_QUICK_FALL, 0.3f)
            .compose());
      }
    });

    collapseAnimation = AnimationUtils.loadAnimation(context, R.anim.collapse);
    collapseAnimation.setAnimationListener(new Animation.AnimationListener() {

      @Override
      public void onAnimationStart(Animation animation) {
        vibrator.vibrate(
          VibrationEffect.startComposition()
            .addPrimitive(VibrationEffect.Composition.PRIMITIVE_SLOW_RISE)
            .compose());
      }
    });
  }

  @Override
  public void onClick(View view) {
    view.startAnimation(isExpanded ? collapseAnimation : expandAnimation);
    isExpanded = !isExpanded;
  }
}

示例：摆动（伴随旋转）

关键触觉原则之一是取悦用户。介绍令人愉快的意想不到的振动效果的一种有趣方式是使用 PRIMITIVE_SPIN。当此基本振动被多次调用时，它最为有效。多个串联的旋转可以产生摇摆和不稳定的效果，可以通过对每个基本振动应用一些随机缩放来进一步增强这种效果。您还可以尝试连续旋转基本振动之间的间隙。两次无间隙旋转（中间间隔 0 毫秒）会产生紧密的旋转感。将旋转间隙从 10 毫秒增加到 50 毫秒会导致更松散的旋转感，并且可以用来匹配视频或动画的持续时间。

我们不建议使用超过 100 毫秒的间隙，因为连续的旋转不再很好地融合，开始感觉像单独的效果。

以下是如何将弹性形状在被拖动下拉并释放后弹回的示例。动画以一对旋转效果增强，这些效果以不同的强度播放，这些强度与弹跳位移成正比。

Kotlin

@Composable
fun WobbleScreen() {
    // Control variables for the dragging and animating state of the elastic.
    var dragDistance by remember { mutableStateOf(0f) }
    var isWobbling by remember { mutableStateOf(false) }
 
    // Use drag distance to create an animated float value behaving like a spring.
    val dragDistanceAnimated by animateFloatAsState(
        targetValue = if (dragDistance > 0f) dragDistance else 0f,
        animationSpec = spring(
            dampingRatio = Spring.DampingRatioHighBouncy,
            stiffness = Spring.StiffnessMedium
        ),
    )
 
    if (isWobbling) {
        LaunchedEffect(Unit) {
            while (true) {
                val displacement = dragDistanceAnimated / MAX_DRAG_DISTANCE
                // Use some sort of minimum displacement so the final few frames
                // of animation don't generate a vibration.
                if (displacement > SPIN_MIN_DISPLACEMENT) {
                    vibrator.vibrate(
                        VibrationEffect.startComposition().addPrimitive(
                            VibrationEffect.Composition.PRIMITIVE_SPIN,
                            nextSpinScale(displacement)
                        ).addPrimitive(
                          VibrationEffect.Composition.PRIMITIVE_SPIN,
                          nextSpinScale(displacement)
                        ).compose()
                    )
                }
                // Delay the next check for a sufficient duration until the current
                // composition finishes. Note that you can use
                // Vibrator.getPrimitiveDurations API to calculcate the delay.
                delay(VIBRATION_DURATION)
            }
        }
    }
 
    Box(
        Modifier
            .fillMaxSize()
            .draggable(
                onDragStopped = {
                    isWobbling = true
                    dragDistance = 0f
                },
                orientation = Orientation.Vertical,
                state = rememberDraggableState { delta ->
                    isWobbling = false
                    dragDistance += delta
                }
            )
    ) {
        // Draw the wobbling shape using the animated spring-like value.
        WobbleShape(dragDistanceAnimated)
    }
}

// Calculate a random scale for each spin to vary the full effect.
fun nextSpinScale(displacement: Float): Float {
  // Generate a random offset in [-0.1,+0.1] to be added to the vibration
  // scale so the spin effects have slightly different values.
  val randomOffset: Float = Random.Default.nextFloat() * 0.2f - 0.1f
  return (displacement + randomOffset).absoluteValue.coerceIn(0f, 1f)
}

Java

class AnimationListener implements DynamicAnimation.OnAnimationUpdateListener {
  private final Random vibrationRandom = new Random(seed);
  private final long lastVibrationUptime;

  @Override
  public void onAnimationUpdate(DynamicAnimation animation, float value, float velocity) {
    // Delay the next check for a sufficient duration until the current
    // composition finishes. Note that you can use
    // Vibrator.getPrimitiveDurations API to calculcate the delay.
    if (SystemClock.uptimeMillis() - lastVibrationUptime < VIBRATION_DURATION) {
      return;
    }

    float displacement = calculateRelativeDisplacement(value);

    // Use some sort of minimum displacement so the final few frames
    // of animation don't generate a vibration.
    if (displacement < SPIN_MIN_DISPLACEMENT) {
      return;
    }

    lastVibrationUptime = SystemClock.uptimeMillis();
    vibrator.vibrate(
      VibrationEffect.startComposition()
        .addPrimitive(VibrationEffect.Composition.PRIMITIVE_SPIN, nextSpinScale(displacement))
        .addPrimitive(VibrationEffect.Composition.PRIMITIVE_SPIN, nextSpinScale(displacement))
        .compose());
  }

  // Calculate a random scale for each spin to vary the full effect.
  float nextSpinScale(float displacement) {
    // Generate a random offset in [-0.1,+0.1] to be added to the vibration
    // scale so the spin effects have slightly different values.
    float randomOffset = vibrationRandom.nextFloat() * 0.2f - 0.1f
    return MathUtils.clamp(displacement + randomOffset, 0f, 1f)
  }
}

示例：弹跳（伴随砰砰声）

振动效果的另一个高级应用是模拟物理交互。 PRIMITIVE_THUD 可以产生强烈而回响的效果，例如可以将其与视频或动画中冲击的视觉效果配对，以增强整体体验。

以下是如何在每次球体从屏幕底部弹起时播放砰砰声效果的简单球体掉落动画示例。

Animation of a dropped ball bouncing off the bottom of the screen

Kotlin

enum class BallPosition {
    Start,
    End
}

@Composable
fun BounceScreen() {
  // Control variable for the state of the ball.
  var ballPosition by remember { mutableStateOf(BallPosition.Start) }
  var bounceCount by remember { mutableStateOf(0) }

  // Animation for the bouncing ball.
  var transitionData = updateTransitionData(ballPosition)
  val collisionData = updateCollisionData(transitionData)

  // Ball is about to contact floor, only vibrating once per collision.
  var hasVibratedForBallContact by remember { mutableStateOf(false) }
  if (collisionData.collisionWithFloor) {
    if (!hasVibratedForBallContact) {
      val vibrationScale = 0.7.pow(bounceCount++).toFloat()
      vibrator.vibrate(
        VibrationEffect.startComposition().addPrimitive(
          VibrationEffect.Composition.PRIMITIVE_THUD,
          vibrationScale
        ).compose()
      )
      hasVibratedForBallContact = true
    }
  } else {
    // Reset for next contact with floor.
    hasVibratedForBallContact = false
  }

  Screen() {
    Box(
      Modifier
        .fillMaxSize()
        .clickable {
          if (transitionData.isAtStart) {
            ballPosition = BallPosition.End
          } else {
            ballPosition = BallPosition.Start
            bounceCount = 0
          }
        },
    ) {
      // Build the ball UI based on the current state.
      BouncingBall(transitionData)
    }
  }
}

Java

class ClickListener implements View.OnClickListener {
  @Override
  public void onClick(View view) {
    view.animate()
      .translationY(targetY)
      .setDuration(3000)
      .setInterpolator(new BounceInterpolator())
      .setUpdateListener(new AnimatorUpdateListener() {

        boolean hasVibratedForBallContact = false;
        int bounceCount = 0;

        @Override
        public void onAnimationUpdate(ValueAnimator animator) {
          boolean valueBeyondThreshold = (float) animator.getAnimatedValue() > 0.98;
          if (valueBeyondThreshold) {
            if (!hasVibratedForBallContact) {
              float vibrationScale = (float) Math.pow(0.7, bounceCount++);
              vibrator.vibrate(
                VibrationEffect.startComposition()
                  .addPrimitive(VibrationEffect.Composition.PRIMITIVE_THUD, vibrationScale)
                  .compose());
              hasVibratedForBallContact = true;
            }
          } else {
            // Reset for next contact with floor.
            hasVibratedForBallContact = false;
          }
        }
      });
  }
}