Android implements universal custom shadow control instance code

<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:andro>
  <item>
    <shape android:shape="rectangle">
      <solid android:color="@color/indexShadowColor_1" />
      <corners android:radius="5dip" />
      <padding
        android:bottom="1dp"
        android:left="1dp"
        android:right="1dp"
        android:top="1dp" />
    </shape>
  </item>
  <item>
    <shape android:shape="rectangle">
      <solid android:color="@color/indexShadowColor_2" />
      <corners android:radius="5dip" />
      <padding
        android:bottom="1dp"
        android:left="1dp"
        android:right="1dp"
        android:top="1dp" />
    </shape>
  </item>
  
  ……

  <item>
    <shape android:shape="rectangle">
      <corners android:radius="5dip" />
      <solid android:color="@color/indexColor" />
    </shape>
  </item>
</layer-list>

<declare-styleable name="ShadowLayout">
  <!--The rounded corner size of the shadow-->
  <attr name="yc_cornerRadius" format="dimension" />
  <!--The spread range of shadows(It can also be understood as the degree of diffusion)-->
  <attr name="yc_shadowLimit" format="dimension" />
  <!--Shadow color-->
  <attr name="yc_shadowColor" format="color" />
  <!--xThe offset of the axis-->
  <attr name="yc_dx" format="dimension" />
  <!--yThe offset of the axis-->
  <attr name="yc_dy" format="dimension" />
  <!--Is there a shadow on the left?-->
  <attr name="yc_leftShow" format="boolean" />
  <!--Is there a shadow on the right?-->
  <attr name="yc_rightShow" format="boolean" />
  <!--Is there a shadow displayed above-->
  <attr name="yc_topShow" format="boolean" />
  <!--Is there a shadow displayed below-->
  <attr name="yc_bottomShow" format="boolean" />
</declare-styleable>

/**
  * <pre>
  * @author yangchong
  * blog : /yangchong211
  * time: 2018/7/20
  * desc : Custom shadow
  * revise:
  */
public class ShadowLayout extends FrameLayout {

  /**
    * Shadow color
    */
  private int mShadowColor;
  /**
    * The diffusion range of the shadow (can also be understood as the diffusion degree)
    */
  private float mShadowLimit;
  /**
    * Shadow rounded corner size
    */
  private float mCornerRadius;
  /**
    * The offset of the x-axis
    */
  private float mDx;
  /**
    * The offset of the y-axis
    */
  private float mDy;
  /**
    * Is there a shadow on the left?
    */
  private boolean leftShow;
  /**
    * Is there a shadow on the right?
    */
  private boolean rightShow;
  /**
    * Is there a shadow displayed above
    */
  private boolean topShow;
  /**
    * Is there a shadow displayed below
    */
  private boolean bottomShow;


  private boolean mInvalidateShadowOnSizeChanged = true;
  private boolean mForceInvalidateShadow = false;

  public ShadowLayout(Context context) {
    super(context);
    initView(context, null);
  }

  public ShadowLayout(Context context, AttributeSet attrs) {
    super(context, attrs);
    initView(context, attrs);
  }

  public ShadowLayout(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    initView(context, attrs);
  }

  @Override
  protected int getSuggestedMinimumWidth() {
    return 0;
  }

  @Override
  protected int getSuggestedMinimumHeight() {
    return 0;
  }

  @Override
  protected void onSizeChanged(int w, int h, int oldw, int oldh) {
    (w, h, oldw, oldh);
    if (w &gt; 0 &amp;&amp; h &gt; 0 &amp;&amp; (getBackground() == null || mInvalidateShadowOnSizeChanged
        || mForceInvalidateShadow)) {
      mForceInvalidateShadow = false;
      setBackgroundCompat(w, h);
    }
  }

  @Override
  protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    (changed, left, top, right, bottom);
    if (mForceInvalidateShadow) {
      mForceInvalidateShadow = false;
      setBackgroundCompat(right - left, bottom - top);
    }
  }

  public void setInvalidateShadowOnSizeChanged(boolean invalidateShadowOnSizeChanged) {
    mInvalidateShadowOnSizeChanged = invalidateShadowOnSizeChanged;
  }

  public void invalidateShadow() {
    mForceInvalidateShadow = true;
    requestLayout();
    invalidate();
  }

  private void initView(Context context, AttributeSet attrs) {
    initAttributes(context, attrs);

    int xPadding = (int) (mShadowLimit + (mDx));
    int yPadding = (int) (mShadowLimit + (mDy));
    int left;
    int right;
    int top;
    int bottom;
    if (leftShow) {
      left = xPadding;
    } else {
      left = 0;
    }

    if (topShow) {
      top = yPadding;
    } else {
      top = 0;
    }


    if (rightShow) {
      right = xPadding;
    } else {
      right = 0;
    }

    if (bottomShow) {
      bottom = yPadding;
    } else {
      bottom = 0;
    }

    setPadding(left, top, right, bottom);
  }

  @SuppressWarnings("deprecation")
  private void setBackgroundCompat(int w, int h) {
    Bitmap bitmap = createShadowBitmap(w, h, mCornerRadius, mShadowLimit, mDx,
        mDy, mShadowColor, );
    BitmapDrawable drawable = new BitmapDrawable(getResources(), bitmap);
    if (.SDK_INT &lt;= Build.VERSION_CODES.JELLY_BEAN) {
      setBackgroundDrawable(drawable);
    } else {
      setBackground(drawable);
    }
  }


  private void initAttributes(Context context, AttributeSet attrs) {
    TypedArray attr = getTypedArray(context, attrs, );
    if (attr == null) {
      return;
    }

    try {
      //Default is to display      leftShow = (.ShadowLayout_yc_leftShow, true);
      rightShow = (.ShadowLayout_yc_rightShow, true);
      bottomShow = (.ShadowLayout_yc_bottomShow, true);
      topShow = (.ShadowLayout_yc_topShow, true);

      mCornerRadius = (.ShadowLayout_yc_cornerRadius, 0);
      mShadowLimit = (.ShadowLayout_yc_shadowLimit, 0);
      mDx = (.ShadowLayout_yc_dx, 0);
      mDy = (.ShadowLayout_yc_dy, 0);
      mShadowColor = (.ShadowLayout_yc_shadowColor,
          getResources().getColor(.default_shadow_color));
    } finally {
      ();
    }
  }

  private TypedArray getTypedArray(Context context, AttributeSet attributeSet, int[] attr) {
    return (attributeSet, attr, 0, 0);
  }

  private Bitmap createShadowBitmap(int shadowWidth, int shadowHeight, float cornerRadius,
                   float shadowRadius, float dx, float dy,
                   int shadowColor, int fillColor) {

    //Create a bitmap background based on width and height    Bitmap output = (shadowWidth, shadowHeight, .ARGB_8888);
    //Draw with artboard canvas    Canvas canvas = new Canvas(output);
    RectF shadowRect = new RectF(shadowRadius, shadowRadius,
        shadowWidth - shadowRadius, shadowHeight - shadowRadius);

    if (dy &gt; 0) {
       += dy;
       -= dy;
    } else if (dy &lt; 0) {
       += (dy);
       -= (dy);
    }

    if (dx &gt; 0) {
       += dx;
       -= dx;
    } else if (dx &lt; 0) {
       += (dx);
       -= (dx);
    }

    Paint shadowPaint = new Paint();
    (true);
    (fillColor);
    ();
    if (!isInEditMode()) {
      (shadowRadius, dx, dy, shadowColor);
    }
    (shadowRect, cornerRadius, cornerRadius, shadowPaint);
    return output;
  }
}
```

<
  android:layout_width="wrap_content"
  android:layout_height="wrap_content"
  android:layout_gravity="center_horizontal"
  android:layout_marginTop="10dp"
  app:yc_cornerRadius="18dp"
  app:yc_dx="0dp"
  app:yc_dy="0dp"
  app:yc_shadowColor="#2a000000"
  app:yc_shadowLimit="5dp">

  <TextView
    android:layout_width="wrap_content"
    android:layout_height="36dp"
    android:background="@drawable/shape_show_"
    android:gravity="center"
    android:paddingLeft="10dp"
    android:paddingRight="10dp"
    android:text="Full round corners"
    android:textColor="#000" />

</>

public class Key {

  private final String name;
  private final int width;
  private final int height;

  public Key(String name, int width, int height) {
     = name;
     = width;
     = height;
  }

  public String getName() {
    return name;
  }

  public int getWidth() {
    return width;
  }

  public int getHeight() {
    return height;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != ()) {
      return false;
    }
    Key key = (Key) o;
    if (width != ) {
      return false;
    }
    if (height != ) {
      return false;
    }
    return name != null ? () :  == null;
  }

  @Override
  public int hashCode() {
    int result = name != null ? () : 0;
    result = 31 * result + width;
    result = 31 * result + height;
    return result;
  }
}

Key key = new Key("bitmap", shadowWidth, shadowHeight);
Bitmap output = (key);
if(output == null){
  //Create a bitmap background based on width and height  output = (shadowWidth, shadowHeight, .ARGB_8888);
  (key, output);
  ("bitmap object-----","----Create the object directly and then save it in the cache---");
} else {
  ("bitmap object-----","----Fetch the object from the cache----");
}