[NavigationView] Updated NavigationView to use ViewOutlineProvider to handle corner clipping when possible and remove drawerLayoutCornerClippingEnabled attribute.

PiperOrigin-RevId: 527633449

Author: hunterstich

docs/components/NavigationDrawer.md

@@ -254,16 +254,14 @@ subtitles, and an optional scrim.
 
 ### Container attributes
 
-Element                 | Attribute(s)                                                        | Related method(s)                                                                | Default value
------------------------ |---------------------------------------------------------------------|----------------------------------------------------------------------------------| -------------
-**Color**               | `android:background`                                                | `setBackground`<br>`getBackground`                                               | `?attr/colorSurface`
-**Shape**               | `app:shapeAppearance`<br>`app:shapeAppearanceOverlay`               | N/A                                                                              | `null`
-**Elevation**           | `app:elevation` (can be used on `NavigationView` or `DrawerLayout`) | `setElevation`<br>`getElevation`                                                 | `0dp` (`NavigationView`) or `1dp` (`DrawerLayout`)
-**Max width**           | `android:maxWidth`                                                  | N/A                                                                              | `280dp`
-**Fits system windows** | `android:fitsSystemWindows`                                         | `setFitsSystemWindows`<br>`getFitsSystemWindows`                                 | `true`
-**Drawer corner size** | `drawerLayoutCornerSize`                                            | N/A                                                                              |  `16dp`
-**Drawer corner clipping** | `drawerLayoutCornerClippingEnabled`                                 | `setDrawerLayoutCornerClippingEnabled`<br/>`isDrawerLayoutCornerClippingEnabled` | `false`
-
+Element                 | Attribute(s)                                                        | Related method(s)                                | Default value
+----------------------- | ------------------------------------------------------------------- | ------------------------------------------------ | -------------
+**Color**               | `android:background`                                                | `setBackground`<br>`getBackground`               | `?attr/colorSurface`
+**Shape**               | `app:shapeAppearance`<br>`app:shapeAppearanceOverlay`               | N/A                                              | `null`
+**Elevation**           | `app:elevation` (can be used on `NavigationView` or `DrawerLayout`) | `setElevation`<br>`getElevation`                 | `0dp` (`NavigationView`) or `1dp` (`DrawerLayout`)
+**Max width**           | `android:maxWidth`                                                  | N/A                                              | `280dp`
+**Fits system windows** | `android:fitsSystemWindows`                                         | `setFitsSystemWindows`<br>`getFitsSystemWindows` | `true`
+**Drawer corner size**  | `drawerLayoutCornerSize`                                            | N/A                                              |  `16dp`
 
 ### Header attributes
 

lib/java/com/google/android/material/carousel/MaskableFrameLayout.java

@@ -19,32 +19,23 @@
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.graphics.Canvas;
-import android.graphics.Outline;
-import android.graphics.Path;
-import android.graphics.Rect;
 import android.graphics.RectF;
-import android.os.Build.VERSION;
-import android.os.Build.VERSION_CODES;
 import android.util.AttributeSet;
 import android.view.MotionEvent;
 import android.view.View;
-import android.view.ViewOutlineProvider;
 import android.widget.FrameLayout;
-import androidx.annotation.DoNotInline;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
-import androidx.annotation.RequiresApi;
 import androidx.annotation.RestrictTo;
 import androidx.annotation.RestrictTo.Scope;
 import androidx.annotation.VisibleForTesting;
 import androidx.core.math.MathUtils;
 import com.google.android.material.animation.AnimationUtils;
-import com.google.android.material.canvas.CanvasCompat.CanvasOperation;
 import com.google.android.material.shape.AbsoluteCornerSize;
 import com.google.android.material.shape.ClampedCornerSize;
 import com.google.android.material.shape.ShapeAppearanceModel;
-import com.google.android.material.shape.ShapeAppearancePathProvider;
 import com.google.android.material.shape.Shapeable;
+import com.google.android.material.shape.ShapeableDelegate;
 
 /** A {@link FrameLayout} than is able to mask itself and all children. */
 public class MaskableFrameLayout extends FrameLayout implements Maskable, Shapeable {
@@ -53,7 +44,7 @@ public class MaskableFrameLayout extends FrameLayout implements Maskable, Shapea
   private final RectF maskRect = new RectF();
   @Nullable private OnMaskChangedListener onMaskChangedListener;
   @NonNull private ShapeAppearanceModel shapeAppearanceModel;
-  private final MaskableDelegate maskableDelegate = createMaskableDelegate();
+  private final ShapeableDelegate shapeableDelegate = ShapeableDelegate.create(this);
   @Nullable private Boolean savedForceCompatClippingEnabled = null;
 
   public MaskableFrameLayout(@NonNull Context context) {
@@ -71,16 +62,6 @@ public MaskableFrameLayout(
         ShapeAppearanceModel.builder(context, attrs, defStyleAttr, 0, 0).build());
   }
 
-  private MaskableDelegate createMaskableDelegate() {
-    if (VERSION.SDK_INT >= VERSION_CODES.TIRAMISU) {
-      return new MaskableDelegateV33(this);
-    } else if (VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP_MR1) {
-      return new MaskableDelegateV22(this);
-    } else {
-      return new MaskableDelegateV14();
-    }
-  }
-
   @Override
   protected void onSizeChanged(int w, int h, int oldw, int oldh) {
     super.onSizeChanged(w, h, oldw, oldh);
@@ -92,16 +73,16 @@ protected void onAttachedToWindow() {
     super.onAttachedToWindow();
     // Restore any saved force compat clipping setting.
     if (savedForceCompatClippingEnabled != null) {
-      maskableDelegate.setForceCompatClippingEnabled(this, savedForceCompatClippingEnabled);
+      shapeableDelegate.setForceCompatClippingEnabled(this, savedForceCompatClippingEnabled);
     }
   }
 
   @Override
   protected void onDetachedFromWindow() {
     // When detaching from the window, force canvas clipping to avoid any transitions from releasing
     // the mask outline set by the MaskableDelegate's ViewOutlineProvider, if any.
-    savedForceCompatClippingEnabled = maskableDelegate.isForceCompatClippingEnabled();
-    maskableDelegate.setForceCompatClippingEnabled(this, true);
+    savedForceCompatClippingEnabled = shapeableDelegate.isForceCompatClippingEnabled();
+    shapeableDelegate.setForceCompatClippingEnabled(this, true);
     super.onDetachedFromWindow();
   }
 
@@ -120,7 +101,7 @@ public void setShapeAppearanceModel(@NonNull ShapeAppearanceModel shapeAppearanc
                 return cornerSize;
               }
             });
-    maskableDelegate.onShapeAppearanceChanged(this, this.shapeAppearanceModel);
+    shapeableDelegate.onShapeAppearanceChanged(this, this.shapeAppearanceModel);
   }
 
   @NonNull
@@ -173,7 +154,7 @@ private void onMaskChanged() {
     // masked away.
     float maskWidth = AnimationUtils.lerp(0f, getWidth() / 2F, 0f, 1f, maskXPercentage);
     maskRect.set(maskWidth, 0F, (getWidth() - maskWidth), getHeight());
-    maskableDelegate.onMaskChanged(this, maskRect);
+    shapeableDelegate.onMaskChanged(this, maskRect);
     if (onMaskChangedListener != null) {
       onMaskChangedListener.onMaskChanged(maskRect);
     }
@@ -187,7 +168,7 @@ private void onMaskChanged() {
   @VisibleForTesting
   @RestrictTo(Scope.LIBRARY_GROUP)
   public void setForceCompatClipping(boolean forceCompatClipping) {
-    maskableDelegate.setForceCompatClippingEnabled(this, forceCompatClipping);
+    shapeableDelegate.setForceCompatClippingEnabled(this, forceCompatClipping);
   }
 
   @SuppressLint("ClickableViewAccessibility")
@@ -206,228 +187,6 @@ public boolean onTouchEvent(MotionEvent event) {
 
   @Override
   protected void dispatchDraw(Canvas canvas) {
-    maskableDelegate.maybeClip(canvas, super::dispatchDraw);
-  }
-
-  /**
-   * A delegate able to handle logic for when and how to mask a View based on the View's {@link
-   * ShapeAppearanceModel} and mask bounds.
-   */
-  private abstract static class MaskableDelegate {
-
-    boolean forceCompatClippingEnabled = false;
-    @Nullable ShapeAppearanceModel shapeAppearanceModel;
-    RectF maskBounds = new RectF();
-    final Path shapePath = new Path();
-
-    /**
-     * Called due to changes in a delegate's shape, mask bounds or other parameters. Delegate
-     * implementations should use this as an opportunity to ensure their method of clipping is
-     * appropriate and invalidate the client view if necessary.
-     *
-     * @param view the client view
-     */
-    abstract void invalidateClippingMethod(View view);
-
-    /**
-     * Whether the client view should use canvas clipping to mask itself.
-     *
-     * <p>Note: It's important that no significant logic is run in this method as it is called from
-     * dispatch draw, which should be as performant as possible. Logic for determining whether
-     * compat clipping is used should be run elsewhere and stored for quick access.
-     *
-     * @return true if the client view should clip the canvas
-     */
-    abstract boolean shouldUseCompatClipping();
-
-    boolean isForceCompatClippingEnabled() {
-      return forceCompatClippingEnabled;
-    }
-
-    /**
-     * Set whether the client would like to always use compat clipping regardless of whether other
-     * means are available.
-     *
-     * @param view the client view
-     * @param enabled true if the client should always use canvas clipping
-     */
-    void setForceCompatClippingEnabled(View view, boolean enabled) {
-      if (enabled != this.forceCompatClippingEnabled) {
-        this.forceCompatClippingEnabled = enabled;
-        invalidateClippingMethod(view);
-      }
-    }
-
-    /**
-     * Called whenever the {@link ShapeAppearanceModel} of the client changes.
-     *
-     * @param view the client view
-     * @param shapeAppearanceModel the update {@link ShapeAppearanceModel}
-     */
-    void onShapeAppearanceChanged(View view, @NonNull ShapeAppearanceModel shapeAppearanceModel) {
-      this.shapeAppearanceModel = shapeAppearanceModel;
-      updateShapePath();
-      invalidateClippingMethod(view);
-    }
-
-    /**
-     * Called whenever the bounds of the clients mask changes.
-     *
-     * @param view the client view
-     * @param maskBounds the updated bounds
-     */
-    void onMaskChanged(View view, RectF maskBounds) {
-      this.maskBounds = maskBounds;
-      updateShapePath();
-      invalidateClippingMethod(view);
-    }
-
-    private void updateShapePath() {
-      if (!maskBounds.isEmpty() && shapeAppearanceModel != null) {
-        ShapeAppearancePathProvider.getInstance()
-            .calculatePath(shapeAppearanceModel, 1F, maskBounds, shapePath);
-      }
-    }
-
-    void maybeClip(Canvas canvas, CanvasOperation op) {
-      if (shouldUseCompatClipping() && !shapePath.isEmpty()) {
-        canvas.save();
-        canvas.clipPath(shapePath);
-        op.run(canvas);
-        canvas.restore();
-      } else {
-        op.run(canvas);
-      }
-    }
-  }
-
-  /**
-   * A {@link MaskableDelegate} implementation for API 14-21 that always clips using canvas
-   * clipping.
-   */
-  private static class MaskableDelegateV14 extends MaskableDelegate {
-
-    @Override
-    boolean shouldUseCompatClipping() {
-      return true;
-    }
-
-    @Override
-    void invalidateClippingMethod(View view) {
-      if (shapeAppearanceModel == null || maskBounds.isEmpty()) {
-        return;
-      }
-
-      if (shouldUseCompatClipping()) {
-        view.invalidate();
-      }
-    }
-  }
-
-  /**
-   * A {@link MaskableDelegate} for API 22-32 that uses {@link ViewOutlineProvider} to clip when the
-   * shape being clipped is a round rect with symmetrical corners and canvas clipping for all other
-   * shapes. This way is not used for API 21 because outline invalidation is incorrectly implemented
-   * in this version.
-   *
-   * <p>{@link Outline#setRoundRect(Rect, float)} is only able to clip to a rectangle with a single
-   * corner radius for all four corners.
-   */
-  @RequiresApi(VERSION_CODES.LOLLIPOP_MR1)
-  private static class MaskableDelegateV22 extends MaskableDelegate {
-
-    private boolean isShapeRoundRect = false;
-
-    MaskableDelegateV22(View view) {
-      initMaskOutlineProvider(view);
-    }
-
-    @Override
-    public boolean shouldUseCompatClipping() {
-      return !isShapeRoundRect || forceCompatClippingEnabled;
-    }
-
-    @Override
-    void invalidateClippingMethod(View view) {
-      updateIsShapeRoundRect();
-      view.setClipToOutline(!shouldUseCompatClipping());
-      if (shouldUseCompatClipping()) {
-        view.invalidate();
-      } else {
-        view.invalidateOutline();
-      }
-    }
-
-    private void updateIsShapeRoundRect() {
-      if (!maskBounds.isEmpty() && shapeAppearanceModel != null) {
-        isShapeRoundRect = shapeAppearanceModel.isRoundRect(maskBounds);
-      }
-    }
-
-    private float getCornerRadiusFromShapeAppearance(
-        @NonNull ShapeAppearanceModel shapeAppearanceModel, @NonNull RectF bounds) {
-      return shapeAppearanceModel.getTopRightCornerSize().getCornerSize(bounds);
-    }
-
-    @DoNotInline
-    private void initMaskOutlineProvider(View view) {
-      view.setOutlineProvider(
-          new ViewOutlineProvider() {
-            @Override
-            public void getOutline(View view, Outline outline) {
-              if (shapeAppearanceModel != null && !maskBounds.isEmpty()) {
-                outline.setRoundRect(
-                    (int) maskBounds.left,
-                    (int) maskBounds.top,
-                    (int) maskBounds.right,
-                    (int) maskBounds.bottom,
-                    getCornerRadiusFromShapeAppearance(shapeAppearanceModel, maskBounds));
-              }
-            }
-          });
-    }
-  }
-
-  /**
-   * A {@link MaskableDelegate} for API 33+ that uses {@link ViewOutlineProvider} to clip for all
-   * shapes.
-   *
-   * <p>{@link Outline#setPath(Path)} was added in API 33 and allows using {@link
-   * ViewOutlineProvider} to clip for all shapes.
-   */
-  @RequiresApi(VERSION_CODES.TIRAMISU)
-  private static class MaskableDelegateV33 extends MaskableDelegate {
-
-    MaskableDelegateV33(View view) {
-      initMaskOutlineProvider(view);
-    }
-
-    @Override
-    public boolean shouldUseCompatClipping() {
-      return forceCompatClippingEnabled;
-    }
-
-    @Override
-    void invalidateClippingMethod(View view) {
-      view.setClipToOutline(!shouldUseCompatClipping());
-      if (shouldUseCompatClipping()) {
-        view.invalidate();
-      } else {
-        view.invalidateOutline();
-      }
-    }
-
-    @DoNotInline
-    private void initMaskOutlineProvider(View view) {
-      view.setOutlineProvider(
-          new ViewOutlineProvider() {
-            @Override
-            public void getOutline(View view, Outline outline) {
-              if (!shapePath.isEmpty()) {
-                outline.setPath(shapePath);
-              }
-            }
-          });
-    }
+    shapeableDelegate.maybeClip(canvas, super::dispatchDraw);
   }
 }