[ProgressIndicator] Optimized the allocation during drawing.

PiperOrigin-RevId: 696962725

Author: pekingme

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

@@ -24,7 +24,6 @@
 import static java.lang.Math.toDegrees;
 
 import android.graphics.Canvas;
-import android.graphics.Matrix;
 import android.graphics.Paint;
 import android.graphics.Paint.Cap;
 import android.graphics.Paint.Style;
@@ -68,6 +67,10 @@ final class CircularDrawingDelegate extends DrawingDelegate<CircularProgressIndi
   @FloatRange(from = 0.0f, to = 1.0f)
   private float totalTrackLengthFraction;
 
+  // Pre-allocates objects used in draw().
+  private final RectF arcBounds = new RectF();
+  private final Pair<PathPoint, PathPoint> endPoints = new Pair<>(new PathPoint(), new PathPoint());
+
   /** Instantiates CircularDrawingDelegate with the current spec. */
   CircularDrawingDelegate(@NonNull CircularProgressIndicatorSpec spec) {
     super(spec);
@@ -349,24 +352,24 @@ private void drawArc(
       // Draws the arc without rounded corners.
       float startDegreeWithoutCorners = startDegree + displayedCornerRadiusInDegree;
       float arcDegreeWithoutCorners = arcDegree - displayedCornerRadiusInDegree * 2;
-      Pair<PathPoint, PathPoint> endPoints = new Pair<>(new PathPoint(), new PathPoint());
+      endPoints.first.reset();
+      endPoints.second.reset();
       if (!shouldDrawWavyPath) {
         endPoints.first.rotate(startDegreeWithoutCorners + 90);
         endPoints.first.moveAcross(-adjustedRadius);
         endPoints.second.rotate(startDegreeWithoutCorners + arcDegreeWithoutCorners + 90);
         endPoints.second.moveAcross(-adjustedRadius);
-        RectF arcBound =
-            new RectF(-adjustedRadius, -adjustedRadius, adjustedRadius, adjustedRadius);
-        canvas.drawArc(arcBound, startDegreeWithoutCorners, arcDegreeWithoutCorners, false, paint);
+        arcBounds.set(-adjustedRadius, -adjustedRadius, adjustedRadius, adjustedRadius);
+        canvas.drawArc(arcBounds, startDegreeWithoutCorners, arcDegreeWithoutCorners, false, paint);
       } else {
-        endPoints =
-            getDisplayedPath(
-                activePathMeasure,
-                displayedActivePath,
-                startDegreeWithoutCorners / 360,
-                arcDegreeWithoutCorners / 360,
-                amplitudeFraction,
-                phaseFraction);
+        calculateDisplayedPath(
+            activePathMeasure,
+            displayedActivePath,
+            endPoints,
+            startDegreeWithoutCorners / 360,
+            arcDegreeWithoutCorners / 360,
+            amplitudeFraction,
+            phaseFraction);
         canvas.drawPath(displayedActivePath, paint);
       }
 
@@ -451,7 +454,7 @@ void invalidateCachedPaths() {
           QUARTER_CIRCLE_CONTROL_HANDLE_LENGTH, -1, 1, -QUARTER_CIRCLE_CONTROL_HANDLE_LENGTH, 1, 0);
     }
     // Scales the circle to its radius.
-    Matrix transform = new Matrix();
+    transform.reset();
     transform.setScale(adjustedRadius, adjustedRadius);
     cachedActivePath.transform(transform);
     if (spec.hasWavyEffect(drawingDeterminateIndicator)) {
@@ -515,10 +518,10 @@ private void appendCubicPerHalfCycle(
         anchor2.posVec[1]);
   }
 
-  @NonNull
-  private Pair<PathPoint, PathPoint> getDisplayedPath(
+  private void calculateDisplayedPath(
       @NonNull PathMeasure pathMeasure,
       @NonNull Path displayedPath,
+      @NonNull Pair<PathPoint, PathPoint> endPoints,
       float start,
       float span,
       float amplitudeFraction,
@@ -548,16 +551,17 @@ private Pair<PathPoint, PathPoint> getDisplayedPath(
     float endDistance = (start + span) * pathMeasure.getLength() / 2;
     pathMeasure.getSegment(startDistance, endDistance, displayedPath, true);
     // Gathers the position and tangent of the start and end.
-    PathPoint startPoint = new PathPoint();
+    PathPoint startPoint = endPoints.first;
+    startPoint.reset();
     pathMeasure.getPosTan(startDistance, startPoint.posVec, startPoint.tanVec);
-    PathPoint endPoint = new PathPoint();
+    PathPoint endPoint = endPoints.second;
+    endPoint.reset();
     pathMeasure.getPosTan(endDistance, endPoint.posVec, endPoint.tanVec);
     // Transforms the result path to match the canvas.
-    Matrix transform = new Matrix();
+    transform.reset();
     transform.setRotate(resultRotation);
     startPoint.rotate(resultRotation);
     endPoint.rotate(resultRotation);
     displayedPath.transform(transform);
-    return new Pair<>(startPoint, endPoint);
   }
 }

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

@@ -23,7 +23,6 @@
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Paint.Style;
-import android.graphics.Rect;
 import android.widget.ProgressBar;
 import androidx.annotation.NonNull;
 import androidx.core.math.MathUtils;
@@ -322,8 +321,6 @@ private void maybeStartAmplitudeAnimator(int level) {
 
   @Override
   public void draw(@NonNull Canvas canvas) {
-    Rect clipBounds = new Rect();
-
     if (getBounds().isEmpty() || !isVisible() || !canvas.getClipBounds(clipBounds)) {
       // Escape if bounds are empty, clip bounds are empty, or currently hidden.
       return;

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

@@ -23,6 +23,7 @@
 import android.graphics.ColorFilter;
 import android.graphics.Paint;
 import android.graphics.PixelFormat;
+import android.graphics.Rect;
 import android.graphics.drawable.Drawable;
 import android.util.Property;
 import androidx.annotation.FloatRange;
@@ -83,12 +84,16 @@ abstract class DrawableWithAnimatedVisibilityChange extends Drawable implements
   @IntRange(from = 0, to = 255)
   private int totalAlpha;
 
+  // Pre-allocates objects used in draw().
+  @NonNull Rect clipBounds;
+
   // ******************* Constructor *******************
 
   DrawableWithAnimatedVisibilityChange(
       @NonNull Context context, @NonNull BaseProgressIndicatorSpec baseSpec) {
     this.context = context;
     this.baseSpec = baseSpec;
+    this.clipBounds = new Rect();
     animatorDurationScaleProvider = new AnimatorDurationScaleProvider();
 
     setAlpha(255);

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

@@ -34,6 +34,7 @@
 import androidx.annotation.IntRange;
 import androidx.annotation.NonNull;
 import androidx.annotation.Px;
+import java.util.Arrays;
 
 /** A delegate abstract class for drawing the graphics in different drawable classes. */
 abstract class DrawingDelegate<S extends BaseProgressIndicatorSpec> {
@@ -48,8 +49,12 @@ abstract class DrawingDelegate<S extends BaseProgressIndicatorSpec> {
 
   final PathMeasure activePathMeasure = new PathMeasure(cachedActivePath, /* forceClosed= */ false);
 
+  // Pre-allocates a Matrix to transform this point.
+  final Matrix transform;
+
   public DrawingDelegate(S spec) {
     this.spec = spec;
+    this.transform = new Matrix();
   }
 
   /**
@@ -186,9 +191,12 @@ protected class PathPoint {
     float[] posVec = new float[2];
     // The tangent vector of this point on a path. The length is not guaranteed.
     float[] tanVec = new float[2];
+    // Pre-allocates a Matrix for transform this point.
+    final Matrix transform;
 
     public PathPoint() {
       tanVec[0] = 1;
+      transform = new Matrix();
     }
 
     public PathPoint(PathPoint other) {
@@ -198,6 +206,7 @@ public PathPoint(PathPoint other) {
     public PathPoint(float[] pos, float[] tan) {
       arraycopy(pos, 0, this.posVec, 0, 2);
       arraycopy(tan, 0, this.tanVec, 0, 2);
+      transform = new Matrix();
     }
 
     /** Moves this point by (x, y). */
@@ -239,10 +248,17 @@ void moveAcross(float distance) {
 
     /** Rotates the coordinates by the given degrees around (0, 0). */
     public void rotate(float rotationDegrees) {
-      Matrix transform = new Matrix();
+      transform.reset();
       transform.setRotate(rotationDegrees);
       transform.mapPoints(posVec);
       transform.mapPoints(tanVec);
     }
+
+    public void reset() {
+      Arrays.fill(posVec, 0);
+      Arrays.fill(tanVec, 0);
+      tanVec[0] = 1;
+      transform.reset();
+    }
   }
 }

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

@@ -23,7 +23,6 @@
 import android.animation.ObjectAnimator;
 import android.content.Context;
 import android.graphics.Canvas;
-import android.graphics.Rect;
 import android.graphics.drawable.Drawable;
 import android.os.Build.VERSION;
 import android.os.Build.VERSION_CODES;
@@ -183,8 +182,6 @@ public int getIntrinsicHeight() {
   /** Draws the graphics based on the progress indicator's properties and the animation states. */
   @Override
   public void draw(@NonNull Canvas canvas) {
-    Rect clipBounds = new Rect();
-
     if (getBounds().isEmpty() || !isVisible() || !canvas.getClipBounds(clipBounds)) {
       // Escape if bounds are empty, clip bounds are empty, or currently hidden.
       return;

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

@@ -26,7 +26,6 @@
 
 import android.graphics.Canvas;
 import android.graphics.Color;
-import android.graphics.Matrix;
 import android.graphics.Paint;
 import android.graphics.Paint.Cap;
 import android.graphics.Paint.Style;
@@ -63,6 +62,9 @@ final class LinearDrawingDelegate extends DrawingDelegate<LinearProgressIndicato
   @FloatRange(from = 0.0f, to = 1.0f)
   private float totalTrackLengthFraction;
 
+  // Pre-allocates objects used in draw().
+  Pair<PathPoint, PathPoint> endPoints = new Pair<>(new PathPoint(), new PathPoint());
+
   /** Instantiates LinearDrawingDelegate with the current spec. */
   LinearDrawingDelegate(@NonNull LinearProgressIndicatorSpec spec) {
     super(spec);
@@ -255,7 +257,8 @@ private void drawLine(
       paint.setAntiAlias(true);
       paint.setStrokeWidth(displayedTrackThickness);
 
-      Pair<PathPoint, PathPoint> endPoints = new Pair<>(new PathPoint(), new PathPoint());
+      endPoints.first.reset();
+      endPoints.second.reset();
       endPoints.first.translate(startBlockCenterX + originX, 0);
       endPoints.second.translate(endBlockCenterX + originX, 0);
       if (startBlockCenterX >= endBlockCenterX) {
@@ -280,14 +283,14 @@ private void drawLine(
               paint);
         } else {
           // Draws a portion of the cached wavy path.
-          endPoints =
-              getDisplayedPath(
-                  activePathMeasure,
-                  displayedActivePath,
-                  startBlockCenterX / trackLength,
-                  endBlockCenterX / trackLength,
-                  amplitudeFraction,
-                  phaseFraction);
+          calculateDisplayedPath(
+              activePathMeasure,
+              displayedActivePath,
+              endPoints,
+              startBlockCenterX / trackLength,
+              endBlockCenterX / trackLength,
+              amplitudeFraction,
+              phaseFraction);
           canvas.drawPath(displayedActivePath, paint);
         }
         if (!useStrokeCap && displayedCornerRadius > 0) {
@@ -381,20 +384,20 @@ void invalidateCachedPaths() {
       }
       // Transforms the wavy path from y = -1/2 * cos(PI * x) + 1/2, as calculated above,
       // to y = cos(2 * PI * x / wavelength), as required in spec.
-      Matrix transformMatrix = new Matrix();
-      transformMatrix.setScale(adjustedWavelength / 2, -2);
-      transformMatrix.postTranslate(0, 1);
-      cachedActivePath.transform(transformMatrix);
+      transform.reset();
+      transform.setScale(adjustedWavelength / 2, -2);
+      transform.postTranslate(0, 1);
+      cachedActivePath.transform(transform);
     } else {
       cachedActivePath.lineTo(trackLength, 0);
     }
     activePathMeasure.setPath(cachedActivePath, /* forceNewPath= */ false);
   }
 
-  @NonNull
-  private Pair<PathPoint, PathPoint> getDisplayedPath(
+  private void calculateDisplayedPath(
       @NonNull PathMeasure pathMeasure,
       @NonNull Path displayedPath,
+      @NonNull Pair<PathPoint, PathPoint> endPoints,
       float start,
       float end,
       float amplitudeFraction,
@@ -420,12 +423,14 @@ private Pair<PathPoint, PathPoint> getDisplayedPath(
     float endDistance = end * pathMeasure.getLength();
     pathMeasure.getSegment(startDistance, endDistance, displayedPath, true);
     // Gathers the position and tangent of the start and end.
-    PathPoint startPoint = new PathPoint();
+    PathPoint startPoint = endPoints.first;
+    startPoint.reset();
     pathMeasure.getPosTan(startDistance, startPoint.posVec, startPoint.tanVec);
-    PathPoint endPoint = new PathPoint();
+    PathPoint endPoint = endPoints.second;
+    endPoint.reset();
     pathMeasure.getPosTan(endDistance, endPoint.posVec, endPoint.tanVec);
     // Transforms the result path to match the canvas.
-    Matrix transform = new Matrix();
+    transform.reset();
     transform.setTranslate(resultTranslationX, 0);
     startPoint.translate(resultTranslationX, 0);
     endPoint.translate(resultTranslationX, 0);
@@ -436,6 +441,5 @@ private Pair<PathPoint, PathPoint> getDisplayedPath(
       endPoint.scale(1, scaleY);
     }
     displayedPath.transform(transform);
-    return new Pair<>(startPoint, endPoint);
   }
 }