[ProgressIndicator] Changed drawables to detect system animator duration scale by themselves.

PiperOrigin-RevId: 322193517

Author: pekingme

catalog/java/io/material/catalog/progressindicator/ProgressIndicatorCustomDemoFragment.java

@@ -68,12 +68,15 @@ public void initialize(@NonNull View view) {
 
     indeterminateIndicator.initializeDrawables(
         new IndeterminateDrawable(
+            getContext(),
             indeterminateIndicator.getSpec(),
             new WavyDrawingDelegate(),
             new LinearIndeterminateNonSeamlessAnimatorDelegate(getContext())),
         null);
     determinateIndicator.initializeDrawables(
-        null, new DeterminateDrawable(determinateIndicator.getSpec(), new WavyDrawingDelegate()));
+        null,
+        new DeterminateDrawable(
+            getContext(), determinateIndicator.getSpec(), new WavyDrawingDelegate()));
 
     Slider slider = view.findViewById(R.id.slider);
     Button showButton = view.findViewById(R.id.show_button);

lib/java/com/google/android/material/progressindicator/DeterminateDrawable.java

@@ -16,6 +16,7 @@
 
 package com.google.android.material.progressindicator;
 
+import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Rect;
 import androidx.annotation.NonNull;
@@ -42,12 +43,14 @@ public final class DeterminateDrawable extends DrawableWithAnimatedVisibilityCha
   private final SpringAnimation springAnimator;
   // Fraction of displayed indicator in the total width.
   private float indicatorFraction;
-  // Whether to skip the next level change event.
-  private boolean skipNextLevelChange = false;
+  // Whether to skip the spring animation on level change event.
+  private boolean skipAnimationOnLevelChange = false;
 
   public DeterminateDrawable(
-      @NonNull ProgressIndicatorSpec spec, @NonNull DrawingDelegate drawingDelegate) {
-    super(spec);
+      @NonNull Context context,
+      @NonNull ProgressIndicatorSpec spec,
+      @NonNull DrawingDelegate drawingDelegate) {
+    super(context, spec);
 
     this.drawingDelegate = drawingDelegate;
 
@@ -69,21 +72,6 @@ public void onAnimationUpdate(DynamicAnimation animation,
     setGrowFraction(1f);
   }
 
-  /**
-   * Invalidates the spring animation's duration by changing the stiffness of {@link SpringForce}.
-   * Negative scale is invalid. 0 is handled as a special case in {@link ProgressIndicator}, which
-   * will skip the animation when the level changes.
-   *
-   * @param scale New scale of the animator's duration.
-   * @throws IllegalArgumentException if scale is negative or zero.
-   */
-  void invalidateAnimationScale(float scale) {
-    if (scale <= 0) {
-      throw new IllegalArgumentException("Animation duration scale must be positive.");
-    }
-    springForce.setStiffness(SPRING_FORCE_STIFFNESS / scale);
-  }
-
   /**
    * Sets the drawable level with a fraction [0,1] of the progress. Note: this function is not used
    * to force updating the level in opposite to the automatic level updates by framework {@link
@@ -95,13 +83,35 @@ void setLevelByFraction(float fraction) {
     setLevel((int) (MAX_DRAWABLE_LEVEL * fraction));
   }
 
-  /** Sets the flag so that when the level is changed next time, it will skip the animation. */
-  void skipNextLevelChange() {
-    skipNextLevelChange = true;
-  }
-
   // ******************* Overridden methods *******************
 
+  /**
+   * Sets the visibility of this drawable. It calls the {@link
+   * DrawableWithAnimatedVisibilityChange#setVisible(boolean, boolean)} to start the show/hide
+   * animation properly. The spring animation will be skipped when the level changes, if animation
+   * is not requested.
+   *
+   * @param visible Whether to make the drawable visible.
+   * @param animationDesired Whether to change the visibility with animation.
+   * @return {@code true}, if the visibility changes or will change after the animation; {@code
+   *     false}, otherwise.
+   */
+  @Override
+  public boolean setVisible(boolean visible, boolean animationDesired) {
+    boolean changed = super.setVisible(visible, animationDesired);
+
+    float systemAnimatorDurationScale =
+        animatorDurationScaleProvider.getSystemAnimatorDurationScale(context.getContentResolver());
+    if (systemAnimatorDurationScale == 0) {
+      skipAnimationOnLevelChange = true;
+    } else {
+      skipAnimationOnLevelChange = false;
+      springForce.setStiffness(SPRING_FORCE_STIFFNESS / systemAnimatorDurationScale);
+    }
+
+    return changed;
+  }
+
   /** Skips the animation of changing indicator length, directly displays the target progress. */
   @Override
   public void jumpToCurrentState() {
@@ -119,11 +129,9 @@ public void jumpToCurrentState() {
    */
   @Override
   protected boolean onLevelChange(int level) {
-    if (skipNextLevelChange) {
+    if (skipAnimationOnLevelChange) {
       springAnimator.cancel();
       setIndicatorFraction((float) level / MAX_DRAWABLE_LEVEL);
-      // One time usage.
-      skipNextLevelChange = false;
     } else {
       springAnimator.setStartValue(getIndicatorFraction() * MAX_DRAWABLE_LEVEL);
       springAnimator.animateToFinalPosition(level);

lib/java/com/google/android/material/progressindicator/DrawableWithAnimatedVisibilityChange.java

@@ -19,6 +19,7 @@
 import android.animation.AnimatorListenerAdapter;
 import android.animation.ObjectAnimator;
 import android.animation.ValueAnimator;
+import android.content.Context;
 import android.graphics.ColorFilter;
 import android.graphics.Paint;
 import android.graphics.PixelFormat;
@@ -44,8 +45,12 @@ abstract class DrawableWithAnimatedVisibilityChange extends Drawable implements
   // Animation duration for both show and hide animators.
   private static final int GROW_DURATION = 500;
 
+  // The current context this drawable is running in.
+  final Context context;
   // The spec of the component being served.
   final ProgressIndicatorSpec spec;
+  // Utils class.
+  AnimatorDurationScaleProvider animatorDurationScaleProvider;
 
   // ValueAnimator used for show animation.
   private ValueAnimator showAnimator;
@@ -67,8 +72,11 @@ abstract class DrawableWithAnimatedVisibilityChange extends Drawable implements
 
   // ******************* Constructor *******************
 
-  DrawableWithAnimatedVisibilityChange(@NonNull ProgressIndicatorSpec spec) {
+  DrawableWithAnimatedVisibilityChange(
+      @NonNull Context context, @NonNull ProgressIndicatorSpec spec) {
+    this.context = context;
     this.spec = spec;
+    animatorDurationScaleProvider = new AnimatorDurationScaleProvider();
 
     setAlpha(255);
 
@@ -187,6 +195,10 @@ public boolean isRunning() {
    */
   @Override
   public boolean setVisible(boolean visible, boolean animationDesired) {
+    float systemAnimatorDurationScale =
+        animatorDurationScaleProvider.getSystemAnimatorDurationScale(context.getContentResolver());
+    animationDesired &= systemAnimatorDurationScale > 0;
+
     // If the drawable is visible and not being hidden, prevents to start the show animation.
     if (visible && animationDesired && isVisible() && !hideAnimator.isRunning()) {
       return false;

lib/java/com/google/android/material/progressindicator/IndeterminateDrawable.java

@@ -18,6 +18,7 @@
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.AnimatorSet;
+import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Rect;
 import androidx.annotation.NonNull;
@@ -34,10 +35,11 @@ public final class IndeterminateDrawable extends DrawableWithAnimatedVisibilityC
   private IndeterminateAnimatorDelegate<AnimatorSet> animatorDelegate;
 
   public IndeterminateDrawable(
+      @NonNull Context context,
       @NonNull ProgressIndicatorSpec spec,
       @NonNull DrawingDelegate drawingDelegate,
       @NonNull IndeterminateAnimatorDelegate<AnimatorSet> animatorDelegate) {
-    super(spec);
+    super(context, spec);
 
     this.drawingDelegate = drawingDelegate;
     setAnimatorDelegate(animatorDelegate);
@@ -48,12 +50,12 @@ public IndeterminateDrawable(
   /**
    * Sets the visibility of this drawable. It calls the {@link
    * DrawableWithAnimatedVisibilityChange#setVisible(boolean, boolean)} to start the show/hide
-   * animation properly. If it's requested to be visible, the main animator will be started. If it's
-   * required to be invisible, the main animator will be canceled unless the hide animation is
-   * required.
+   * animation properly. The indeterminate animation will be started if animation is requested.
    *
    * @param visible Whether to make the drawable visible.
    * @param animationDesired Whether to change the visibility with animation.
+   * @return {@code true}, if the visibility changes or will change after the animation; {@code
+   *     false}, otherwise.
    */
   @Override
   public boolean setVisible(boolean visible, boolean animationDesired) {
@@ -65,7 +67,11 @@ public boolean setVisible(boolean visible, boolean animationDesired) {
       animatorDelegate.resetPropertiesForNewStart();
     }
     // Restarts the main animator if it's visible and needs to be animated.
-    if (visible && animationDesired) {
+    if (visible
+        && animationDesired
+        && animatorDurationScaleProvider.getSystemAnimatorDurationScale(
+                context.getContentResolver())
+            != 0) {
       animatorDelegate.startAnimator();
     }
 

lib/java/com/google/android/material/progressindicator/ProgressIndicator.java

@@ -121,9 +121,6 @@ public class ProgressIndicator extends ProgressBar {
 
   private long lastShowStartTime = -1L;
 
-  /** The scale of the animation speed combining system setting and debug parameters. */
-  private float systemAnimationScale = 1f;
-
   private AnimatorDurationScaleProvider animatorDurationScaleProvider;
 
   // ******************** Interfaces **********************
@@ -270,14 +267,15 @@ private void initializeDrawables() {
           isLinearSeamless()
               ? new LinearIndeterminateSeamlessAnimatorDelegate()
               : new LinearIndeterminateNonSeamlessAnimatorDelegate(getContext());
-      setIndeterminateDrawable(new IndeterminateDrawable(spec, drawingDelegate, animatorDelegate));
-      setProgressDrawable(new DeterminateDrawable(spec, drawingDelegate));
+      setIndeterminateDrawable(
+          new IndeterminateDrawable(getContext(), spec, drawingDelegate, animatorDelegate));
+      setProgressDrawable(new DeterminateDrawable(getContext(), spec, drawingDelegate));
     } else {
       DrawingDelegate drawingDelegate = new CircularDrawingDelegate();
       setIndeterminateDrawable(
           new IndeterminateDrawable(
-              spec, drawingDelegate, new CircularIndeterminateAnimatorDelegate()));
-      setProgressDrawable(new DeterminateDrawable(spec, drawingDelegate));
+              getContext(), spec, drawingDelegate, new CircularIndeterminateAnimatorDelegate()));
+      setProgressDrawable(new DeterminateDrawable(getContext(), spec, drawingDelegate));
     }
 
     applyNewVisibility();
@@ -343,17 +341,6 @@ private void unregisterAnimationCallbacks() {
     }
   }
 
-  private void updateAnimationScale() {
-    systemAnimationScale =
-        animatorDurationScaleProvider.getSystemAnimatorDurationScale(
-            getContext().getContentResolver());
-    if (systemAnimationScale > 0) {
-      if (getProgressDrawable() != null) {
-        getProgressDrawable().invalidateAnimationScale(systemAnimationScale);
-      }
-    }
-  }
-
   // ******************** Visibility control **********************
 
   /**
@@ -394,13 +381,12 @@ public void hide() {
    */
   private void internalHide() {
     // Hides animation should be used if it's visible to user and potentially can be hidden with
-    // animation, unless animators are disabled actively.
-    boolean shouldHideAnimated =
-        visibleToUser() && spec.growMode != GROW_MODE_NONE && !isAnimatorDisabled();
+    // animation.
+    boolean shouldHideAnimated = visibleToUser() && spec.growMode != GROW_MODE_NONE;
 
     getCurrentDrawable().setVisible(false, shouldHideAnimated);
 
-    if (!shouldHideAnimated) {
+    if (isNoLongerNeedToBeVisible()) {
       setVisibility(INVISIBLE);
     }
   }
@@ -426,14 +412,12 @@ private void applyNewVisibility() {
       return;
     }
 
-    updateAnimationScale();
-
     boolean visibleToUser = visibleToUser();
 
     // Sets the drawable to visible/invisible if the component is currently visible/invisible. Only
     // show animation should be started (when the component is currently visible). Hide animation
     // should have already ended or is not necessary at this point.
-    getCurrentDrawable().setVisible(visibleToUser, visibleToUser && !isAnimatorDisabled());
+    getCurrentDrawable().setVisible(visibleToUser, visibleToUser);
   }
 
   @Override
@@ -550,14 +534,17 @@ public DrawingDelegate getCurrentDrawingDelegate() {
    */
   @Override
   public void setProgressDrawable(Drawable drawable) {
-    if (drawable == null || drawable instanceof DeterminateDrawable) {
+    if (drawable == null) {
+      super.setProgressDrawable(null);
+      return;
+    }
+    if (drawable instanceof DeterminateDrawable) {
+      drawable.setVisible(false, false);
       super.setProgressDrawable(drawable);
       // Every time ProgressBar sets progress drawable, it refreshes the drawable's level with
       // progress then secondary progress. Since secondary progress is not used here. We need to set
       // the level actively to overcome the affects from secondary progress.
-      if (drawable != null) {
-        ((DeterminateDrawable) drawable).setLevelByFraction((float) getProgress() / getMax());
-      }
+      ((DeterminateDrawable) drawable).setLevelByFraction((float) getProgress() / getMax());
     } else {
       throw new IllegalArgumentException("Cannot set framework drawable as progress drawable.");
     }
@@ -570,7 +557,12 @@ public void setProgressDrawable(Drawable drawable) {
    */
   @Override
   public void setIndeterminateDrawable(Drawable drawable) {
-    if (drawable == null || drawable instanceof IndeterminateDrawable) {
+    if (drawable == null) {
+      super.setIndeterminateDrawable(null);
+      return;
+    }
+    if (drawable instanceof IndeterminateDrawable) {
+      drawable.setVisible(false, false);
       super.setIndeterminateDrawable(drawable);
     } else {
       throw new IllegalArgumentException(
@@ -644,9 +636,13 @@ private void updateColorsInDrawables() {
     getIndeterminateDrawable().getAnimatorDelegate().invalidateSpecValues();
   }
 
-  /** Returns whether the animators are disabled passively (by system settings). */
-  private boolean isAnimatorDisabled() {
-    return systemAnimationScale == 0;
+  /**
+   * Returns {@code true} if both drawables are either null or not visible; {@code false},
+   * otherwise.
+   */
+  private boolean isNoLongerNeedToBeVisible() {
+    return (getProgressDrawable() == null || !getProgressDrawable().isVisible())
+        && (getIndeterminateDrawable() == null || !getIndeterminateDrawable().isVisible());
   }
 
   // ******************** Getters and setters **********************
@@ -991,33 +987,35 @@ public void setProgressCompat(int progress, boolean animated) {
       storedProgress = progress;
       storedProgressAnimated = animated;
 
-      updateAnimationScale();
-
-      if (isAnimatorDisabled()) {
+      if (animatorDurationScaleProvider.getSystemAnimatorDurationScale(
+              getContext().getContentResolver())
+          == 0) {
         switchIndeterminateModeCallback.onAnimationEnd(getIndeterminateDrawable());
       } else {
         getIndeterminateDrawable().getAnimatorDelegate().requestCancelAnimatorAfterCurrentCycle();
       }
       return;
     }
 
-    // When no progress animation is needed, it will notify the drawable to skip animation on the
-    // next level change.
-    if (getProgressDrawable() != null
-        && getProgress() != progress
-        && (!animated || isAnimatorDisabled())) {
-      getProgressDrawable().skipNextLevelChange();
-    }
-
     // Calls ProgressBar setProgress(int) to update the progress value and level. We don't rely on
     // it to draw or animate the indicator.
     super.setProgress(progress);
+    // Fast forward to the final state of the determinate animation.
+    if (getProgressDrawable() != null && !animated) {
+      getProgressDrawable().jumpToCurrentState();
+    }
   }
 
   @VisibleForTesting
   public void setAnimatorDurationScaleProvider(
       @NonNull AnimatorDurationScaleProvider animatorDurationScaleProvider) {
     this.animatorDurationScaleProvider = animatorDurationScaleProvider;
+    if (getProgressDrawable() != null) {
+      getProgressDrawable().animatorDurationScaleProvider = animatorDurationScaleProvider;
+    }
+    if (getIndeterminateDrawable() != null) {
+      getIndeterminateDrawable().animatorDurationScaleProvider = animatorDurationScaleProvider;
+    }
   }
 
   // ************************ In-place defined parameters ****************************