Uncouple CornerSize from CornerTreatment

This allows for more easily updating the CornerSize independently from the CornerTreatment and makes it possible to create different types of CornerSizes such as percentage based corners. However, this means corner sizes can be different depending on the bounds of the shape, so the bounds need to be provided. MaterialShapeDrawable has bounds and the ShapeAppearanceModel, so there are new convenience methods there which return the current corner size for the current bounds of the drawable.

PiperOrigin-RevId: 272908508
(cherry picked from commit 0547d2a)

Author: cketcham

lib/java/com/google/android/material/button/MaterialButtonToggleGroup.java

@@ -36,6 +36,9 @@
 import android.widget.RelativeLayout;
 import com.google.android.material.internal.ThemeEnforcement;
 import com.google.android.material.internal.ViewUtils;
+import com.google.android.material.shape.AbsoluteCornerSize;
+import com.google.android.material.shape.CornerSize;
+import com.google.android.material.shape.ShapeAppearanceModel;
 import java.util.ArrayList;
 import java.util.LinkedHashSet;
 import java.util.List;
@@ -203,10 +206,10 @@ public void addView(View child, int index, ViewGroup.LayoutParams params) {
     ShapeAppearanceModel shapeAppearanceModel = buttonChild.getShapeAppearanceModel();
     originalCornerData.add(
         new CornerData(
-            shapeAppearanceModel.getTopLeftCorner().getCornerSize(),
-            shapeAppearanceModel.getTopRightCorner().getCornerSize(),
-            shapeAppearanceModel.getBottomRightCorner().getCornerSize(),
-            shapeAppearanceModel.getBottomLeftCorner().getCornerSize()));
+            shapeAppearanceModel.getTopLeftCornerSize(),
+            shapeAppearanceModel.getTopRightCornerSize(),
+            shapeAppearanceModel.getBottomRightCornerSize(),
+            shapeAppearanceModel.getBottomLeftCornerSize()));
   }
 
   @Override
@@ -491,19 +494,19 @@ private void updateChildShapes() {
               // Keeps the left corners of the first child in LTR, or the last child in RTL
               shapeAppearanceModelBuilder
                   .setTopLeftCornerSize(cornerData.topLeft)
-                  .setTopRightCornerSize(0)
-                  .setBottomRightCornerSize(0)
+                  .setTopRightCornerSize(new AbsoluteCornerSize(0))
+                  .setBottomRightCornerSize(new AbsoluteCornerSize(0))
                   .setBottomLeftCornerSize(cornerData.bottomLeft);
             } else if (i != 0 && i < numChildren - 1) {
               // Sets corner radii of all middle children to 0
               shapeAppearanceModelBuilder.setCornerRadius(0);
             } else if (i == (ViewUtils.isLayoutRtl(this) ? 0 : (numChildren - 1))) {
               // Keeps the right corners of the last child in LTR, or the first child in RTL
               shapeAppearanceModelBuilder
-                  .setTopLeftCornerSize(0)
+                  .setTopLeftCornerSize(new AbsoluteCornerSize(0))
                   .setTopRightCornerSize(cornerData.topRight)
                   .setBottomRightCornerSize(cornerData.bottomRight)
-                  .setBottomLeftCornerSize(0);
+                  .setBottomLeftCornerSize(new AbsoluteCornerSize(0));
             }
           }
           button.setShapeAppearanceModel(shapeAppearanceModelBuilder.build());
@@ -620,12 +623,13 @@ public void onPressedChanged(@NonNull MaterialButton button, boolean isPressed)
   }
 
   private static class CornerData {
-    final float topLeft;
-    final float topRight;
-    final float bottomRight;
-    final float bottomLeft;
+    final CornerSize topLeft;
+    final CornerSize topRight;
+    final CornerSize bottomRight;
+    final CornerSize bottomLeft;
 
-    CornerData(float topLeft, float topRight, float bottomRight, float bottomLeft) {
+    CornerData(
+        CornerSize topLeft, CornerSize topRight, CornerSize bottomRight, CornerSize bottomLeft) {
       this.topLeft = topLeft;
       this.topRight = topRight;
       this.bottomRight = bottomRight;

lib/java/com/google/android/material/card/MaterialCardViewHelper.java

@@ -280,7 +280,7 @@ void setCornerRadius(float cornerRadius) {
   }
 
   float getCornerRadius() {
-    return shapeAppearanceModel.getTopLeftCorner().getCornerSize();
+    return bgDrawable.getTopLeftCornerResolvedSize();
   }
 
   void setProgress(@FloatRange(from = 0f, to = 1f) float progress) {
@@ -505,7 +505,7 @@ private float calculateHorizontalBackgroundPadding() {
   }
 
   private boolean canClipToOutline() {
-    return VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP && shapeAppearanceModel.isRoundRect();
+    return VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP && bgDrawable.isRoundRect();
   }
 
   private float getParentCardViewCalculatedCornerPadding() {
@@ -537,18 +537,25 @@ && canClipToOutline()
   private float calculateActualCornerPadding() {
     return Math.max(
         Math.max(
-            calculateCornerPaddingForCornerTreatment(shapeAppearanceModel.getTopLeftCorner()),
-            calculateCornerPaddingForCornerTreatment(shapeAppearanceModel.getTopRightCorner())),
+            calculateCornerPaddingForCornerTreatment(
+                shapeAppearanceModel.getTopLeftCorner(), bgDrawable.getTopLeftCornerResolvedSize()),
+            calculateCornerPaddingForCornerTreatment(
+                shapeAppearanceModel.getTopRightCorner(),
+                bgDrawable.getTopRightCornerResolvedSize())),
         Math.max(
-            calculateCornerPaddingForCornerTreatment(shapeAppearanceModel.getBottomRightCorner()),
-            calculateCornerPaddingForCornerTreatment(shapeAppearanceModel.getBottomLeftCorner())));
+            calculateCornerPaddingForCornerTreatment(
+                shapeAppearanceModel.getBottomRightCorner(),
+                bgDrawable.getBottomRightCornerResolvedSize()),
+            calculateCornerPaddingForCornerTreatment(
+                shapeAppearanceModel.getBottomLeftCorner(),
+                bgDrawable.getBottomLeftCornerResolvedSize())));
   }
 
-  private float calculateCornerPaddingForCornerTreatment(CornerTreatment treatment) {
+  private float calculateCornerPaddingForCornerTreatment(CornerTreatment treatment, float size) {
     if (treatment instanceof RoundedCornerTreatment) {
-      return (float) ((1 - COS_45) * treatment.getCornerSize());
+      return (float) ((1 - COS_45) * size);
     } else if (treatment instanceof CutCornerTreatment) {
-      return treatment.getCornerSize() / 2;
+      return size / 2;
     }
     return 0;
   }

lib/java/com/google/android/material/chip/ChipDrawable.java

@@ -1406,9 +1406,7 @@ public void setChipMinHeight(float chipMinHeight) {
    * @attr ref com.google.android.material.R.styleable#Chip_chipCornerRadius
    */
   public float getChipCornerRadius() {
-    return isShapeThemingEnabled
-        ? getShapeAppearanceModel().getTopLeftCorner().getCornerSize()
-        : chipCornerRadius;
+    return isShapeThemingEnabled ? getTopLeftCornerResolvedSize() : chipCornerRadius;
   }
 
   /**

lib/java/com/google/android/material/floatingactionbutton/BorderDrawable.java

@@ -63,6 +63,7 @@ class BorderDrawable extends Drawable {
   private final Path shapePath = new Path();
   private final Rect rect = new Rect();
   private final RectF rectF = new RectF();
+  private final RectF boundsRectF = new RectF();
   private final BorderState state = new BorderState();
 
   @Dimension float borderWidth;
@@ -131,9 +132,10 @@ public void draw(@NonNull Canvas canvas) {
 
     // We need to inset the oval bounds by half the border width. This is because stroke draws
     // the center of the border on the dimension. Whereas we want the stroke on the inside.
-    float cornerSize = shapeAppearanceModel.getTopLeftCorner().getCornerSize();
+    float cornerSize =
+        shapeAppearanceModel.getTopLeftCornerSize().getCornerSize(getBoundsAsRectF());
     float radius = Math.min(cornerSize, rectF.width() / 2f);
-    if (shapeAppearanceModel.isRoundRect()) {
+    if (shapeAppearanceModel.isRoundRect(getBoundsAsRectF())) {
       rectF.inset(halfBorderWidth, halfBorderWidth);
       canvas.drawRoundRect(rectF, radius, radius, paint);
     }
@@ -142,8 +144,8 @@ public void draw(@NonNull Canvas canvas) {
   @TargetApi(VERSION_CODES.LOLLIPOP)
   @Override
   public void getOutline(@NonNull Outline outline) {
-    if (shapeAppearanceModel.isRoundRect()) {
-      float radius = shapeAppearanceModel.getTopLeftCorner().getCornerSize();
+    if (shapeAppearanceModel.isRoundRect(getBoundsAsRectF())) {
+      float radius = shapeAppearanceModel.getTopLeftCornerSize().getCornerSize(getBoundsAsRectF());
       outline.setRoundRect(getBounds(), radius);
       return;
     }
@@ -158,13 +160,19 @@ public void getOutline(@NonNull Outline outline) {
 
   @Override
   public boolean getPadding(@NonNull Rect padding) {
-    if (shapeAppearanceModel.isRoundRect()) {
+    if (shapeAppearanceModel.isRoundRect(getBoundsAsRectF())) {
       final int borderWidth = Math.round(this.borderWidth);
       padding.set(borderWidth, borderWidth, borderWidth, borderWidth);
     }
     return true;
   }
 
+  @NonNull
+  protected RectF getBoundsAsRectF() {
+    boundsRectF.set(getBounds());
+    return boundsRectF;
+  }
+
   public ShapeAppearanceModel getShapeAppearanceModel() {
     return shapeAppearanceModel;
   }

lib/java/com/google/android/material/floatingactionbutton/ExtendedFloatingActionButton.java

@@ -48,6 +48,8 @@
 import com.google.android.material.bottomsheet.BottomSheetBehavior;
 import com.google.android.material.internal.DescendantOffsetUtils;
 import com.google.android.material.internal.ThemeEnforcement;
+import com.google.android.material.shape.MaterialShapeDrawable;
+import com.google.android.material.shape.ShapeAppearanceModel;
 import java.util.List;
 
 /**
@@ -681,10 +683,7 @@ public void set(@NonNull View object, @NonNull Float value) {
 
         @Override
         public Float get(@NonNull View object) {
-          return ((ExtendedFloatingActionButton) object)
-              .getShapeAppearanceModel()
-              .getTopRightCorner()
-              .getCornerSize();
+          return ((MaterialShapeDrawable) object.getBackground()).getTopRightCornerResolvedSize();
         }
       };
 

lib/java/com/google/android/material/floatingactionbutton/FloatingActionButton.java

@@ -76,6 +76,7 @@
 import com.google.android.material.internal.VisibilityAwareImageButton;
 import com.google.android.material.resources.MaterialResources;
 import com.google.android.material.shadow.ShadowViewDelegate;
+import com.google.android.material.shape.AbsoluteCornerSize;
 import com.google.android.material.shape.ShapeAppearanceModel;
 import com.google.android.material.shape.Shapeable;
 import com.google.android.material.stateful.ExtendableSavedState;
@@ -240,7 +241,9 @@ public FloatingActionButton(
     MotionSpec hideMotionSpec =
         MotionSpec.createFromAttribute(context, a, R.styleable.FloatingActionButton_hideMotionSpec);
     ShapeAppearanceModel shapeAppearance =
-        ShapeAppearanceModel.builder(context, attrs, defStyleAttr, DEF_STYLE_RES, -1).build();
+        ShapeAppearanceModel.builder(
+                context, attrs, defStyleAttr, DEF_STYLE_RES, ShapeAppearanceModel.PILL)
+            .build();
 
     boolean usingDefaultCorner = isUsingDefaultCorner(shapeAppearance);
     boolean ensureMinTouchTargetSize = a
@@ -1360,7 +1363,8 @@ public void removeTransformationCallback(
   }
 
   private boolean isUsingDefaultCorner(@NonNull ShapeAppearanceModel shapeAppearance) {
-    return shapeAppearance.getTopRightCorner().getCornerSize() == -1;
+    return ((AbsoluteCornerSize) shapeAppearance.getTopRightCornerSize()).getCornerSize()
+        == ShapeAppearanceModel.PILL;
   }
 
   class TransformationCallbackWrapper<T extends FloatingActionButton>

lib/java/com/google/android/material/shape/AbsoluteCornerSize.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.material.shape;
+
+import android.graphics.RectF;
+import androidx.annotation.NonNull;
+import java.util.Arrays;
+
+/** A {@link CornerSize} that always uses the provided size and ignores the bounds. */
+public final class AbsoluteCornerSize implements CornerSize {
+
+  private final float size;
+
+  public AbsoluteCornerSize(float size) {
+    this.size = size;
+  }
+
+  @Override
+  public float getCornerSize(@NonNull RectF bounds) {
+    return size;
+  }
+
+  /**
+   * Returns the size of this corner. Bounds aren't required since the result is always the same.
+   */
+  public float getCornerSize() {
+    return size;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (!(o instanceof AbsoluteCornerSize)) {
+      return false;
+    }
+    AbsoluteCornerSize that = (AbsoluteCornerSize) o;
+    return size == that.size;
+  }
+
+  @Override
+  public int hashCode() {
+    Object[] hashedFields = {size};
+    return Arrays.hashCode(hashedFields);
+  }
+}

lib/java/com/google/android/material/shape/AdjustedCornerSize.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.material.shape;
+
+import static androidx.annotation.RestrictTo.Scope.LIBRARY_GROUP;
+
+import android.graphics.RectF;
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import java.util.Arrays;
+
+/**
+ * Adjusts another {@link CornerSize} by some amount.
+ *
+ * @hide
+ */
+@RestrictTo(LIBRARY_GROUP)
+public final class AdjustedCornerSize implements CornerSize {
+
+  private final CornerSize other;
+  private final float adjustment;
+
+  public AdjustedCornerSize(float adjustment, @NonNull CornerSize other) {
+    // Rollup other Adjustments into this one
+    while (other instanceof AdjustedCornerSize) {
+      other = ((AdjustedCornerSize) other).other;
+      adjustment += ((AdjustedCornerSize) other).adjustment;
+    }
+
+    this.other = other;
+    this.adjustment = adjustment;
+  }
+
+  @Override
+  public float getCornerSize(@NonNull RectF bounds) {
+    return Math.max(0, other.getCornerSize(bounds) + adjustment);
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (!(o instanceof AdjustedCornerSize)) {
+      return false;
+    }
+    AdjustedCornerSize that = (AdjustedCornerSize) o;
+    return other.equals(that.other) && adjustment == that.adjustment;
+  }
+
+  @Override
+  public int hashCode() {
+    Object[] hashedFields = {other, adjustment};
+    return Arrays.hashCode(hashedFields);
+  }
+}

lib/java/com/google/android/material/shape/CornerSize.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.material.shape;
+
+import android.graphics.RectF;
+import androidx.annotation.NonNull;
+
+/** Allows clients to describe the size of a corner independently from a {@link CornerTreatment}. */
+public interface CornerSize {
+  /** Returns the corner size that should be used given the full bounds of the shape. */
+  float getCornerSize(@NonNull RectF bounds);
+}