package carbon.widget; import android.animation.Animator; import android.animation.AnimatorListenerAdapter; import android.animation.ValueAnimator; import android.annotation.SuppressLint; import android.content.Context; import android.content.res.ColorStateList; import android.content.res.TypedArray; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Matrix; import android.graphics.Outline; import android.graphics.Paint; import android.graphics.Path; import android.graphics.Point; import android.graphics.PointF; import android.graphics.Rect; import android.graphics.RectF; import android.graphics.drawable.Drawable; import android.util.AttributeSet; import android.view.LayoutInflater; import android.view.MotionEvent; import android.view.View; import android.view.ViewAnimationUtils; import android.view.ViewGroup; import android.view.ViewOutlineProvider; import androidx.annotation.AttrRes; import androidx.annotation.FloatRange; import androidx.annotation.LayoutRes; import androidx.annotation.NonNull; import androidx.annotation.StyleRes; import com.annimon.stream.Stream; import com.google.android.material.shape.CutCornerTreatment; import com.google.android.material.shape.MaterialShapeDrawable; import com.google.android.material.shape.RoundedCornerTreatment; import com.google.android.material.shape.ShapeAppearanceModel; import org.jetbrains.annotations.NotNull; import java.util.ArrayList; import java.util.Collections; import java.util.List; import carbon.Carbon; import carbon.R; import carbon.animation.AnimatedView; import carbon.animation.StateAnimator; import carbon.behavior.Behavior; import carbon.component.Component; import carbon.component.ComponentView; import carbon.drawable.ripple.RippleDrawable; import carbon.drawable.ripple.RippleView; import carbon.internal.ElevationComparator; import carbon.internal.RevealAnimator; import carbon.view.BehaviorView; import carbon.view.InsetView; import carbon.view.MarginView; import carbon.view.MaxSizeView; import carbon.view.RevealView; import carbon.view.ShadowView; import carbon.view.ShapeModelView; import carbon.view.StateAnimatorView; import carbon.view.StrokeView; import carbon.view.TouchMarginView; import carbon.view.TransformationView; import carbon.view.VisibleView; /** * A ConstraintLayout implementation with support for material features including shadows, ripples, * rounded corners, insets, custom drawing order, touch margins, state animators and others. */ public class ConstraintLayout extends androidx.constraintlayout.widget.ConstraintLayout implements ShadowView, RippleView, TouchMarginView, StateAnimatorView, AnimatedView, ShapeModelView, InsetView, StrokeView, MaxSizeView, RevealView, VisibleView, TransformationView, BehaviorView, MarginView { private OnTouchListener onDispatchTouchListener; public ConstraintLayout(Context context) { super(context, null, R.attr.carbon_constraintLayoutStyle); initConstraintLayout(null, R.attr.carbon_constraintLayoutStyle, R.style.carbon_ConstraintLayout); } public ConstraintLayout(Context context, AttributeSet attrs) { super(context, attrs, R.attr.carbon_constraintLayoutStyle); initConstraintLayout(attrs, R.attr.carbon_constraintLayoutStyle, R.style.carbon_ConstraintLayout); } public ConstraintLayout(Context context, AttributeSet attrs, @AttrRes int defStyleAttr) { super(context, attrs, defStyleAttr); initConstraintLayout(attrs, R.attr.carbon_constraintLayoutStyle, R.style.carbon_ConstraintLayout); } public ConstraintLayout(Context context, AttributeSet attrs, @AttrRes int defStyleAttr, @StyleRes int defStyleRes) { super(context, attrs, defStyleAttr); initConstraintLayout(attrs, R.attr.carbon_constraintLayoutStyle, defStyleRes); } private static int[] rippleIds = new int[]{ R.styleable.ConstraintLayout_carbon_rippleColor, R.styleable.ConstraintLayout_carbon_rippleStyle, R.styleable.ConstraintLayout_carbon_rippleHotspot, R.styleable.ConstraintLayout_carbon_rippleRadius }; private static int[] animationIds = new int[]{ R.styleable.ConstraintLayout_carbon_inAnimation, R.styleable.ConstraintLayout_carbon_outAnimation }; private static int[] touchMarginIds = new int[]{ R.styleable.ConstraintLayout_carbon_touchMargin, R.styleable.ConstraintLayout_carbon_touchMarginLeft, R.styleable.ConstraintLayout_carbon_touchMarginTop, R.styleable.ConstraintLayout_carbon_touchMarginRight, R.styleable.ConstraintLayout_carbon_touchMarginBottom }; private static int[] insetIds = new int[]{ R.styleable.ConstraintLayout_carbon_inset, R.styleable.ConstraintLayout_carbon_insetLeft, R.styleable.ConstraintLayout_carbon_insetTop, R.styleable.ConstraintLayout_carbon_insetRight, R.styleable.ConstraintLayout_carbon_insetBottom, R.styleable.ConstraintLayout_carbon_insetColor }; private static int[] strokeIds = new int[]{ R.styleable.ConstraintLayout_carbon_stroke, R.styleable.ConstraintLayout_carbon_strokeWidth }; private static int[] cornerCutRadiusIds = new int[]{ R.styleable.ConstraintLayout_carbon_cornerRadiusTopStart, R.styleable.ConstraintLayout_carbon_cornerRadiusTopEnd, R.styleable.ConstraintLayout_carbon_cornerRadiusBottomStart, R.styleable.ConstraintLayout_carbon_cornerRadiusBottomEnd, R.styleable.ConstraintLayout_carbon_cornerRadius, R.styleable.ConstraintLayout_carbon_cornerCutTopStart, R.styleable.ConstraintLayout_carbon_cornerCutTopEnd, R.styleable.ConstraintLayout_carbon_cornerCutBottomStart, R.styleable.ConstraintLayout_carbon_cornerCutBottomEnd, R.styleable.ConstraintLayout_carbon_cornerCut }; private static int[] maxSizeIds = new int[]{ R.styleable.ConstraintLayout_carbon_maxWidth, R.styleable.ConstraintLayout_carbon_maxHeight, }; private static int[] elevationIds = new int[]{ R.styleable.ConstraintLayout_carbon_elevation, R.styleable.ConstraintLayout_carbon_elevationShadowColor, R.styleable.ConstraintLayout_carbon_elevationAmbientShadowColor, R.styleable.ConstraintLayout_carbon_elevationSpotShadowColor }; private void initConstraintLayout(AttributeSet attrs, @AttrRes int defStyleAttr, @StyleRes int defStyleRes) { TypedArray a = getContext().obtainStyledAttributes(attrs, R.styleable.ConstraintLayout, defStyleAttr, defStyleRes); Carbon.initDefaultBackground(this, a, R.styleable.ConstraintLayout_android_background); Carbon.initElevation(this, a, elevationIds); Carbon.initRippleDrawable(this, a, rippleIds); Carbon.initAnimations(this, a, animationIds); Carbon.initTouchMargin(this, a, touchMarginIds); Carbon.initInset(this, a, insetIds); Carbon.initMaxSize(this, a, maxSizeIds); Carbon.initStroke(this, a, strokeIds); Carbon.initCornerCutRadius(this, a, cornerCutRadiusIds); a.recycle(); setChildrenDrawingOrderEnabled(true); setClipToPadding(false); } private Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.FILTER_BITMAP_FLAG); private boolean drawCalled = false; RevealAnimator revealAnimator; public Point getLocationOnScreen() { int[] outLocation = new int[2]; super.getLocationOnScreen(outLocation); return new Point(outLocation[0], outLocation[1]); } public Point getLocationInWindow() { int[] outLocation = new int[2]; super.getLocationInWindow(outLocation); return new Point(outLocation[0], outLocation[1]); } @NotNull public Animator createCircularReveal(android.view.View hotspot, float startRadius, float finishRadius) { int[] location = new int[2]; hotspot.getLocationOnScreen(location); int[] myLocation = new int[2]; getLocationOnScreen(myLocation); return createCircularReveal(location[0] - myLocation[0] + hotspot.getWidth() / 2, location[1] - myLocation[1] + hotspot.getHeight() / 2, startRadius, finishRadius); } @NotNull @Override public Animator createCircularReveal(int x, int y, float startRadius, float finishRadius) { startRadius = Carbon.getRevealRadius(this, x, y, startRadius); finishRadius = Carbon.getRevealRadius(this, x, y, finishRadius); if (Carbon.IS_LOLLIPOP_OR_HIGHER) { Animator circularReveal = ViewAnimationUtils.createCircularReveal(this, x, y, startRadius, finishRadius); circularReveal.setDuration(Carbon.getDefaultRevealDuration()); return circularReveal; } else { revealAnimator = new RevealAnimator(x, y, startRadius, finishRadius); revealAnimator.setDuration(Carbon.getDefaultRevealDuration()); revealAnimator.addUpdateListener(animation -> { RevealAnimator reveal = ((RevealAnimator) animation); reveal.radius = (float) reveal.getAnimatedValue(); reveal.mask.reset(); reveal.mask.addCircle(reveal.x, reveal.y, Math.max((Float) reveal.getAnimatedValue(), 1), Path.Direction.CW); postInvalidate(); }); revealAnimator.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationCancel(Animator animation) { revealAnimator = null; } @Override public void onAnimationEnd(Animator animation) { revealAnimator = null; } }); return revealAnimator; } } @Override public void dispatchDraw(@NonNull Canvas canvas) { boolean r = revealAnimator != null && revealAnimator.isRunning(); boolean c = !Carbon.isShapeRect(shapeModel, boundsRect); if (Carbon.IS_PIE_OR_HIGHER) { if (spotShadowColor != null) super.setOutlineSpotShadowColor(spotShadowColor.getColorForState(getDrawableState(), spotShadowColor.getDefaultColor())); if (ambientShadowColor != null) super.setOutlineAmbientShadowColor(ambientShadowColor.getColorForState(getDrawableState(), ambientShadowColor.getDefaultColor())); } // draw not called, we have to handle corners here if (isInEditMode() && !drawCalled && (r || c) && getWidth() > 0 && getHeight() > 0) { Bitmap layer = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888); Canvas layerCanvas = new Canvas(layer); dispatchDrawInternal(layerCanvas); Bitmap mask = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888); Canvas maskCanvas = new Canvas(mask); Paint maskPaint = new Paint(0xffffffff); maskCanvas.drawPath(cornersMask, maskPaint); for (int x = 0; x < getWidth(); x++) { for (int y = 0; y < getHeight(); y++) { int maskPixel = mask.getPixel(x, y); layer.setPixel(x, y, Color.alpha(maskPixel) > 0 ? layer.getPixel(x, y) : 0); } } canvas.drawBitmap(layer, 0, 0, paint); } else if (!drawCalled && (r || c) && getWidth() > 0 && getHeight() > 0 && !Carbon.IS_LOLLIPOP_OR_HIGHER) { int saveCount = canvas.saveLayer(0, 0, getWidth(), getHeight(), null, Canvas.ALL_SAVE_FLAG); if (r) { int saveCount2 = canvas.save(); canvas.clipRect(revealAnimator.x - revealAnimator.radius, revealAnimator.y - revealAnimator.radius, revealAnimator.x + revealAnimator.radius, revealAnimator.y + revealAnimator.radius); dispatchDrawInternal(canvas); canvas.restoreToCount(saveCount2); } else { dispatchDrawInternal(canvas); } paint.setXfermode(Carbon.CLEAR_MODE); if (c) { cornersMask.setFillType(Path.FillType.INVERSE_WINDING); canvas.drawPath(cornersMask, paint); } if (r) canvas.drawPath(revealAnimator.mask, paint); paint.setXfermode(null); canvas.restoreToCount(saveCount); } else { dispatchDrawInternal(canvas); } drawCalled = false; } private void dispatchDrawInternal(@NonNull Canvas canvas) { Collections.sort(getViews(), new ElevationComparator()); super.dispatchDraw(canvas); if (stroke != null) drawStroke(canvas); if (rippleDrawable != null && rippleDrawable.getStyle() == RippleDrawable.Style.Over) rippleDrawable.draw(canvas); if (insetColor != 0) { paint.setColor(insetColor); paint.setAlpha(255); if (insetLeft != 0) canvas.drawRect(0, 0, insetLeft, getHeight(), paint); if (insetTop != 0) canvas.drawRect(0, 0, getWidth(), insetTop, paint); if (insetRight != 0) canvas.drawRect(getWidth() - insetRight, 0, getWidth(), getHeight(), paint); if (insetBottom != 0) canvas.drawRect(0, getHeight() - insetBottom, getWidth(), getHeight(), paint); } } @Override protected boolean drawChild(@NonNull Canvas canvas, @NonNull View child, long drawingTime) { if (child instanceof ShadowView && (!Carbon.IS_LOLLIPOP_OR_HIGHER || ((ShadowView) child).getElevationShadowColor() != null && !Carbon.IS_PIE_OR_HIGHER)) { ShadowView shadowView = (ShadowView) child; shadowView.drawShadow(canvas); } if (child instanceof RippleView) { RippleView rippleView = (RippleView) child; RippleDrawable rippleDrawable = rippleView.getRippleDrawable(); if (rippleDrawable != null && rippleDrawable.getStyle() == RippleDrawable.Style.Borderless) { int saveCount = canvas.save(); canvas.translate(child.getLeft(), child.getTop()); canvas.concat(child.getMatrix()); rippleDrawable.draw(canvas); canvas.restoreToCount(saveCount); } } return super.drawChild(canvas, child, drawingTime); } @Override protected int getChildDrawingOrder(int childCount, int child) { if (views.size() != childCount) getViews(); return indexOfChild(views.get(child)); } protected boolean isTransformedTouchPointInView(float x, float y, View child, PointF outLocalPoint) { final Rect frame = new Rect(); child.getHitRect(frame); return frame.contains((int) x, (int) y); } // ------------------------------- // corners // ------------------------------- private RectF boundsRect = new RectF(); private Path cornersMask = new Path(); @NotNull public ShapeAppearanceModel getShapeModel() { return shapeModel; } /** * Sets the corner radius. If corner radius is equal to 0, rounded corners are turned off. * * @param cornerRadius */ @Override public void setCornerRadius(float cornerRadius) { shapeModel = ShapeAppearanceModel.builder().setAllCorners(new RoundedCornerTreatment(cornerRadius)).build(); setShapeModel(shapeModel); } @Override public void setCornerCut(float cornerCut) { shapeModel = ShapeAppearanceModel.builder().setAllCorners(new CutCornerTreatment(cornerCut)).build(); setShapeModel(shapeModel); } @Override public void setShapeModel(@NotNull ShapeAppearanceModel model) { this.shapeModel = model; shadowDrawable = new MaterialShapeDrawable(shapeModel); if (getWidth() > 0 && getHeight() > 0) updateCorners(); if (!Carbon.IS_LOLLIPOP_OR_HIGHER) postInvalidate(); } @Override protected void onLayout(boolean changed, int left, int top, int right, int bottom) { super.onLayout(changed, left, top, right, bottom); if (!changed) return; if (getWidth() == 0 || getHeight() == 0) return; updateCorners(); if (rippleDrawable != null) rippleDrawable.setBounds(0, 0, getWidth(), getHeight()); } private void updateCorners() { if (Carbon.IS_LOLLIPOP_OR_HIGHER) { setClipToOutline(true); setOutlineProvider(new ViewOutlineProvider() { @Override public void getOutline(View view, Outline outline) { if (Carbon.isShapeRect(shapeModel, boundsRect)) { outline.setRect(0, 0, getWidth(), getHeight()); } else { shadowDrawable.setBounds(0, 0, getWidth(), getHeight()); shadowDrawable.setShadowCompatibilityMode(MaterialShapeDrawable.SHADOW_COMPAT_MODE_NEVER); shadowDrawable.getOutline(outline); } } }); } boundsRect.set(shadowDrawable.getBounds()); shadowDrawable.getPathForSize(getWidth(), getHeight(), cornersMask); } public void drawInternal(@NonNull Canvas canvas) { super.draw(canvas); if (stroke != null) drawStroke(canvas); if (rippleDrawable != null && rippleDrawable.getStyle() == RippleDrawable.Style.Over) rippleDrawable.draw(canvas); } @SuppressLint("MissingSuperCall") @Override public void draw(@NonNull Canvas canvas) { drawCalled = true; boolean r = revealAnimator != null; boolean c = !Carbon.isShapeRect(shapeModel, boundsRect); if (Carbon.IS_PIE_OR_HIGHER) { if (spotShadowColor != null) super.setOutlineSpotShadowColor(spotShadowColor.getColorForState(getDrawableState(), spotShadowColor.getDefaultColor())); if (ambientShadowColor != null) super.setOutlineAmbientShadowColor(ambientShadowColor.getColorForState(getDrawableState(), ambientShadowColor.getDefaultColor())); } if (isInEditMode() && (r || c) && getWidth() > 0 && getHeight() > 0) { Bitmap layer = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888); Canvas layerCanvas = new Canvas(layer); drawInternal(layerCanvas); Bitmap mask = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888); Canvas maskCanvas = new Canvas(mask); Paint maskPaint = new Paint(0xffffffff); maskCanvas.drawPath(cornersMask, maskPaint); for (int x = 0; x < getWidth(); x++) { for (int y = 0; y < getHeight(); y++) { int maskPixel = mask.getPixel(x, y); layer.setPixel(x, y, Color.alpha(maskPixel) > 0 ? layer.getPixel(x, y) : 0); } } canvas.drawBitmap(layer, 0, 0, paint); } else if (getWidth() > 0 && getHeight() > 0 && (((r || c) && !Carbon.IS_LOLLIPOP_OR_HIGHER) || !shapeModel.isRoundRect(boundsRect))) { int saveCount = canvas.saveLayer(0, 0, getWidth(), getHeight(), null, Canvas.ALL_SAVE_FLAG); if (r) { int saveCount2 = canvas.save(); canvas.clipRect(revealAnimator.x - revealAnimator.radius, revealAnimator.y - revealAnimator.radius, revealAnimator.x + revealAnimator.radius, revealAnimator.y + revealAnimator.radius); drawInternal(canvas); canvas.restoreToCount(saveCount2); } else { drawInternal(canvas); } paint.setXfermode(Carbon.CLEAR_MODE); if (c) { cornersMask.setFillType(Path.FillType.INVERSE_WINDING); canvas.drawPath(cornersMask, paint); } if (r) canvas.drawPath(revealAnimator.mask, paint); paint.setXfermode(null); canvas.restoreToCount(saveCount); paint.setXfermode(null); } else { drawInternal(canvas); } } // ------------------------------- // ripple // ------------------------------- private RippleDrawable rippleDrawable; @Override public boolean dispatchTouchEvent(@NonNull MotionEvent event) { if (shadowDrawable.isPointInTransparentRegion((int) event.getX(), (int) event.getY())) return false; if (onDispatchTouchListener != null && onDispatchTouchListener.onTouch(this, event)) return true; if (rippleDrawable != null && event.getAction() == MotionEvent.ACTION_DOWN) rippleDrawable.setHotspot(event.getX(), event.getY()); return super.dispatchTouchEvent(event); } @Override public RippleDrawable getRippleDrawable() { return rippleDrawable; } @Override public void setRippleDrawable(RippleDrawable newRipple) { if (rippleDrawable != null) { rippleDrawable.setCallback(null); if (rippleDrawable.getStyle() == RippleDrawable.Style.Background) super.setBackgroundDrawable(rippleDrawable.getBackground()); } if (newRipple != null) { newRipple.setCallback(this); newRipple.setBounds(0, 0, getWidth(), getHeight()); newRipple.setState(getDrawableState()); ((Drawable) newRipple).setVisible(getVisibility() == VISIBLE, false); if (newRipple.getStyle() == RippleDrawable.Style.Background) super.setBackgroundDrawable((Drawable) newRipple); } rippleDrawable = newRipple; } @Override protected boolean verifyDrawable(@NonNull Drawable who) { return super.verifyDrawable(who) || rippleDrawable == who; } @Override public void invalidateDrawable(@NonNull Drawable drawable) { super.invalidateDrawable(drawable); invalidateParentIfNeeded(); } @Override public void invalidate(@NonNull Rect dirty) { super.invalidate(dirty); invalidateParentIfNeeded(); } @Override public void invalidate(int l, int t, int r, int b) { super.invalidate(l, t, r, b); invalidateParentIfNeeded(); } @Override public void invalidate() { super.invalidate(); invalidateParentIfNeeded(); } private void invalidateParentIfNeeded() { if (getParent() == null || !(getParent() instanceof View)) return; if (rippleDrawable != null && rippleDrawable.getStyle() == RippleDrawable.Style.Borderless) ((View) getParent()).invalidate(); if (elevation > 0 || !Carbon.isShapeRect(shapeModel, boundsRect)) ((View) getParent()).invalidate(); } @Override public void postInvalidateDelayed(long delayMilliseconds) { super.postInvalidateDelayed(delayMilliseconds); postInvalidateParentIfNeededDelayed(delayMilliseconds); } @Override public void postInvalidateDelayed(long delayMilliseconds, int left, int top, int right, int bottom) { super.postInvalidateDelayed(delayMilliseconds, left, top, right, bottom); postInvalidateParentIfNeededDelayed(delayMilliseconds); } private void postInvalidateParentIfNeededDelayed(long delayMilliseconds) { if (getParent() == null || !(getParent() instanceof View)) return; if (rippleDrawable != null && rippleDrawable.getStyle() == RippleDrawable.Style.Borderless) ((View) getParent()).postInvalidateDelayed(delayMilliseconds); if (elevation > 0 || !Carbon.isShapeRect(shapeModel, boundsRect)) ((View) getParent()).postInvalidateDelayed(delayMilliseconds); } @Override public void setBackground(Drawable background) { setBackgroundDrawable(background); } @Override public void setBackgroundDrawable(Drawable background) { if (background instanceof RippleDrawable) { setRippleDrawable((RippleDrawable) background); return; } if (rippleDrawable != null && rippleDrawable.getStyle() == RippleDrawable.Style.Background) { rippleDrawable.setCallback(null); rippleDrawable = null; } super.setBackgroundDrawable(background); } // ------------------------------- // elevation // ------------------------------- private float elevation = 0; private float translationZ = 0; private ShapeAppearanceModel shapeModel = new ShapeAppearanceModel(); private MaterialShapeDrawable shadowDrawable = new MaterialShapeDrawable(shapeModel); private ColorStateList ambientShadowColor, spotShadowColor; @Override public float getElevation() { return elevation; } @Override public void setElevation(float elevation) { if (Carbon.IS_PIE_OR_HIGHER) { super.setElevation(elevation); super.setTranslationZ(translationZ); } else if (Carbon.IS_LOLLIPOP_OR_HIGHER) { if (ambientShadowColor == null || spotShadowColor == null) { super.setElevation(elevation); super.setTranslationZ(translationZ); } else { super.setElevation(0); super.setTranslationZ(0); } } else if (elevation != this.elevation && getParent() != null) { ((View) getParent()).postInvalidate(); } this.elevation = elevation; } @Override public float getTranslationZ() { return translationZ; } public void setTranslationZ(float translationZ) { if (translationZ == this.translationZ) return; if (Carbon.IS_PIE_OR_HIGHER) { super.setTranslationZ(translationZ); } else if (Carbon.IS_LOLLIPOP_OR_HIGHER) { if (ambientShadowColor == null || spotShadowColor == null) { super.setTranslationZ(translationZ); } else { super.setTranslationZ(0); } } else if (translationZ != this.translationZ && getParent() != null) { ((View) getParent()).postInvalidate(); } this.translationZ = translationZ; } @Override public void setEnabled(boolean enabled) { super.setEnabled(enabled); } @Override public boolean hasShadow() { return getElevation() + getTranslationZ() >= 0.01f && getWidth() > 0 && getHeight() > 0; } @Override public void drawShadow(@NotNull Canvas canvas) { float alpha = getAlpha() * Carbon.getBackgroundTintAlpha(this) / 255.0f; if (alpha == 0 || !hasShadow()) return; float z = getElevation() + getTranslationZ(); int saveCount; boolean maskShadow = getBackground() != null && alpha != 1; boolean r = revealAnimator != null && revealAnimator.isRunning(); if (alpha != 255) { paint.setAlpha((int) (127 * alpha)); saveCount = canvas.saveLayer(0, 0, canvas.getWidth(), canvas.getHeight(), paint, Canvas.ALL_SAVE_FLAG); } else { saveCount = canvas.save(); } Matrix matrix = getMatrix(); canvas.setMatrix(matrix); if (r) { canvas.clipRect( getLeft() + revealAnimator.x - revealAnimator.radius, getTop() + revealAnimator.y - revealAnimator.radius, getLeft() + revealAnimator.x + revealAnimator.radius, getTop() + revealAnimator.y + revealAnimator.radius); } shadowDrawable.setFillColor(spotShadowColor); shadowDrawable.setShadowColor(spotShadowColor != null ? spotShadowColor.getColorForState(getDrawableState(), spotShadowColor.getDefaultColor()) : 0xff000000); shadowDrawable.setShadowCompatibilityMode(MaterialShapeDrawable.SHADOW_COMPAT_MODE_ALWAYS); shadowDrawable.setAlpha(0x44); shadowDrawable.setElevation(z); shadowDrawable.setShadowVerticalOffset(0); shadowDrawable.setBounds(getLeft(), (int) (getTop() + z / 4), getRight(), (int) (getBottom() + z / 4)); shadowDrawable.draw(canvas); canvas.translate(this.getLeft(), this.getTop()); canvas.concat(matrix); paint.setXfermode(Carbon.CLEAR_MODE); if (maskShadow) { cornersMask.setFillType(Path.FillType.WINDING); canvas.drawPath(cornersMask, paint); } if (r) canvas.drawPath(revealAnimator.mask, paint); canvas.restoreToCount(saveCount); paint.setXfermode(null); paint.setAlpha(255); } @Override public void setElevationShadowColor(ColorStateList shadowColor) { ambientShadowColor = spotShadowColor = shadowColor; setElevation(elevation); setTranslationZ(translationZ); } @Override public void setElevationShadowColor(int color) { ambientShadowColor = spotShadowColor = ColorStateList.valueOf(color); setElevation(elevation); setTranslationZ(translationZ); } @Override public ColorStateList getElevationShadowColor() { return ambientShadowColor; } @Override public void setOutlineAmbientShadowColor(int color) { setOutlineAmbientShadowColor(ColorStateList.valueOf(color)); } @Override public void setOutlineAmbientShadowColor(ColorStateList color) { ambientShadowColor = color; if (Carbon.IS_PIE_OR_HIGHER) { super.setOutlineAmbientShadowColor(color.getColorForState(getDrawableState(), color.getDefaultColor())); } else { setElevation(elevation); setTranslationZ(translationZ); } } @Override public int getOutlineAmbientShadowColor() { return ambientShadowColor.getDefaultColor(); } @Override public void setOutlineSpotShadowColor(int color) { setOutlineSpotShadowColor(ColorStateList.valueOf(color)); } @Override public void setOutlineSpotShadowColor(ColorStateList color) { spotShadowColor = color; if (Carbon.IS_PIE_OR_HIGHER) { super.setOutlineSpotShadowColor(color.getColorForState(getDrawableState(), color.getDefaultColor())); } else { setElevation(elevation); setTranslationZ(translationZ); } } @Override public int getOutlineSpotShadowColor() { return spotShadowColor.getDefaultColor(); } // ------------------------------- // touch margin // ------------------------------- private Rect touchMargin = new Rect(); @Override public void setTouchMargin(int left, int top, int right, int bottom) { touchMargin.set(left, top, right, bottom); } @Override public void setTouchMarginLeft(int margin) { touchMargin.left = margin; } @Override public void setTouchMarginTop(int margin) { touchMargin.top = margin; } @Override public void setTouchMarginRight(int margin) { touchMargin.right = margin; } @Override public void setTouchMarginBottom(int margin) { touchMargin.bottom = margin; } @NotNull @Override public Rect getTouchMargin() { return touchMargin; } final RectF tmpHitRect = new RectF(); public void getHitRect(@NonNull Rect outRect) { Matrix matrix = getMatrix(); if (matrix.isIdentity()) { outRect.set(getLeft(), getTop(), getRight(), getBottom()); } else { tmpHitRect.set(0, 0, getWidth(), getHeight()); matrix.mapRect(tmpHitRect); outRect.set((int) tmpHitRect.left + getLeft(), (int) tmpHitRect.top + getTop(), (int) tmpHitRect.right + getLeft(), (int) tmpHitRect.bottom + getTop()); } outRect.left -= touchMargin.left; outRect.top -= touchMargin.top; outRect.right += touchMargin.right; outRect.bottom += touchMargin.bottom; } // ------------------------------- // state animators // ------------------------------- private StateAnimator stateAnimator = new StateAnimator(this); @NotNull @Override public StateAnimator getStateAnimator() { return stateAnimator; } @Override protected void drawableStateChanged() { super.drawableStateChanged(); if (rippleDrawable != null && rippleDrawable.getStyle() != RippleDrawable.Style.Background) rippleDrawable.setState(getDrawableState()); if (stateAnimator != null) stateAnimator.setState(getDrawableState()); } // ------------------------------- // animations // ------------------------------- private Animator inAnim = null, outAnim = null; private Animator animator; public Animator animateVisibility(final int visibility) { if (visibility == View.VISIBLE && (getVisibility() != View.VISIBLE || animator != null)) { if (animator != null) animator.cancel(); if (inAnim != null) { animator = inAnim; animator.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator a) { a.removeListener(this); animator = null; } @Override public void onAnimationCancel(Animator a) { a.removeListener(this); animator = null; } }); animator.start(); } setVisibility(visibility); } else if (visibility != View.VISIBLE && (getVisibility() == View.VISIBLE || animator != null)) { if (animator != null) animator.cancel(); if (outAnim == null) { setVisibility(visibility); return null; } animator = outAnim; animator.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator a) { if (((ValueAnimator) a).getAnimatedFraction() == 1) setVisibility(visibility); a.removeListener(this); animator = null; } @Override public void onAnimationCancel(Animator a) { a.removeListener(this); animator = null; } }); animator.start(); } else { setVisibility(visibility); } return animator; } public Animator getAnimator() { return animator; } public Animator getOutAnimator() { return outAnim; } public void setOutAnimator(Animator outAnim) { if (this.outAnim != null) this.outAnim.setTarget(null); this.outAnim = outAnim; if (outAnim != null) outAnim.setTarget(this); } public Animator getInAnimator() { return inAnim; } public void setInAnimator(Animator inAnim) { if (this.inAnim != null) this.inAnim.setTarget(null); this.inAnim = inAnim; if (inAnim != null) inAnim.setTarget(this); } // ------------------------------- // insets // ------------------------------- int insetLeft = InsetView.INSET_NULL, insetTop = InsetView.INSET_NULL, insetRight = InsetView.INSET_NULL, insetBottom = InsetView.INSET_NULL; int insetColor; private OnInsetsChangedListener onInsetsChangedListener; public int getInsetColor() { return insetColor; } public void setInsetColor(int insetsColor) { this.insetColor = insetsColor; } public void setInset(int left, int top, int right, int bottom) { insetLeft = left; insetTop = top; insetRight = right; insetBottom = bottom; } public int getInsetLeft() { return insetLeft; } public void setInsetLeft(int insetLeft) { this.insetLeft = insetLeft; } public int getInsetTop() { return insetTop; } public void setInsetTop(int insetTop) { this.insetTop = insetTop; } public int getInsetRight() { return insetRight; } public void setInsetRight(int insetRight) { this.insetRight = insetRight; } public int getInsetBottom() { return insetBottom; } public void setInsetBottom(int insetBottom) { this.insetBottom = insetBottom; } @Override protected boolean fitSystemWindows(@NonNull Rect insets) { if (insetLeft == InsetView.INSET_NULL) insetLeft = insets.left; if (insetTop == InsetView.INSET_NULL) insetTop = insets.top; if (insetRight == InsetView.INSET_NULL) insetRight = insets.right; if (insetBottom == InsetView.INSET_NULL) insetBottom = insets.bottom; insets.set(insetLeft, insetTop, insetRight, insetBottom); if (onInsetsChangedListener != null) onInsetsChangedListener.onInsetsChanged(); postInvalidate(); return super.fitSystemWindows(insets); } public void setOnInsetsChangedListener(OnInsetsChangedListener onInsetsChangedListener) { this.onInsetsChangedListener = onInsetsChangedListener; } // ------------------------------- // ViewGroup utils // ------------------------------- List<View> views = new ArrayList<>(); public List<View> getViews() { views.clear(); for (int i = 0; i < getChildCount(); i++) views.add(getChildAt(i)); return views; } public void setOnDispatchTouchListener(OnTouchListener onDispatchTouchListener) { this.onDispatchTouchListener = onDispatchTouchListener; } public Component findComponentById(int id) { List<ViewGroup> groups = new ArrayList<>(); groups.add(this); while (!groups.isEmpty()) { ViewGroup group = groups.remove(0); for (int i = 0; i < group.getChildCount(); i++) { View child = group.getChildAt(i); if (child instanceof ComponentView && ((ComponentView) child).getComponent().getView().getId() == id) return ((ComponentView) child).getComponent(); if (child instanceof ViewGroup) groups.add((ViewGroup) child); } } return null; } public List<Component> findComponentsById(int id) { List<Component> result = new ArrayList<>(); List<ViewGroup> groups = new ArrayList<>(); groups.add(this); while (!groups.isEmpty()) { ViewGroup group = groups.remove(0); for (int i = 0; i < group.getChildCount(); i++) { View child = group.getChildAt(i); if (child instanceof ComponentView && ((ComponentView) child).getComponent().getView().getId() == id) result.add(((ComponentView) child).getComponent()); if (child instanceof ViewGroup) groups.add((ViewGroup) child); } } return result; } public Component findComponentOfType(Class type) { List<ViewGroup> groups = new ArrayList<>(); groups.add(this); while (!groups.isEmpty()) { ViewGroup group = groups.remove(0); for (int i = 0; i < group.getChildCount(); i++) { View child = group.getChildAt(i); if (child instanceof ComponentView && ((ComponentView) child).getComponent().getClass().equals(type)) return ((ComponentView) child).getComponent(); if (child instanceof ViewGroup) groups.add((ViewGroup) child); } } return null; } public List<Component> findComponentsOfType(Class type) { List<Component> result = new ArrayList<>(); List<ViewGroup> groups = new ArrayList<>(); groups.add(this); while (!groups.isEmpty()) { ViewGroup group = groups.remove(0); for (int i = 0; i < group.getChildCount(); i++) { View child = group.getChildAt(i); if (child instanceof ComponentView && ((ComponentView) child).getComponent().getClass().equals(type)) result.add(((ComponentView) child).getComponent()); if (child instanceof ViewGroup) groups.add((ViewGroup) child); } } return result; } public <Type extends View> Type findViewOfType(Class<Type> type) { List<ViewGroup> groups = new ArrayList<>(); groups.add(this); while (!groups.isEmpty()) { ViewGroup group = groups.remove(0); for (int i = 0; i < group.getChildCount(); i++) { View child = group.getChildAt(i); if (child.getClass().equals(type)) return (Type) child; if (child instanceof ViewGroup) groups.add((ViewGroup) child); } } return null; } public <Type extends View> List<Type> findViewsOfType(Class<Type> type) { List<Type> result = new ArrayList<>(); List<ViewGroup> groups = new ArrayList<>(); groups.add(this); while (!groups.isEmpty()) { ViewGroup group = groups.remove(0); for (int i = 0; i < group.getChildCount(); i++) { View child = group.getChildAt(i); if (child.getClass().equals(type)) result.add((Type) child); if (child instanceof ViewGroup) groups.add((ViewGroup) child); } } return result; } public List<View> findViewsById(int id) { List<View> result = new ArrayList<>(); List<ViewGroup> groups = new ArrayList<>(); groups.add(this); while (!groups.isEmpty()) { ViewGroup group = groups.remove(0); for (int i = 0; i < group.getChildCount(); i++) { View child = group.getChildAt(i); if (child.getId() == id) result.add(child); if (child instanceof ViewGroup) groups.add((ViewGroup) child); } } return result; } public List<View> findViewsWithTag(Object tag) { List<View> result = new ArrayList<>(); List<ViewGroup> groups = new ArrayList<>(); groups.add(this); while (!groups.isEmpty()) { ViewGroup group = groups.remove(0); for (int i = 0; i < group.getChildCount(); i++) { View child = group.getChildAt(i); if (tag.equals(child.getTag())) result.add(child); if (child instanceof ViewGroup) groups.add((ViewGroup) child); } } return result; } public View inflate(@LayoutRes int id) { return LayoutInflater.from(getContext()).inflate(id, this); } public View inflate(@LayoutRes int id, boolean attach) { return LayoutInflater.from(getContext()).inflate(id, this, attach); } // ------------------------------- // stroke // ------------------------------- private ColorStateList stroke; private float strokeWidth; private Paint strokePaint; private void drawStroke(Canvas canvas) { strokePaint.setStrokeWidth(strokeWidth * 2); strokePaint.setColor(stroke.getColorForState(getDrawableState(), stroke.getDefaultColor())); cornersMask.setFillType(Path.FillType.WINDING); canvas.drawPath(cornersMask, strokePaint); } @Override public void setStroke(ColorStateList colorStateList) { stroke = colorStateList; if (stroke == null) return; if (strokePaint == null) { strokePaint = new Paint(Paint.ANTI_ALIAS_FLAG); strokePaint.setStyle(Paint.Style.STROKE); } } @Override public void setStroke(int color) { setStroke(ColorStateList.valueOf(color)); } @Override public ColorStateList getStroke() { return stroke; } @Override public void setStrokeWidth(float strokeWidth) { this.strokeWidth = strokeWidth; } @Override public float getStrokeWidth() { return strokeWidth; } // ------------------------------- // layout params // ------------------------------- @Override protected ConstraintLayout.LayoutParams generateDefaultLayoutParams() { return new ConstraintLayout.LayoutParams(super.generateDefaultLayoutParams()); } @Override public ConstraintLayout.LayoutParams generateLayoutParams(AttributeSet attrs) { return new ConstraintLayout.LayoutParams(getContext(), attrs); } @Override protected ConstraintLayout.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) { return new ConstraintLayout.LayoutParams(p); } public static class LayoutParams extends androidx.constraintlayout.widget.ConstraintLayout.LayoutParams { public LayoutParams(Context c, AttributeSet attrs) { super(c, attrs); TypedArray a = c.obtainStyledAttributes(attrs, R.styleable.ConstraintLayout_Layout); if (a.hasValue(R.styleable.ConstraintLayout_Layout_carbon_layout_marginHorizontal)) leftMargin = rightMargin = a.getDimensionPixelSize(R.styleable.ConstraintLayout_Layout_carbon_layout_marginHorizontal, 0); if (a.hasValue(R.styleable.ConstraintLayout_Layout_carbon_layout_marginVertical)) topMargin = bottomMargin = a.getDimensionPixelSize(R.styleable.ConstraintLayout_Layout_carbon_layout_marginVertical, 0); a.recycle(); } public LayoutParams(int w, int h) { super(w, h); } /** * {@inheritDoc} */ public LayoutParams(ViewGroup.LayoutParams source) { super(source); } /** * {@inheritDoc} */ public LayoutParams(ViewGroup.MarginLayoutParams source) { super(source); } public LayoutParams(androidx.constraintlayout.widget.ConstraintLayout.LayoutParams source) { super((MarginLayoutParams) source); } public LayoutParams(ConstraintLayout.LayoutParams source) { super((MarginLayoutParams) source); } } // ------------------------------- // maximum width & height // ------------------------------- int maxWidth = Integer.MAX_VALUE, maxHeight = Integer.MAX_VALUE; @Override public int getMaxWidth() { return maxWidth; } @Override public void setMaxWidth(int maxWidth) { this.maxWidth = maxWidth; requestLayout(); } @Override public int getMaxHeight() { return maxHeight; } @Override public void setMaxHeight(int maxHeight) { this.maxHeight = maxHeight; requestLayout(); } @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { super.onMeasure(widthMeasureSpec, heightMeasureSpec); if (getMeasuredWidth() > maxWidth || getMeasuredHeight() > maxHeight) { if (getMeasuredWidth() > maxWidth) widthMeasureSpec = MeasureSpec.makeMeasureSpec(maxWidth, MeasureSpec.EXACTLY); if (getMeasuredHeight() > maxHeight) heightMeasureSpec = MeasureSpec.makeMeasureSpec(maxHeight, MeasureSpec.EXACTLY); super.onMeasure(widthMeasureSpec, heightMeasureSpec); } } // ------------------------------- // transformations // ------------------------------- List<OnTransformationChangedListener> transformationChangedListeners = new ArrayList<>(); public void addOnTransformationChangedListener(OnTransformationChangedListener listener) { transformationChangedListeners.add(listener); } public void removeOnTransformationChangedListener(OnTransformationChangedListener listener) { transformationChangedListeners.remove(listener); } public void clearOnTransformationChangedListeners() { transformationChangedListeners.clear(); } private void fireOnTransformationChangedListener() { if (transformationChangedListeners == null) return; for (OnTransformationChangedListener listener : transformationChangedListeners) listener.onTransformationChanged(); } @Override public void setRotation(float rotation) { super.setRotation(rotation); invalidateParentIfNeeded(); fireOnTransformationChangedListener(); } @Override public void setRotationY(float rotationY) { super.setRotationY(rotationY); invalidateParentIfNeeded(); fireOnTransformationChangedListener(); } @Override public void setRotationX(float rotationX) { super.setRotationX(rotationX); invalidateParentIfNeeded(); fireOnTransformationChangedListener(); } @Override public void setScaleX(float scaleX) { super.setScaleX(scaleX); invalidateParentIfNeeded(); fireOnTransformationChangedListener(); } @Override public void setScaleY(float scaleY) { super.setScaleY(scaleY); invalidateParentIfNeeded(); fireOnTransformationChangedListener(); } @Override public void setPivotX(float pivotX) { super.setPivotX(pivotX); invalidateParentIfNeeded(); fireOnTransformationChangedListener(); } @Override public void setPivotY(float pivotY) { super.setPivotY(pivotY); invalidateParentIfNeeded(); fireOnTransformationChangedListener(); } @Override public void setAlpha(@FloatRange(from = 0.0, to = 1.0) float alpha) { super.setAlpha(alpha); invalidateParentIfNeeded(); fireOnTransformationChangedListener(); } @Override public void setTranslationX(float translationX) { super.setTranslationX(translationX); invalidateParentIfNeeded(); fireOnTransformationChangedListener(); } @Override public void setTranslationY(float translationY) { super.setTranslationY(translationY); invalidateParentIfNeeded(); fireOnTransformationChangedListener(); } public void setWidth(int width) { ViewGroup.LayoutParams layoutParams = getLayoutParams(); if (layoutParams == null) { setLayoutParams(new ViewGroup.LayoutParams(width, ViewGroup.LayoutParams.WRAP_CONTENT)); } else { layoutParams.width = width; setLayoutParams(layoutParams); } } public void setHeight(int height) { ViewGroup.LayoutParams layoutParams = getLayoutParams(); if (layoutParams == null) { setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, height)); } else { layoutParams.height = height; setLayoutParams(layoutParams); } } public void setSize(int width, int height) { ViewGroup.LayoutParams layoutParams = getLayoutParams(); if (layoutParams == null) { setLayoutParams(new ViewGroup.LayoutParams(width, height)); } else { layoutParams.width = width; layoutParams.height = height; setLayoutParams(layoutParams); } } public void setBounds(int x, int y, int width, int height) { setSize(width, height); setTranslationX(x); setTranslationY(y); } // ------------------------------- // dependency // ------------------------------- private List<Behavior> behaviors = new ArrayList<>(); @Override public void addBehavior(@NotNull Behavior behavior) { behaviors.add(behavior); } @Override public void removeBehavior(@NotNull Behavior behavior) { behaviors.remove(behavior); } @Override protected void onDetachedFromWindow() { super.onDetachedFromWindow(); Stream.of(behaviors).forEach(Behavior::onDetachedFromWindow); } @Override protected void onAttachedToWindow() { super.onAttachedToWindow(); Stream.of(behaviors).forEach(Behavior::onAttachedToWindow); } }