Add warning to ShapePath when an operation is being used in a situation where a compatibility shadow would normally be drawn

PiperOrigin-RevId: 295847026

Author: cketcham

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

@@ -56,6 +56,7 @@
 import androidx.core.graphics.drawable.TintAwareDrawable;
 import androidx.core.util.ObjectsCompat;
 import android.util.AttributeSet;
+import android.util.Log;
 import com.google.android.material.color.MaterialColors;
 import com.google.android.material.elevation.ElevationOverlayProvider;
 import com.google.android.material.shadow.ShadowRenderer;
@@ -64,13 +65,16 @@
 import com.google.android.material.shape.ShapePath.ShadowCompatOperation;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
+import java.util.BitSet;
 
 /**
  * Base drawable class for Material Shapes that handles shadows, elevation, scale and color for a
  * generated path.
  */
 public class MaterialShapeDrawable extends Drawable implements TintAwareDrawable, Shapeable {
 
+  private static final String TAG = MaterialShapeDrawable.class.getSimpleName();
+
   private static final float SHADOW_RADIUS_MULTIPLIER = .75f;
 
   private static final float SHADOW_OFFSET_MULTIPLIER = .25f;
@@ -108,6 +112,7 @@ public class MaterialShapeDrawable extends Drawable implements TintAwareDrawable
   // Inter-method state.
   private final ShadowCompatOperation[] cornerShadowOperation = new ShadowCompatOperation[4];
   private final ShadowCompatOperation[] edgeShadowOperation = new ShadowCompatOperation[4];
+  private final BitSet containsIncompatibleShadowOp = new BitSet(8);
   private boolean pathDirty;
 
   // Pre-allocated objects that are re-used several times during path computation and rendering.
@@ -204,11 +209,13 @@ private MaterialShapeDrawable(@NonNull MaterialShapeDrawableState drawableState)
           @Override
           public void onCornerPathCreated(
               @NonNull ShapePath cornerPath, Matrix transform, int count) {
+            containsIncompatibleShadowOp.set(count, cornerPath.containsIncompatibleShadowOp());
             cornerShadowOperation[count] = cornerPath.createShadowCompatOperation(transform);
           }
 
           @Override
           public void onEdgePathCreated(@NonNull ShapePath edgePath, Matrix transform, int count) {
+            containsIncompatibleShadowOp.set(count + 4, edgePath.containsIncompatibleShadowOp());
             edgeShadowOperation[count] = edgePath.createShadowCompatOperation(transform);
           }
         };
@@ -1067,6 +1074,12 @@ private void prepareCanvasForShadow(@NonNull Canvas canvas) {
    * completely covered by the shape.
    */
   private void drawCompatShadow(@NonNull Canvas canvas) {
+    if (containsIncompatibleShadowOp.cardinality() > 0) {
+      Log.w(
+          TAG,
+          "Compatibility shadow requested but can't be drawn for all operations in this shape.");
+    }
+
     if (drawableState.shadowCompatOffset != 0) {
       canvas.drawPath(path, shadowRenderer.getShadowPaint());
     }

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

@@ -89,6 +89,7 @@ public class ShapePath {
 
   private final List<PathOperation> operations = new ArrayList<>();
   private final List<ShadowCompatOperation> shadowCompatOperations = new ArrayList<>();
+  private boolean containsIncompatibleShadowOp;
 
   public ShapePath() {
     reset(0, 0);
@@ -116,6 +117,7 @@ public void reset(float startX, float startY, float shadowStartAngle, float shad
     setEndShadowAngle((shadowStartAngle + shadowSweepAngle) % 360);
     this.operations.clear();
     this.shadowCompatOperations.clear();
+    this.containsIncompatibleShadowOp = false;
   }
 
   /**
@@ -162,6 +164,8 @@ public void quadToPoint(float controlX, float controlY, float toX, float toY) {
     operation.setEndY(toY);
     operations.add(operation);
 
+    containsIncompatibleShadowOp = true;
+
     setEndX(toX);
     setEndY(toY);
   }
@@ -186,6 +190,8 @@ public void cubicToPoint(
         new PathCubicOperation(controlX1, controlY1, controlX2, controlY2, toX, toY);
     operations.add(operation);
 
+    containsIncompatibleShadowOp = true;
+
     setEndX(toX);
     setEndY(toY);
   }
@@ -270,6 +276,14 @@ private void addShadowCompatOperation(
     setCurrentShadowAngle(endShadowAngle);
   }
 
+  /**
+   * Hint to let {@link MaterialShapeDrawable} know that it won't be rendering the shadow correctly
+   * if it's drawing the compat shadow.
+   */
+  boolean containsIncompatibleShadowOp() {
+    return containsIncompatibleShadowOp;
+  }
+
   /**
    * Create an {@link ArcShadowOperation} to fill in a shadow between the currently drawn shadow and
    * the next shadow angle, if there would be a gap.