[ProgressIndicator] Fixed incorrect visibility when Recyclerview is used.

Resolves #1662

PiperOrigin-RevId: 341845553

Author: pekingme

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

@@ -237,35 +237,38 @@ public void hide() {
    * @see #hide()
    */
   private void internalHide() {
-    getCurrentDrawable().setVisible(/*visible=*/ false, /*restart=*/ false);
+    getCurrentDrawable()
+        .setVisible(/*visible=*/ false, /*restart=*/ false, /*animationDesired=*/ true);
 
     if (isNoLongerNeedToBeVisible()) {
       setVisibility(INVISIBLE);
     }
   }
 
   @Override
-  protected void onVisibilityChanged(@NonNull View changeView, int visibility) {
-    super.onVisibilityChanged(changeView, visibility);
-    applyNewVisibility();
+  protected void onVisibilityChanged(@NonNull View changedView, int visibility) {
+    super.onVisibilityChanged(changedView, visibility);
+    applyNewVisibility(/*animationDesired=*/ visibility == VISIBLE);
   }
 
   @Override
   protected void onWindowVisibilityChanged(int visibility) {
     super.onWindowVisibilityChanged(visibility);
-    applyNewVisibility();
+    applyNewVisibility(/*animationDesired=*/ false);
   }
 
   /**
    * If it changes to visible, the start animation will be started if {@code growMode} indicates
    * any. If it changes to invisible, hides the drawable immediately.
+   *
+   * @param animationDesired Whether to change the visibility with animation.
    */
-  protected void applyNewVisibility() {
+  protected void applyNewVisibility(boolean animationDesired) {
     if (!isParentDoneInitializing) {
       return;
     }
 
-    getCurrentDrawable().setVisible(visibleToUser(), /*restart=*/ false);
+    getCurrentDrawable().setVisible(visibleToUser(), /*restart=*/ false, animationDesired);
   }
 
   @Override

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

@@ -102,7 +102,6 @@ private void initializeDrawables() {
     setProgressDrawable(
         new DeterminateDrawable(
             getContext(), baseSpec, behavior, new CircularDrawingDelegate(spec)));
-    applyNewVisibility();
   }
 
   // **************** Getters and setters ****************

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

@@ -98,8 +98,8 @@ void setLevelByFraction(float fraction) {
    *     false}, otherwise.
    */
   @Override
-  public boolean setVisible(boolean visible, boolean restart, boolean animationDesired) {
-    boolean changed = super.setVisible(visible, restart, animationDesired);
+  protected boolean setVisibleInternal(boolean visible, boolean restart, boolean animationDesired) {
+    boolean changed = super.setVisibleInternal(visible, restart, animationDesired);
 
     float systemAnimatorDurationScale =
         animatorDurationScaleProvider.getSystemAnimatorDurationScale(context.getContentResolver());

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

@@ -68,6 +68,8 @@ abstract class DrawableWithAnimatedVisibilityChange extends Drawable implements
   private List<AnimationCallback> animationCallbacks;
   // An internal AnimationCallback which is executed before the user's animation callbacks.
   private AnimationCallback internalAnimationCallback;
+  // Flag to ignore all external callbacks.
+  private boolean ignoreCallbacks;
 
   // A fraction from 0 to 1 indicating the ratio used in drawing, controlled by show/hide animator.
   private float growFraction;
@@ -165,7 +167,7 @@ private void dispatchAnimationStart() {
     if (internalAnimationCallback != null) {
       internalAnimationCallback.onAnimationStart(this);
     }
-    if (animationCallbacks != null) {
+    if (animationCallbacks != null && !ignoreCallbacks) {
       for (AnimationCallback callback : animationCallbacks) {
         callback.onAnimationStart(this);
       }
@@ -177,7 +179,7 @@ private void dispatchAnimationEnd() {
     if (internalAnimationCallback != null) {
       internalAnimationCallback.onAnimationEnd(this);
     }
-    if (animationCallbacks != null) {
+    if (animationCallbacks != null && !ignoreCallbacks) {
       for (AnimationCallback callback : animationCallbacks) {
         callback.onAnimationEnd(this);
       }
@@ -211,48 +213,66 @@ public boolean isHiding() {
     return (hideAnimator != null && hideAnimator.isRunning()) || mockHideAnimationRunning;
   }
 
-  /** Hides the drawable immediately */
-  public boolean hideNow(){
+  /** Hides the drawable immediately without triggering animation callbacks. */
+  public boolean hideNow() {
     return setVisible(/*visible=*/ false, /*restart=*/ false, /*animationDesired=*/ false);
   }
 
+  @Override
+  public boolean setVisible(boolean visible, boolean restart) {
+    return setVisible(visible, restart, /*animationDesired=*/ true);
+  }
+
   /**
-   * Sets the visibility with/without animation based on system animator duration scale.
+   * Changes the visibility with/without triggering the animation callbacks.
    *
+   * @param visible Whether to make the drawable visible.
+   * @param restart Whether to force starting the animation from the beginning.
+   * @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.
    * @see #setVisible(boolean, boolean, boolean)
    */
-  @Override
-  public boolean setVisible(boolean visible, boolean restart) {
+  public boolean setVisible(boolean visible, boolean restart, boolean animationDesired) {
     float systemAnimatorDurationScale =
         animatorDurationScaleProvider.getSystemAnimatorDurationScale(context.getContentResolver());
     // Only show/hide the drawable with animations if system animator duration scale is not off and
     // some grow mode is used.
-    return setVisible(visible, restart, systemAnimatorDurationScale > 0);
+    return setVisibleInternal(
+        visible, restart, animationDesired && systemAnimatorDurationScale > 0);
   }
 
   /**
-   * Show or hide the drawable with/without animation effects.
+   * Show or hide the drawable with/without animation effects and/or animation callbacks.
    *
    * @param visible Whether to make the drawable visible.
    * @param restart Whether to force starting the animation from the beginning.
    * @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.
    */
-  public boolean setVisible(boolean visible, boolean restart, boolean animationDesired) {
+  protected boolean setVisibleInternal(boolean visible, boolean restart, boolean animationDesired) {
+    maybeInitializeAnimators();
     if (!isVisible() && !visible) {
-      // Early return if trying to hide a hidden drawable.
+      // Early returns if trying to hide a hidden drawable.
       return false;
     }
 
-    maybeInitializeAnimators();
+    ValueAnimator animatorInAction = visible ? showAnimator : hideAnimator;
 
-    if (animationDesired && (visible ? showAnimator : hideAnimator).isRunning()) {
-      // Show/hide animation should not be reset while being played.
-      return false;
+    if (!animationDesired) {
+      if (animatorInAction.isRunning()) {
+        // Show/hide animation should fast-forward to the end without callbacks.
+        endAnimatorWithoutCallbacks(animatorInAction);
+      }
+      // Immediately updates the drawable's visibility without animation if not desired.
+      return super.setVisible(visible, DEFAULT_DRAWABLE_RESTART);
     }
 
-    ValueAnimator animationInAction = visible ? showAnimator : hideAnimator;
+    if (animationDesired && animatorInAction.isRunning()) {
+      // Show/hide animation should not be replayed while playing.
+      return false;
+    }
 
     // If requests to show, sets the drawable visible. If requests to hide, the visibility is
     // controlled by the animation listener attached to hide animation.
@@ -262,19 +282,28 @@ public boolean setVisible(boolean visible, boolean restart, boolean animationDes
     if (!animationDesired) {
       // This triggers onAnimationStart() callbacks for showing and onAnimationEnd() callbacks for
       // hiding. It also fast-forwards the animator properties to the end state.
-      animationInAction.end();
+      animatorInAction.end();
       return changed;
     }
 
-    if (restart || VERSION.SDK_INT < 19 || !animationInAction.isPaused()) {
+    if (restart || VERSION.SDK_INT < 19 || !animatorInAction.isPaused()) {
       // Starts/restarts the animator if requested or not eligible to resume.
-      animationInAction.start();
+      animatorInAction.start();
     } else {
-      animationInAction.resume();
+      animatorInAction.resume();
     }
     return changed;
   }
 
+  private void endAnimatorWithoutCallbacks(@NonNull ValueAnimator... animators) {
+    boolean ignoreCallbacksOrig = ignoreCallbacks;
+    ignoreCallbacks = true;
+    for (ValueAnimator animator : animators) {
+      animator.end();
+    }
+    ignoreCallbacks = ignoreCallbacksOrig;
+  }
+
   // ******************* Getters and setters *******************
 
   @Override

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

@@ -20,6 +20,8 @@
 import android.graphics.Canvas;
 import android.graphics.Rect;
 import android.graphics.drawable.Drawable;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
 import androidx.annotation.NonNull;
 
 /**
@@ -59,16 +61,20 @@ public IndeterminateDrawable(
    *     false}, otherwise.
    */
   @Override
-  public boolean setVisible(boolean visible, boolean restart, boolean animationDesired) {
-    boolean changed = super.setVisible(visible, restart, animationDesired);
+  protected boolean setVisibleInternal(boolean visible, boolean restart, boolean animationDesired) {
+    boolean changed = super.setVisibleInternal(visible, restart, animationDesired);
 
     // Unless it's showing or hiding, cancels and resets main animator.
     if (!isRunning()) {
       animatorDelegate.cancelAnimatorImmediately();
       animatorDelegate.resetPropertiesForNewStart();
     }
     // Restarts the main animator if it's visible and needs to be animated.
-    if (visible && animationDesired) {
+    float systemAnimatorDurationScale =
+        animatorDurationScaleProvider.getSystemAnimatorDurationScale(context.getContentResolver());
+    if (visible
+        && (animationDesired
+            || (VERSION.SDK_INT < VERSION_CODES.LOLLIPOP && systemAnimatorDurationScale > 0))) {
       animatorDelegate.startAnimator();
     }
 

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

@@ -135,7 +135,6 @@ private void initializeDrawables() {
                 : new LinearIndeterminateSpacingAnimatorDelegate(getContext(), spec)));
     setProgressDrawable(
         new DeterminateDrawable(getContext(), baseSpec, behavior, new LinearDrawingDelegate(spec)));
-    applyNewVisibility();
   }
 
   // **************** Getters and setters ****************

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

@@ -244,7 +244,6 @@ private void initializeDrawables() {
           new DeterminateDrawable(
               getContext(), baseSpec, behavior, new LinearDrawingDelegate(linearSpec)));
     }
-    applyNewVisibility();
   }
 
   private void registerAnimationCallbacks() {
@@ -334,35 +333,38 @@ public void hide() {
    * @see #hide()
    */
   private void internalHide() {
-    getCurrentDrawable().setVisible(/*visible=*/ false, /*restart=*/ false);
+    getCurrentDrawable()
+        .setVisible(/*visible=*/ false, /*restart=*/ false, /*animationDesired=*/ true);
 
     if (isNoLongerNeedToBeVisible()) {
       setVisibility(INVISIBLE);
     }
   }
 
   @Override
-  protected void onVisibilityChanged(View changeView, int visibility) {
-    super.onVisibilityChanged(changeView, visibility);
-    applyNewVisibility();
+  protected void onVisibilityChanged(@NonNull View changedView, int visibility) {
+    super.onVisibilityChanged(changedView, visibility);
+    applyNewVisibility(/*animationDesired=*/ visibility != GONE);
   }
 
   @Override
   protected void onWindowVisibilityChanged(int visibility) {
     super.onWindowVisibilityChanged(visibility);
-    applyNewVisibility();
+    applyNewVisibility(/*animationDesired=*/ false);
   }
 
   /**
    * If it changes to visible, the start animation will be started if {@code growMode} indicates
    * any. If it changes to invisible, hides the drawable immediately.
+   *
+   * @param animationDesired Whether to change the visibility with animation.
    */
-  private void applyNewVisibility() {
+  private void applyNewVisibility(boolean animationDesired) {
     if (!isParentDoneInitializing) {
       return;
     }
 
-    getCurrentDrawable().setVisible(visibleToUser(), /*restart=*/ false);
+    getCurrentDrawable().setVisible(visibleToUser(), /*restart=*/ false, animationDesired);
   }
 
   @Override