• Android实现自定义圆角边框渐变

    1.定义全部圆角的通用接口

    1. public interface IRadiusLayout {
    2.     int DEFAULT_RADIUS = 0; // 默认没有圆角
    3.     int SOLID_TYPE_SOLID = 0; // 实线
    4.     int SOLID_TYPE_DASH = 1;  // 虚线
    5.  
    6.     /**
    7.      * 设置背景颜色状态列表
    8.      *
    9.      * @param bgColorStateList 背景颜色状态列表
    10.      */
    11.     void setBackgroundColor(ColorStateList bgColorStateList);
    12.  
    13.     /**
    14.      * 设置边框虚线样式
    15.      *
    16.      * @param dashPathEffect 边框虚线样式
    17.      */
    18.     void setSolidDashPathEffect(DashPathEffect dashPathEffect);
    19.  
    20.     /**
    21.      * 设置边框线颜色
    22.      *
    23.      * @param color 边框线颜色
    24.      */
    25.     void setSolidColor(int color);
    26.  
    27.     /**
    28.      * 设置边框颜色状态列表
    29.      *
    30.      * @param solidColorStateList 边框颜色状态列表
    31.      */
    32.     void setSolidColor(ColorStateList solidColorStateList);
    33.  
    34.     /**
    35.      * 设置圆角，四个圆角大小一样
    36.      *
    37.      * @param radius 圆角大小
    38.      */
    39.     void setRadius(int radius);
    40.  
    41.     /**
    42.      * 设置圆角大小，分别设置
    43.      *
    44.      * @param leftTopRadius     左上角圆角大小
    45.      * @param rightTopRadius    右上角圆角大小
    46.      * @param rightBottomRadius 左下角圆角大小
    47.      * @param leftBottomRadius  右下角圆角大小
    48.      */
    49.     void setRadius(int leftTopRadius, int rightTopRadius, int rightBottomRadius, int leftBottomRadius);
    50.  
    51.     /**
    52.      * 设置左上角圆角大小
    53.      *
    54.      * @param leftTopRadius 左上角圆角大小
    55.      */
    56.     void setLeftTopRadius(int leftTopRadius);
    57.  
    58.     /**
    59.      * 设置右上角圆角大小
    60.      *
    61.      * @param rightTopRadius 右上角圆角大小
    62.      */
    63.     void setRightTopRadius(int rightTopRadius);
    64.  
    65.     /**
    66.      * 设置右下角圆角大小
    67.      *
    68.      * @param rightBottomRadius 右下角圆角大小
    69.      */
    70.     void setRightBottomRadius(int rightBottomRadius);
    71.  
    72.     /**
    73.      * 设置左下角圆角大小
    74.      *
    75.      * @param leftBottomRadius 左下角圆角大小
    76.      */
    77.     void setLeftBottomRadius(int leftBottomRadius);
    78.  
    79.     /**
    80.      * 设置背景渐变信息
    81.      *
    82.      * @param shapeType   渐变类型
    83.      * @param shapeColors 渐变颜色数组
    84.      */
    85.     void setShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors);
    86.  
    87.     /**
    88.      * 设置背景渐变信息
    89.      *
    90.      * @param shapeType               渐变类型
    91.      * @param shapeColors             渐变颜色数组
    92.      * @param shaderLinearOrientation 渐变方向
    93.      */
    94.     void setShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors, @ShaderUtils.LinearOrientation int shaderLinearOrientation);
    95.  
    96.     /**
    97.      * 设置边框渐变信息
    98.      *
    99.      * @param shapeType   渐变类型
    100.      * @param shapeColors 渐变颜色数组
    101.      */
    102.     void setSolidShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors);
    103.  
    104.     /**
    105.      * 设置边框渐变信息
    106.      *
    107.      * @param shapeType               渐变类型
    108.      * @param shapeColors             渐变颜色数组
    109.      * @param shaderLinearOrientation 渐变方向
    110.      */
    111.     void setSolidShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors, @ShaderUtils.LinearOrientation int shaderLinearOrientation);
    112. }

    2.定义渐变工具ShaderUtils

    1. public class ShaderUtils {
    2.     // 定义超出颜色范围的值作为非颜色值
    3.     public static final int COLOR_VALUE_NONE = -0xFFFFFFFF;
    4.     // 渐变类型
    5.     public static final int SHADER_TYPE_LINEAR = 10; // 线性渐变
    6.     public static final int SHADER_TYPE_RADIAL = 11; // 圆形渐变
    7.     public static final int SHADER_TYPE_SWEEP = 12;  // 扫描渐变
    8.     public static final int SHADER_TYPE_NONE = -1;   // 不要渐变
    9.  
    10.     // 线性渐变方向
    11.     public static final int LINEAR_ORIENTATION_TOP_TO_BOTTOM = 110; // 从上到下
    12.     public static final int LINEAR_ORIENTATION_BOTTOM_TO_TOP = 111; // 从下到上
    13.     public static final int LINEAR_ORIENTATION_LEFT_TO_RIGHT = 220; // 从左到右
    14.     public static final int LINEAR_ORIENTATION_RIGHT_TO_LEFT = 221; // 从右到左
    15.     public static final int LINEAR_ORIENTATION_LEFT_TOP_TO_RIGHT_BOTTOM = 330; // 从左上到右下
    16.     public static final int LINEAR_ORIENTATION_RIGHT_BOTTOM_TO_LEFT_TOP = 331; // 从右下到左上
    17.     public static final int LINEAR_ORIENTATION_RIGHT_TOP_TO_LEFT_BOTTOM = 440; // 从右上到左下
    18.     public static final int LINEAR_ORIENTATION_LEFT_BOTTOM_TO_RIGHT_TOP = 441; // 从左下到右上
    19.  
    20.     @IntDef(value = {SHADER_TYPE_LINEAR, SHADER_TYPE_RADIAL, SHADER_TYPE_SWEEP})
    21.     public @interface ShaderType {
    22.     }
    23.  
    24.     @IntDef(value = {LINEAR_ORIENTATION_TOP_TO_BOTTOM, LINEAR_ORIENTATION_BOTTOM_TO_TOP,
    25.             LINEAR_ORIENTATION_LEFT_TO_RIGHT, LINEAR_ORIENTATION_RIGHT_TO_LEFT,
    26.             LINEAR_ORIENTATION_LEFT_TOP_TO_RIGHT_BOTTOM, LINEAR_ORIENTATION_RIGHT_BOTTOM_TO_LEFT_TOP,
    27.             LINEAR_ORIENTATION_RIGHT_TOP_TO_LEFT_BOTTOM, LINEAR_ORIENTATION_LEFT_BOTTOM_TO_RIGHT_TOP})
    28.     public @interface LinearOrientation {
    29.     }
    30.  
    31.     private ShaderUtils() {
    32.     }
    33.  
    34.     public static Shader createShader(@ShaderType int shaderType, int width, int height, int[] colors, @LinearOrientation int orientation) {
    35.         if (shaderType == SHADER_TYPE_LINEAR) {
    36.             return createLinearGradient(width, height, colors, orientation);
    37.         } else if (shaderType == SHADER_TYPE_RADIAL) {
    38.             return createRadialGradient(width, height, colors);
    39.         } else if (shaderType == SHADER_TYPE_SWEEP) {
    40.             return createSweepGradient(width, height, colors);
    41.         } else {
    42.             return createLinearGradient(width, height, colors, orientation);
    43.         }
    44.     }
    45.  
    46.     public static LinearGradient createLinearGradient(int width, int height, int[] colors, @LinearOrientation int orientation) {
    47.         LinearGradient linearGradient;
    48.         int halfWidth = width / 2;
    49.         int halfHeight = height / 2;
    50.         if (LINEAR_ORIENTATION_TOP_TO_BOTTOM == orientation) {
    51.             linearGradient = new LinearGradient(halfWidth, 0, halfWidth, height, colors, null, Shader.TileMode.CLAMP);
    52.         } else if (LINEAR_ORIENTATION_BOTTOM_TO_TOP == orientation) {
    53.             linearGradient = new LinearGradient(halfWidth, height, halfWidth, 0, colors, null, Shader.TileMode.CLAMP);
    54.         } else if (LINEAR_ORIENTATION_LEFT_TO_RIGHT == orientation) {
    55.             linearGradient = new LinearGradient(0, halfHeight, width, halfHeight, colors, null, Shader.TileMode.CLAMP);
    56.         } else if (LINEAR_ORIENTATION_RIGHT_TO_LEFT == orientation) {
    57.             linearGradient = new LinearGradient(width, halfHeight, 0, halfHeight, colors, null, Shader.TileMode.CLAMP);
    58.         } else if (LINEAR_ORIENTATION_LEFT_TOP_TO_RIGHT_BOTTOM == orientation) {
    59.             linearGradient = new LinearGradient(0, 0, width, height, colors, null, Shader.TileMode.CLAMP);
    60.         } else if (LINEAR_ORIENTATION_RIGHT_BOTTOM_TO_LEFT_TOP == orientation) {
    61.             linearGradient = new LinearGradient(width, height, 0, 0, colors, null, Shader.TileMode.CLAMP);
    62.         } else if (LINEAR_ORIENTATION_RIGHT_TOP_TO_LEFT_BOTTOM == orientation) {
    63.             linearGradient = new LinearGradient(width, 0, 0, height, colors, null, Shader.TileMode.CLAMP);
    64.         } else if (LINEAR_ORIENTATION_LEFT_BOTTOM_TO_RIGHT_TOP == orientation) {
    65.             linearGradient = new LinearGradient(0, height, width, 0, colors, null, Shader.TileMode.CLAMP);
    66.         } else {
    67.             linearGradient = new LinearGradient(halfWidth, 0, halfWidth, height, colors, null, Shader.TileMode.CLAMP);
    68.         }
    69.         return linearGradient;
    70.     }
    71.  
    72.     public static RadialGradient createRadialGradient(int width, int height, int[] colors) {
    73.         int halfWidth = width / 2;
    74.         int halfHeight = height / 2;
    75.         return new RadialGradient(halfWidth, halfHeight, Math.min(halfWidth, halfHeight), colors, null, Shader.TileMode.CLAMP);
    76.     }
    77.  
    78.     public static SweepGradient createSweepGradient(int width, int height, int[] colors) {
    79.         int halfWidth = width / 2;
    80.         int halfHeight = height / 2;
    81.         return new SweepGradient(halfWidth, halfHeight, colors, null);
    82.     }
    83.  
    84.     public static int[] createColorsArray(int startColor, int middleColor, int middleColor2, int middleColor3, int endColor) {
    85.         List colors = new ArrayList<>();
    86.         if (startColor != COLOR_VALUE_NONE) {
    87.             colors.add(startColor);
    88.         }
    89.         if (middleColor != COLOR_VALUE_NONE) {
    90.             colors.add(middleColor);
    91.         }
    92.         if (middleColor2 != COLOR_VALUE_NONE) {
    93.             colors.add(middleColor2);
    94.         }
    95.         if (middleColor3 != COLOR_VALUE_NONE) {
    96.             colors.add(middleColor3);
    97.         }
    98.         if (endColor != COLOR_VALUE_NONE) {
    99.             colors.add(endColor);
    100.         }
    101.         if (colors.size() > 0) {
    102.             int[] shaderColors = new int[colors.size()];
    103.             for (int i = 0; i < colors.size(); i++) {
    104.                 shaderColors[i] = colors.get(i);
    105.             }
    106.             return shaderColors;
    107.         }
    108.         return null;
    109.     }
    110.  
    111.     public static int[] createColorsArray(int startColor, int middleColor, int endColor) {
    112.         List colors = new ArrayList<>();
    113.         if (startColor != COLOR_VALUE_NONE) {
    114.             colors.add(startColor);
    115.         }
    116.         if (middleColor != COLOR_VALUE_NONE) {
    117.             colors.add(middleColor);
    118.         }
    119.         if (endColor != COLOR_VALUE_NONE) {
    120.             colors.add(endColor);
    121.         }
    122.         if (colors.size() > 0) {
    123.             int[] shaderColors = new int[colors.size()];
    124.             for (int i = 0; i < colors.size(); i++) {
    125.                 shaderColors[i] = colors.get(i);
    126.             }
    127.             return shaderColors;
    128.         }
    129.         return null;
    130.     }
    131. }

    3.圆角工具RadiusUtils

    1. public class RadiusUtils {
    2.     public static final int TYPE_NONE = 0x0000;  // 没有圆角
    3.     public static final int TYPE_RADIUS = 0x0001;  // 圆角形状
    4.     public static final int TYPE_CIRCLE = 0x0002;  // 整体为圆形
    5.     public static final int TYPE_OVAL_LEFT = 0x0004;    // 左边为椭圆
    6.     public static final int TYPE_OVAL_TOP = 0x0008;    // 上边为椭圆
    7.     public static final int TYPE_OVAL_RIGHT = 0x0010;    // 右边为椭圆
    8.     public static final int TYPE_OVAL_BOTTOM = 0x0020;    // 下边为椭圆
    9.  
    10.     /**
    11.      * 计算背景路径 ConvexPath
    12.      * ConvexPath 这里简单理解：圆角矩形的圆角度数大于矩形的高度或宽度(上下圆角度数的边长和大于高度或者左右圆角度数的边长大于高度，那么就不是 ConvexPath 了)
    13.      *
    14.      * @param leftTopRadius     左上角圆角大小
    15.      * @param rightTopRadius    右上角圆角大小
    16.      * @param leftBottomRadius  左下角圆角大小
    17.      * @param rightBottomRadius 右下角圆角大小
    18.      * @param width             矩形宽
    19.      * @param height            矩形高
    20.      * @return 结果Path
    21.      */
    22.     public static Path calculateBgPath(int leftTopRadius, int rightTopRadius,
    23.                                        int leftBottomRadius, int rightBottomRadius,
    24.                                        int width, int height) {
    25.         return calculateBgPath(leftTopRadius, rightTopRadius, leftBottomRadius, rightBottomRadius, width, height, true);
    26.     }
    27.  
    28.     /**
    29.      * 计算背景路径 ConvexPath
    30.      * ConvexPath 这里简单理解：圆角矩形的圆角度数大于矩形的高度或宽度(上下圆角度数的边长和大于高度或者左右圆角度数的边长大于高度，那么就不是 ConvexPath 了)
    31.      *
    32.      * @param leftTopRadius     左上角圆角大小
    33.      * @param rightTopRadius    右上角圆角大小
    34.      * @param leftBottomRadius  左下角圆角大小
    35.      * @param rightBottomRadius 右下角圆角大小
    36.      * @param width             矩形宽
    37.      * @param height            矩形高
    38.      * @param isGetType         是否需要判断类型，当为 true 时可能返回非 Convex Path
    39.      * @return 结果Path
    40.      */
    41.     public static Path calculateBgPath(int leftTopRadius, int rightTopRadius,
    42.                                        int leftBottomRadius, int rightBottomRadius,
    43.                                        int width, int height, boolean isGetType) {
    44.         leftTopRadius = Math.max(leftTopRadius, 0);
    45.         rightTopRadius = Math.max(rightTopRadius, 0);
    46.         leftBottomRadius = Math.max(leftBottomRadius, 0);
    47.         rightBottomRadius = Math.max(rightBottomRadius, 0);
    48.         if (isGetType) {
    49.             int type = getType(leftTopRadius, rightTopRadius, leftBottomRadius, rightBottomRadius, width, height);
    50.             if (type == TYPE_NONE)
    51.                 return calculateRectBgPath(width, height);
    52.  
    53.             if (type == TYPE_RADIUS)
    54.                 return calculateRadiusBgPath(leftTopRadius, rightTopRadius, leftBottomRadius, rightBottomRadius, width, height);
    55.  
    56.             if (type == TYPE_CIRCLE) {
    57.                 Path resultPath = new Path();
    58.                 RectF rectF = new RectF();
    59.                 rectF.set(0, 0, width, height);
    60.                 resultPath.addCircle(rectF.centerX(), rectF.centerY(), Math.min(rectF.width(), rectF.height()) / 2f, Path.Direction.CW);
    61.                 return resultPath;
    62.             }
    63.  
    64.             Path resultPath = new Path();
    65.             if (((type & TYPE_OVAL_LEFT) != 0) && (type & TYPE_OVAL_RIGHT) != 0) {
    66.                 // 左右都半圆
    67.                 RectF arcRectF = new RectF();
    68.                 // 左边半圆
    69.                 arcRectF.set(0, 0, height, height);
    70.                 resultPath.addArc(arcRectF, 90, 180);
    71.                 // 上边的线
    72.                 resultPath.lineTo(width - height / 2f, 0);
    73.                 // 右边半圆
    74.                 RectF rightRectF = new RectF();
    75.                 rightRectF.set(width - height, 0, width, height);
    76.                 resultPath.addArc(rightRectF, -90, 180);
    77.                 // 下边的线
    78.                 resultPath.lineTo(height / 2f, height);
    79.             } else if (((type & TYPE_OVAL_TOP) != 0) && (type & TYPE_OVAL_BOTTOM) != 0) {
    80.                 // 上下都半圆
    81.                 RectF arcRectF = new RectF();
    82.                 // 上边半圆
    83.                 arcRectF.set(0, 0, width, width);
    84.                 resultPath.addArc(arcRectF, 180, 180);
    85.                 // 右边的线
    86.                 resultPath.lineTo(width, height - width / 2f);
    87.                 // 下边半圆
    88.                 RectF rightRectF = new RectF();
    89.                 rightRectF.set(0, height - width, width, height);
    90.                 resultPath.addArc(rightRectF, 0, 180);
    91.                 // 左边的线
    92.                 resultPath.lineTo(0, width / 2f);
    93.             } else if ((type & TYPE_OVAL_LEFT) != 0) {
    94.                 RectF arcRectF = new RectF();
    95.                 // 左半圆
    96.                 arcRectF.set(0, 0, height, height);
    97.                 resultPath.addArc(arcRectF, 90, 180);
    98.                 // 上边的线
    99.                 resultPath.lineTo(width - rightTopRadius, 0);
    100.                 // 右上角
    101.                 resultPath.quadTo(width, 0, width, rightTopRadius);
    102.                 // 右边线
    103.                 resultPath.lineTo(width, height - rightBottomRadius);
    104.                 // 右下角
    105.                 resultPath.quadTo(width, height, width - rightBottomRadius, height);
    106.                 // 下边的线
    107.                 resultPath.lineTo(height / 2f, height);
    108.             } else if ((type & TYPE_OVAL_RIGHT) != 0) {
    109.                 // 上边的线
    110.                 resultPath.moveTo(leftTopRadius, 0);
    111.                 resultPath.lineTo(width - height / 2f, 0);
    112.                 // 右边半圆
    113.                 RectF rightRectF = new RectF();
    114.                 rightRectF.set(width - height, 0, width, height);
    115.                 resultPath.addArc(rightRectF, -90, 180);
    116.                 // 下边线
    117.                 resultPath.lineTo(leftBottomRadius, height);
    118.                 // 左下角
    119.                 resultPath.quadTo(0, height, 0, height - leftBottomRadius);
    120.                 // 左边线
    121.                 resultPath.lineTo(0, leftTopRadius);
    122.                 // 左上角
    123.                 resultPath.quadTo(0, 0, leftTopRadius, 0);
    124.             } else if ((type & TYPE_OVAL_TOP) != 0) {
    125.                 RectF arcRectF = new RectF();
    126.                 // 上半圆
    127.                 arcRectF.set(0, 0, width, width);
    128.                 resultPath.addArc(arcRectF, 180, 180);
    129.                 // 右边的线
    130.                 resultPath.lineTo(width, height - rightBottomRadius);
    131.                 // 右下角
    132.                 resultPath.quadTo(width, height, width - rightBottomRadius, height);
    133.                 // 底部线
    134.                 resultPath.lineTo(leftBottomRadius, height);
    135.                 // 左下角
    136.                 resultPath.quadTo(0, height, 0, height - leftBottomRadius);
    137.                 // 左边的线
    138.                 resultPath.lineTo(0, width / 2f);
    139.             } else if ((type & TYPE_OVAL_BOTTOM) != 0) {
    140.                 // 上边线
    141.                 resultPath.moveTo(leftTopRadius, 0);
    142.                 resultPath.lineTo(width - rightTopRadius, 0);
    143.                 // 右上角
    144.                 resultPath.quadTo(width, 0, width, rightTopRadius);
    145.                 // 右边线
    146.                 resultPath.lineTo(width, height - width / 2f);
    147.                 // 下半圆
    148.                 RectF rightRectF = new RectF();
    149.                 rightRectF.set(0, height - width, width, height);
    150.                 resultPath.addArc(rightRectF, 0, 180);
    151.                 // 左边线
    152.                 resultPath.lineTo(0, leftTopRadius);
    153.                 // 左上角
    154.                 resultPath.quadTo(0, 0, leftTopRadius, 0);
    155.             } else {
    156.                 return calculateRadiusBgPath(leftTopRadius, rightTopRadius, leftBottomRadius, rightBottomRadius, width, height);
    157.             }
    158.  
    159.             return resultPath;
    160.         }
    161.  
    162.         return calculateRadiusBgPath(leftTopRadius, rightTopRadius, leftBottomRadius, rightBottomRadius, width, height);
    163.     }
    164.  
    165.     /**
    166.      * 计算圆角矩形背景路径
    167.      */
    168.     private static Path calculateRadiusBgPath(int leftTopRadius, int rightTopRadius, int leftBottomRadius,
    169.                                               int rightBottomRadius, int width, int height) {
    170.         float leftTopRadiusLeft, leftTopRadiusTop; // 左上角
    171.         float leftBottomRadiusLeft, leftBottomRadiusBottom; // 左下角
    172.         float rightTopRadiusRight, rightTopRadiusTop; // 右上角
    173.         float rightBottomRadiusRight, rightBottomRadiusBottom; // 右下角
    174.         int[] sideTop = calculateRadiusLength(leftTopRadius, rightTopRadius, width); // 上同边
    175.         int[] sideBottom = calculateRadiusLength(leftBottomRadius, rightBottomRadius, width); // 下同边
    176.         int[] sideLeft = calculateRadiusLength(leftTopRadius, leftBottomRadius, height); // 左同边
    177.         int[] sideRight = calculateRadiusLength(rightTopRadius, rightBottomRadius, height); // 右同边
    178.         leftTopRadiusTop = sideTop[0];
    179.         rightTopRadiusTop = sideTop[1];
    180.         leftBottomRadiusBottom = sideBottom[0];
    181.         rightBottomRadiusBottom = sideBottom[1];
    182.         leftTopRadiusLeft = sideLeft[0];
    183.         leftBottomRadiusLeft = sideLeft[1];
    184.         rightTopRadiusRight = sideRight[0];
    185.         rightBottomRadiusRight = sideRight[1];
    186.  
    187.         Path resultPath = new Path();
    188.         // 四个角：右上，右下，左下，左上
    189.         resultPath.moveTo(leftTopRadiusTop, 0);
    190.         resultPath.lineTo(width - rightTopRadiusTop, 0);
    191.         resultPath.quadTo(width, 0, width, rightTopRadiusRight);
    192.  
    193.         resultPath.lineTo(width, height - rightBottomRadiusRight);
    194.         resultPath.quadTo(width, height, width - rightBottomRadiusBottom, height);
    195.  
    196.         resultPath.lineTo(leftBottomRadiusBottom, height);
    197.         resultPath.quadTo(0, height, 0, height - leftBottomRadiusLeft);
    198.  
    199.         resultPath.lineTo(0, leftTopRadiusLeft);
    200.         resultPath.quadTo(0, 0, leftTopRadiusTop, 0);
    201.         return resultPath;
    202.     }
    203.  
    204.     /**
    205.      * 计算直角矩形背景路径
    206.      *
    207.      * @param width  宽
    208.      * @param height 高
    209.      */
    210.     private static Path calculateRectBgPath(int width, int height) {
    211.         Path result = new Path();
    212.         result.moveTo(0, 0);
    213.         result.lineTo(width, 0);
    214.         result.lineTo(width, height);
    215.         result.lineTo(0, height);
    216.         result.close();
    217.         return result;
    218.     }
    219.  
    220.     /**
    221.      * 计算边框的边框路径 ConvexPath
    222.      * ConvexPath 这里简单理解：圆角矩形的圆角度数大于矩形的高度或宽度(上下圆角度数的边长和大于高度或者左右圆角度数的边长大于高度，那么就不是 ConvexPath 了)
    223.      *
    224.      * @param leftTopRadius     左上角圆角大小
    225.      * @param rightTopRadius    右上角圆角大小
    226.      * @param leftBottomRadius  左下角圆角大小
    227.      * @param rightBottomRadius 右下角圆角大小
    228.      * @param width             矩形宽
    229.      * @param height            矩形高
    230.      * @param solidWidth        边框宽度
    231.      * @return 结果Path 数组，path[0]：四条边 path[1]：四个角的路径
    232.      */
    233.     public static Path[] calculateSocketPath(int leftTopRadius, int rightTopRadius,
    234.                                              int leftBottomRadius, int rightBottomRadius,
    235.                                              int width, int height, int solidWidth) {
    236.         leftTopRadius = Math.max(leftTopRadius, 0);
    237.         rightTopRadius = Math.max(rightTopRadius, 0);
    238.         leftBottomRadius = Math.max(leftBottomRadius, 0);
    239.         rightBottomRadius = Math.max(rightBottomRadius, 0);
    240.         int type = getType(leftTopRadius, rightTopRadius, leftBottomRadius, rightBottomRadius, width, height);
    241.  
    242.         if (type == TYPE_NONE)
    243.             return new Path[]{calculateRectSocketPath(width, height, solidWidth)};
    244.  
    245.         if (type == TYPE_RADIUS)
    246.             return calculateRadiusSocketPath(leftTopRadius, rightTopRadius, leftBottomRadius, rightBottomRadius, width, height, solidWidth);
    247.  
    248.         if (type == TYPE_CIRCLE) {
    249.             Path[] result = new Path[1];
    250.             Path resultPath = new Path();
    251.             RectF rectF = new RectF();
    252.             rectF.set(0, 0, width, height);
    253.             // 对位置进行偏移线宽的一半，因为直接画线的话，有一半是画到画布外的，
    254.             // 但是因为有圆角，圆角后面还有画布，导致角的线宽比边的线宽要宽
    255.             // 矩形缩小边框的一半
    256.             float newWidth = solidWidth / 2.0f;
    257.             rectF.inset(newWidth, newWidth);
    258.             resultPath.addCircle(rectF.centerX(), rectF.centerY(), Math.min(rectF.width(), rectF.height()) / 2f, Path.Direction.CW);
    259.             result[0] = resultPath;
    260.             return result;
    261.         }
    262.  
    263.  
    264.         Path[] result = new Path[1];
    265.         Path resultPath = new Path();
    266.         // 对位置进行偏移线宽的一半，因为直接画线的话，有一半是画到画布外的，
    267.         // 但是因为有圆角，圆角后面还有画布，导致角的线宽比边的线宽要宽
    268.         // 矩形缩小边框的一半
    269.         float newWidth = solidWidth / 2.0f;
    270.         if (((type & TYPE_OVAL_LEFT) != 0) && (type & TYPE_OVAL_RIGHT) != 0) {
    271.             // 左边半圆
    272.             RectF leftRectF = new RectF();
    273.             leftRectF.set(newWidth, newWidth, height, height - newWidth);
    274.             resultPath.addArc(leftRectF, 90, 180);
    275.             // 增加上边的线
    276.             resultPath.lineTo(width - height / 2f, newWidth);
    277.             // 右边半圆
    278.             RectF rightRectF = new RectF();
    279.             rightRectF.set(width - height, newWidth, width - newWidth, height - newWidth);
    280.             resultPath.addArc(rightRectF, -90, 180);
    281.             // 增加下边的线
    282.             resultPath.lineTo(height / 2f, height - newWidth);
    283.         } else if (((type & TYPE_OVAL_TOP) != 0) && (type & TYPE_OVAL_BOTTOM) != 0) {
    284.             // 上边半圆
    285.             RectF leftRectF = new RectF();
    286.             leftRectF.set(newWidth, newWidth, width - newWidth, width);
    287.             resultPath.addArc(leftRectF, 180, 180);
    288.             // 增加右边的线
    289.             resultPath.lineTo(width - newWidth, height - width / 2f);
    290.             // 下边半圆
    291.             RectF rightRectF = new RectF();
    292.             rightRectF.set(newWidth, height - width, width - newWidth, height - newWidth);
    293.             resultPath.addArc(rightRectF, 0, 180);
    294.             // 增加左边的线
    295.             resultPath.lineTo(newWidth, width / 2f);
    296.         } else if ((type & TYPE_OVAL_LEFT) != 0) {
    297.             // 左半圆
    298.             RectF arcRectF = new RectF();
    299.             arcRectF.set(newWidth, newWidth, height, height - newWidth);
    300.             resultPath.addArc(arcRectF, 90, 180);
    301.             // 上边的线
    302.             resultPath.lineTo(width - rightTopRadius, newWidth);
    303.             // 右上角
    304.             resultPath.quadTo(width, newWidth, width - newWidth, rightTopRadius);
    305.             // 右边线
    306.             resultPath.lineTo(width - newWidth, height - rightBottomRadius);
    307.             // 右下角
    308.             resultPath.quadTo(width - newWidth, height - newWidth, width - rightBottomRadius, height - newWidth);
    309.             // 下边的线
    310.             resultPath.lineTo(height / 2f, height - newWidth);
    311.         } else if ((type & TYPE_OVAL_RIGHT) != 0) {
    312.             // 上边的线
    313.             resultPath.moveTo(leftTopRadius, newWidth);
    314.             resultPath.lineTo(width - height / 2f, newWidth);
    315.             // 右边半圆
    316.             RectF rightRectF = new RectF();
    317.             rightRectF.set(width - height, newWidth, width - newWidth, height - newWidth);
    318.             resultPath.addArc(rightRectF, -90, 180);
    319.             // 下边线
    320.             resultPath.lineTo(leftBottomRadius, height - newWidth);
    321.             // 左下角
    322.             resultPath.quadTo(newWidth, height - newWidth, newWidth, height - leftBottomRadius);
    323.             // 左边线
    324.             resultPath.lineTo(newWidth, leftTopRadius);
    325.             // 左上角
    326.             resultPath.quadTo(newWidth, newWidth, leftTopRadius, newWidth);
    327.         } else if ((type & TYPE_OVAL_TOP) != 0) {
    328.             // 上半圆
    329.             RectF arcRectF = new RectF();
    330.             arcRectF.set(newWidth, newWidth, width - newWidth, width);
    331.             resultPath.addArc(arcRectF, 180, 180);
    332.             // 右边的线
    333.             resultPath.lineTo(width - newWidth, height - rightBottomRadius);
    334.             // 右下角
    335.             resultPath.quadTo(width - newWidth, height - newWidth, width - rightBottomRadius, height - newWidth);
    336.             // 底部线
    337.             resultPath.lineTo(leftBottomRadius, height - newWidth);
    338.             // 左下角
    339.             resultPath.quadTo(newWidth, height - newWidth, newWidth, height - leftBottomRadius);
    340.             // 左边的线
    341.             resultPath.lineTo(newWidth, width / 2f);
    342.         } else if ((type & TYPE_OVAL_BOTTOM) != 0) {
    343.             // 上边线
    344.             resultPath.moveTo(leftTopRadius, newWidth);
    345.             resultPath.lineTo(width - rightTopRadius, newWidth);
    346.             // 右上角
    347.             resultPath.quadTo(width, newWidth, width - newWidth, rightTopRadius);
    348.             // 右边线
    349.             resultPath.lineTo(width - newWidth, height - width / 2f);
    350.             // 下半圆
    351.             RectF rightRectF = new RectF();
    352.             rightRectF.set(newWidth, height - width, width - newWidth, height - newWidth);
    353.             resultPath.addArc(rightRectF, 0, 180);
    354.             // 左边线
    355.             resultPath.lineTo(newWidth, leftTopRadius);
    356.             // 左上角
    357.             resultPath.quadTo(newWidth, newWidth, leftTopRadius, newWidth);
    358.         } else {
    359.             return calculateRadiusSocketPath(leftTopRadius, rightTopRadius, leftBottomRadius, rightBottomRadius, width, height, solidWidth);
    360.         }
    361.  
    362.         result[0] = resultPath;
    363.         return result;
    364.     }
    365.  
    366.     /**
    367.      * 计算圆角矩形的边框路径
    368.      */
    369.     private static Path[] calculateRadiusSocketPath(int leftTopRadius, int rightTopRadius,
    370.                                                     int leftBottomRadius, int rightBottomRadius,
    371.                                                     int width, int height, int solidWidth) {
    372.         Path[] result = new Path[2];
    373.         Path solidPath = new Path();
    374.         Path radiusPath = new Path();
    375.  
    376.         float leftTopRadiusLeft, leftTopRadiusTop; // 左上角
    377.         float leftBottomRadiusLeft, leftBottomRadiusBottom; // 左下角
    378.         float rightTopRadiusRight, rightTopRadiusTop; // 右上角
    379.         float rightBottomRadiusRight, rightBottomRadiusBottom; // 右下角
    380.         int[] sideTop = calculateRadiusLength(leftTopRadius, rightTopRadius, width); // 上同边
    381.         int[] sideBottom = calculateRadiusLength(leftBottomRadius, rightBottomRadius, width); // 下同边
    382.         int[] sideLeft = calculateRadiusLength(leftTopRadius, leftBottomRadius, height); // 左同边
    383.         int[] sideRight = calculateRadiusLength(rightTopRadius, rightBottomRadius, height); // 右同边
    384.         leftTopRadiusTop = sideTop[0];
    385.         rightTopRadiusTop = sideTop[1];
    386.         leftBottomRadiusBottom = sideBottom[0];
    387.         rightBottomRadiusBottom = sideBottom[1];
    388.         leftTopRadiusLeft = sideLeft[0];
    389.         leftBottomRadiusLeft = sideLeft[1];
    390.         rightTopRadiusRight = sideRight[0];
    391.         rightBottomRadiusRight = sideRight[1];
    392.  
    393.         // 对位置进行偏移线宽的一半，因为直接画线的话，有一半是画到画布外的，
    394.         // 但是因为有圆角，圆角后面还有画布，导致角的线宽比边的线宽要宽
    395.         float newWidth = solidWidth / 2.0f;
    396.         // 四条边路径
    397.         solidPath.moveTo(leftTopRadiusTop, newWidth);
    398.         solidPath.lineTo(width - rightTopRadiusTop, newWidth);
    399.  
    400.         solidPath.moveTo(width - newWidth, rightTopRadiusRight);
    401.         solidPath.lineTo(width - newWidth, height - rightBottomRadiusRight);
    402.  
    403.         solidPath.moveTo(width - rightBottomRadiusBottom, height - newWidth);
    404.         solidPath.lineTo(leftBottomRadiusBottom, height - newWidth);
    405.  
    406.         solidPath.moveTo(newWidth, height - leftBottomRadiusLeft);
    407.         solidPath.lineTo(newWidth, leftTopRadiusLeft);
    408.  
    409.         // 四个角路径
    410.         radiusPath.moveTo(newWidth, leftTopRadiusLeft);
    411.         radiusPath.quadTo(newWidth, newWidth, leftTopRadiusTop, newWidth);
    412.  
    413.         radiusPath.moveTo(width - rightTopRadiusTop, newWidth);
    414.         radiusPath.quadTo(width, newWidth, width - newWidth, rightTopRadiusRight);
    415.  
    416.         radiusPath.moveTo(width - newWidth, height - rightBottomRadiusRight);
    417.         radiusPath.quadTo(width - newWidth, height - newWidth, width - rightBottomRadiusBottom, height - newWidth);
    418.  
    419.         radiusPath.moveTo(leftBottomRadiusBottom, height - newWidth);
    420.         radiusPath.quadTo(newWidth, height - newWidth, newWidth, height - leftBottomRadiusLeft);
    421.  
    422.         result[0] = solidPath;
    423.         result[1] = radiusPath;
    424.         return result;
    425.     }
    426.  
    427.     /**
    428.      * 计算直角矩形边框路径
    429.      *
    430.      * @param width      宽
    431.      * @param height     高
    432.      * @param solidWidth 线宽
    433.      * @return
    434.      */
    435.     public static Path calculateRectSocketPath(int width, int height, int solidWidth) {
    436.         float newWidth = solidWidth / 2.0f;
    437.         Path result = new Path();
    438.         result.moveTo(newWidth, newWidth);
    439.         result.lineTo(width - newWidth, newWidth);
    440.         result.lineTo(width - newWidth, height - newWidth);
    441.         result.lineTo(newWidth, height - newWidth);
    442.         result.close();
    443.         return result;
    444.     }
    445.  
    446.     /**
    447.      * 根据圆角大小和边框长度将圆角矩形作为什么图形处理
    448.      *
    449.      * @return TYPE_CIRCLE：圆形  TYPE_RADIUS：圆角矩形  TYPE_OVAL：两端作为椭圆
    450.      */
    451.     private static int getType(int leftTopRadius, int rightTopRadius,
    452.                                int leftBottomRadius, int rightBottomRadius,
    453.                                int width, int height) {
    454.  
    455.         // 没有圆角
    456.         if (leftTopRadius <= 0 && rightTopRadius <= 0 && leftBottomRadius <= 0 && rightBottomRadius <= 0)
    457.             return TYPE_NONE;
    458.  
    459.         boolean topOval = leftTopRadius + rightTopRadius >= width;
    460.         boolean bottomOval = leftBottomRadius + rightBottomRadius >= width;
    461.         boolean leftOval = leftTopRadius + leftBottomRadius >= height;
    462.         boolean rightOval = rightTopRadius + rightBottomRadius >= height;
    463.  
    464.         // 变为原型
    465.         if (topOval && bottomOval && leftOval && rightOval)
    466.             return TYPE_CIRCLE;
    467.  
    468.         // 变为圆角矩形
    469.         if (!topOval && !bottomOval && !leftOval && !rightOval)
    470.             return TYPE_RADIUS;
    471.         if ((topOval || bottomOval) && (leftOval || rightOval)) return TYPE_RADIUS;
    472.  
    473.         // 处理半圆
    474.         int result = TYPE_NONE;
    475.         if (topOval) {
    476.             result |= TYPE_OVAL_TOP;
    477.         }
    478.  
    479.         if (bottomOval) {
    480.             result |= TYPE_OVAL_BOTTOM;
    481.         }
    482.  
    483.         if (leftOval) {
    484.             result |= TYPE_OVAL_LEFT;
    485.         }
    486.  
    487.         if (rightOval) {
    488.             result |= TYPE_OVAL_RIGHT;
    489.         }
    490.  
    491.         return result;
    492.     }
    493.  
    494.     /**
    495.      * 根据同边的两个圆角的分别长度和边的长度，重新计算两个圆角该有的长度(防止两个圆角的同边长度之后大于总的长度)
    496.      * 如：给出左上角上边的长度和右上角上边的长度，以及矩形的上边边长(矩形的长)，重新计算出左上角上边的长度和右上角上边的长度，
    497.      * 防止左上角上边的长度和右上角上边的长度之和大于边长导致出错，如果大于边长时，根据比例计算。
    498.      *
    499.      * @param sameSide1     同边第一个值的原大小
    500.      * @param sameSide2     同边第二个值的原大小
    501.      * @param sameSideWidth 同边长度
    502.      * @return int[]，长度为2，int[0]：同边第一个值的最终大小 int[1]：同边第二个值的最终大小
    503.      */
    504.     private static int[] calculateRadiusLength(int sameSide1, int sameSide2, int sameSideWidth) {
    505.         int[] result = new int[2];
    506.         if (sameSide1 > 0 && sameSide2 > 0) {
    507.             int topRadiusWidth = sameSide1 + sameSide2;
    508.             if (topRadiusWidth > sameSideWidth) {
    509.                 result[0] = (int) ((sameSide1 * 1.0 / topRadiusWidth) * sameSideWidth);
    510.                 result[1] = (int) ((sameSide2 * 1.0 / topRadiusWidth) * sameSideWidth);
    511.             } else {
    512.                 result[0] = sameSide1;
    513.                 result[1] = sameSide2;
    514.             }
    515.         } else if (sameSide1 > 0) {
    516.             result[0] = Math.min(sameSide1, sameSideWidth);
    517.         } else if (sameSide2 > 0) {
    518.             result[1] = Math.min(sameSide2, sameSideWidth);
    519.         }
    520.         return result;
    521.     }
    522. }

    4. 解决锯齿问题  自定义Drawable

    RadiusDrawable

    1. public class RadiusDrawable extends Drawable {
    2.     // 背景颜色相关
    3.     private ColorStateList mBgColorsList;
    4.     private Shader mBgShader; // 渐变优先级更高
    5.     private Path mBgPath;
    6.     private Paint mBgPaint;
    7.     private PorterDuffColorFilter mBgTintFilter;
    8.     private ColorStateList mBgTint;
    9.     private PorterDuff.Mode mBgTintMode;
    10.     // 边框线相关
    11.     private boolean mDrawSolid;
    12.     private ColorStateList mSolidColorsList;
    13.     private Shader mSolidShader; // 渐变优先级更高
    14.     private List mSolidPath;
    15.     private Paint mSolidPaint;
    16.     private PorterDuffColorFilter mSolidTintFilter;
    17.     private ColorStateList mSolidTint;
    18.     private PorterDuff.Mode mSolidTintMode;
    19.  
    20.     public RadiusDrawable(ColorStateList bgColorsList, Shader bgShader, Path path) {
    21.         this(bgColorsList, bgShader, path, 0, null, null, null, null);
    22.     }
    23.  
    24.     public RadiusDrawable(ColorStateList bgColorsList, Shader bgShader, Path path, int solidWidth, ColorStateList solidColorsList,
    25.                           Shader solidShader, List solidPath, DashPathEffect dashPathEffect) {
    26.         this.mBgPath = path;
    27.         this.mBgTintMode = PorterDuff.Mode.SRC_IN;
    28.         this.mBgPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    29.         this.mBgPaint.setDither(true);
    30.         this.mBgShader = bgShader;
    31.  
    32.         this.mDrawSolid = solidWidth > 0;
    33.         if (mDrawSolid) {
    34.             this.mSolidPath = solidPath == null ? new ArrayList() : solidPath;
    35.             this.mSolidTintMode = PorterDuff.Mode.SRC_IN;
    36.             this.mSolidPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    37.             this.mSolidPaint.setAntiAlias(true);
    38.             this.mSolidPaint.setDither(true);
    39.             this.mSolidPaint.setStyle(Paint.Style.STROKE);
    40.             this.mSolidPaint.setStrokeWidth(solidWidth);
    41.             this.mSolidPaint.setPathEffect(dashPathEffect);
    42.             this.mSolidShader = solidShader;
    43.         }
    44.  
    45.         this.setBackground(bgColorsList, solidColorsList);
    46.     }
    47.  
    48.     void setBgShader(Shader shader) {
    49.         if (shader != null) {
    50.             this.mBgShader = shader;
    51.             this.invalidateSelf();
    52.         }
    53.     }
    54.  
    55.     void setBackground(ColorStateList bgColorsList, ColorStateList solidColorsList) {
    56.         if (mBgShader == null) {
    57.             this.mBgColorsList = bgColorsList == null ? ColorStateList.valueOf(0) : bgColorsList;
    58.             this.mBgPaint.setColor(this.mBgColorsList.getColorForState(this.getState(), this.mBgColorsList.getDefaultColor()));
    59.         }
    60.         if (mDrawSolid && mSolidShader == null) {
    61.             this.mSolidColorsList = solidColorsList == null ? ColorStateList.valueOf(0) : solidColorsList;
    62.             this.mSolidPaint.setColor(this.mSolidColorsList.getColorForState(this.getState(), this.mSolidColorsList.getDefaultColor()));
    63.         }
    64.     }
    65.  
    66.     @Override
    67.     public void draw(Canvas canvas) {
    68.         Paint bgPaint = this.mBgPaint;
    69.         boolean bgClearColorFilter = false;
    70.         boolean hasBgShader = mBgShader != null;
    71.         if (hasBgShader) {
    72.             bgPaint.setShader(mBgShader);
    73.         } else {
    74.             if (this.mBgTintFilter != null) {
    75.                 bgPaint.setColorFilter(this.mBgTintFilter);
    76.                 bgClearColorFilter = true;
    77.             } else {
    78.                 bgClearColorFilter = false;
    79.             }
    80.         }
    81.         canvas.setDrawFilter(new PaintFlagsDrawFilter(0, Paint.ANTI_ALIAS_FLAG|Paint.FILTER_BITMAP_FLAG));
    82.         canvas.drawPath(mBgPath, bgPaint);
    83.         if (bgClearColorFilter) {
    84.             bgPaint.setColorFilter(null);
    85.         }
    86.  
    87.  
    88.         if (mDrawSolid) {
    89.             Paint solidPaint = this.mSolidPaint;
    90.             boolean solidClearColorFilter = false;
    91.             boolean hasSolidShader = mSolidShader != null;
    92.             if (hasSolidShader) {
    93.                 solidPaint.setShader(mSolidShader);
    94.             } else {
    95.                 if (this.mSolidTintFilter != null) {
    96.                     solidPaint.setColorFilter(this.mSolidTintFilter);
    97.                     solidClearColorFilter = true;
    98.                 } else {
    99.                     solidClearColorFilter = false;
    100.                 }
    101.             }
    102.  
    103.             for (Path solidPath : mSolidPath) {
    104.                 canvas.drawPath(solidPath, solidPaint);
    105.             }
    106.             if (solidClearColorFilter) {
    107.                 solidPaint.setColorFilter(null);
    108.             }
    109.         }
    110.  
    111.     }
    112.  
    113.     @Override
    114.     public void setAlpha(int alpha) {
    115.         if (mBgShader == null) {
    116.             this.mBgPaint.setAlpha(alpha);
    117.         }
    118.  
    119.         if (mDrawSolid) {
    120.             this.mSolidPaint.setAlpha(alpha);
    121.         }
    122.     }
    123.  
    124.     @Override
    125.     public void setColorFilter(ColorFilter cf) {
    126.         if (mBgShader == null) {
    127.             this.mBgPaint.setColorFilter(cf);
    128.         }
    129.  
    130.         if (mDrawSolid) {
    131.             this.mSolidPaint.setColorFilter(cf);
    132.         }
    133.     }
    134.  
    135.     @Override
    136.     public int getOpacity() {
    137.         return PixelFormat.TRANSLUCENT;
    138.     }
    139.  
    140.     public void setColor(@Nullable ColorStateList backgroundColor, @Nullable ColorStateList solidColorsList) {
    141.         this.setBackground(backgroundColor, solidColorsList);
    142.         this.invalidateSelf();
    143.     }
    144.  
    145.     public ColorStateList getBackGroundColor() {
    146.         return this.mBgColorsList;
    147.     }
    148.  
    149.     public ColorStateList getSolidColor() {
    150.         return this.mSolidColorsList;
    151.     }
    152.  
    153.     @Override
    154.     public void setTintList(ColorStateList tint) {
    155.         if (mBgShader == null) {
    156.             this.mBgTint = tint;
    157.             this.mBgTintFilter = this.createTintFilter(this.mBgTint, this.mBgTintMode);
    158.         }
    159.  
    160.         if (mDrawSolid) {
    161.             this.mSolidTint = tint;
    162.             this.mSolidTintFilter = this.createTintFilter(this.mSolidTint, this.mSolidTintMode);
    163.         }
    164.  
    165.         this.invalidateSelf();
    166.     }
    167.  
    168.     @Override
    169.     public void setTintMode(PorterDuff.Mode tintMode) {
    170.         if (mBgShader == null) {
    171.             this.mBgTintMode = tintMode;
    172.             this.mBgTintFilter = this.createTintFilter(this.mBgTint, this.mSolidTintMode);
    173.         }
    174.  
    175.         if (mDrawSolid && mSolidShader == null) {
    176.             this.mSolidTintMode = tintMode;
    177.             this.mSolidTintFilter = this.createTintFilter(this.mBgTint, this.mSolidTintMode);
    178.         }
    179.  
    180.         this.invalidateSelf();
    181.     }
    182.  
    183.     @Override
    184.     protected boolean onStateChange(int[] stateSet) {
    185.         boolean bgColorChanged = false;
    186.         if (mBgShader == null) {
    187.             int newBgColor = this.mBgColorsList.getColorForState(stateSet, this.mBgColorsList.getDefaultColor());
    188.             bgColorChanged = newBgColor != this.mBgPaint.getColor();
    189.             if (bgColorChanged) {
    190.                 this.mBgPaint.setColor(newBgColor);
    191.             }
    192.         }
    193.  
    194.         boolean solidColorChanged = false;
    195.         if (mDrawSolid && mSolidShader == null) {
    196.             int newSolidColor = this.mSolidColorsList.getColorForState(stateSet, this.mSolidColorsList.getDefaultColor());
    197.             solidColorChanged = newSolidColor != this.mSolidPaint.getColor();
    198.             if (solidColorChanged) {
    199.                 this.mSolidPaint.setColor(newSolidColor);
    200.             }
    201.         }
    202.  
    203.  
    204.         if (this.mBgShader == null && this.mBgTint != null && this.mBgTintMode != null) {
    205.             this.mBgTintFilter = this.createTintFilter(this.mBgTint, this.mBgTintMode);
    206.             this.invalidateSelf();
    207.             return true;
    208.         } else if (this.mSolidShader == null && this.mSolidTint != null && this.mSolidTintMode != null) {
    209.             this.mSolidTintFilter = this.createTintFilter(this.mSolidTint, this.mSolidTintMode);
    210.             return true;
    211.         } else {
    212.             return bgColorChanged || solidColorChanged;
    213.         }
    214.     }
    215.  
    216.     @Override
    217.     public boolean isStateful() {
    218.         if (mDrawSolid) {
    219.             return this.mBgTint != null && this.mBgTint.isStateful()
    220.                     || this.mBgColorsList != null && this.mBgColorsList.isStateful()
    221.                     || this.mSolidTint != null && this.mSolidTint.isStateful()
    222.                     || this.mSolidColorsList != null && this.mSolidColorsList.isStateful()
    223.                     || super.isStateful();
    224.         } else {
    225.             return this.mBgTint != null && this.mBgTint.isStateful()
    226.                     || this.mBgColorsList != null && this.mBgColorsList.isStateful()
    227.                     || super.isStateful();
    228.         }
    229.     }
    230.  
    231.     private PorterDuffColorFilter createTintFilter(ColorStateList tint, PorterDuff.Mode tintMode) {
    232.         if (tint != null && tintMode != null) {
    233.             int color = tint.getColorForState(this.getState(), 0);
    234.             return new PorterDuffColorFilter(color, tintMode);
    235.         } else {
    236.             return null;
    237.         }
    238.     }
    239. }

    4.1创建attrs自定义属性

    1.  
    2.     <declare-styleable name="RadiusView">
    3.         
    4.         <attr name="rv_radius_all" format="dimension" />
    5.         <attr name="rv_radius_leftTop" format="dimension" />
    6.         <attr name="rv_radius_rightTop" format="dimension" />
    7.         <attr name="rv_radius_rightBottom" format="dimension" />
    8.         <attr name="rv_radius_leftBottom" format="dimension" />
    9.  
    10.         
    11.         <attr name="rv_background_color" format="color" />
    12.         
    13.         <attr name="rv_shader_start_color" format="color" />
    14.         <attr name="rv_shader_middle_color" format="color" />
    15.         <attr name="rv_shader_middle_color2" format="color" />
    16.         <attr name="rv_shader_middle_color3" format="color" />
    17.         <attr name="rv_shader_end_color" format="color" />
    18.         
    19.         <attr name="rv_shader_type" format="enum">
    20.             <enum name="linear" value="10" />
    21.             <enum name="radial" value="11" />
    22.             <enum name="sweep" value="12" />
    23.         attr>
    24.         
    25.         <attr name="rv_shader_linear_orientation" format="enum">
    26.             <enum name="top_to_bottom" value="110" />
    27.             <enum name="bottom_to_top" value="111" />
    28.             <enum name="left_to_right" value="220" />
    29.             <enum name="right_to_left" value="221" />
    30.             <enum name="leftTop_to_rightBottom" value="330" />
    31.             <enum name="rightBottom_to_leftTop" value="331" />
    32.             <enum name="rightTop_to_leftBottom" value="440" />
    33.             <enum name="leftBottom_to_rightTop" value="441" />
    34.         attr>
    35.  
    36.         
    37.         <attr name="rv_solid_width" format="dimension" />
    38.         <attr name="rv_solid_color" format="color" />
    39.         
    40.         <attr name="rv_solid_dashWidth" format="dimension" />
    41.         
    42.         <attr name="rv_solid_dashGap" format="dimension" />
    43.         
    44.         <attr name="rv_solid_type" format="enum">
    45.             
    46.             <enum name="solid" value="0" />
    47.             
    48.             <enum name="dash" value="1" />
    49.         attr>
    50.         
    51.         <attr name="rv_solid_shader_start_color" format="color" />
    52.         <attr name="rv_solid_shader_middle_color" format="color" />
    53.         <attr name="rv_solid_shader_middle_color2" format="color" />
    54.         <attr name="rv_solid_shader_middle_color3" format="color" />
    55.         <attr name="rv_solid_shader_end_color" format="color" />
    56.         
    57.         <attr name="rv_solid_shader_type" format="enum">
    58.             <enum name="linear" value="10" />
    59.             <enum name="radial" value="11" />
    60.             <enum name="sweep" value="12" />
    61.         attr>
    62.         
    63.         <attr name="rv_solid_shader_linear_orientation" format="enum">
    64.             <enum name="top_to_bottom" value="110" />
    65.             <enum name="bottom_to_top" value="111" />
    66.             <enum name="left_to_right" value="220" />
    67.             <enum name="right_to_left" value="221" />
    68.             <enum name="leftTop_to_rightBottom" value="330" />
    69.             <enum name="rightBottom_to_leftTop" value="331" />
    70.             <enum name="rightTop_to_leftBottom" value="440" />
    71.             <enum name="leftBottom_to_rightTop" value="441" />
    72.         attr>
    73.     declare-styleable>

    4.2创建自动适配布局  公共接口IAutoLayout

    1. public interface IAutoLayout {
    2.     int AUTO_TYPE_WIDTH = 0;
    3.     int AUTO_TYPE_HEIGHT = 1;
    4.  
    5.     @IntDef(value = {AUTO_TYPE_WIDTH, AUTO_TYPE_HEIGHT})
    6.     @interface AutoType {
    7.     }
    8.  
    9.     /**
    10.      * 设置控件宽高信息，并重新布局
    11.      *
    12.      * @param autoWidth
    13.      * @param autoHeight
    14.      */
    15.     void setAutoViewInfo(int autoWidth, int autoHeight);
    16.  
    17.     /**
    18.      * 设置控件宽高信息，并重新布局
    19.      *
    20.      * @param autoWidth
    21.      * @param autoHeight
    22.      */
    23.     void setAutoViewInfo(@AutoType int autoType, int autoWidth, int autoHeight);
    24. }

    4.3创建账单适配布局AutoRelativeLayout

    1. public class AutoRelativeLayout extends RelativeLayout implements IAutoLayout {
    2.     // 自动适配的类型，0：宽适配 1：高适配
    3.     private int auto_type = 1;
    4.     private int auto_width;
    5.     private int auto_height;
    6.  
    7.     public AutoRelativeLayout(Context context) {
    8.         this(context, null);
    9.     }
    10.  
    11.     public AutoRelativeLayout(Context context, AttributeSet attrs) {
    12.         this(context, attrs, 0);
    13.     }
    14.  
    15.     public AutoRelativeLayout(Context context, AttributeSet attrs, int defStyleAttr) {
    16.         super(context, attrs, defStyleAttr);
    17.         init(context, attrs);
    18.     }
    19.  
    20.     @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    21.     public AutoRelativeLayout(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    22.         super(context, attrs, defStyleAttr, defStyleRes);
    23.         init(context, attrs);
    24.     }
    25.  
    26.     protected void init(Context context, AttributeSet attrs) {
    27.         TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.AutoWidthHeightView);
    28.         auto_height = typedArray.getInt(R.styleable.AutoWidthHeightView_auto_view_height, 0);
    29.         auto_width = typedArray.getInt(R.styleable.AutoWidthHeightView_auto_view_width, 0);
    30.         auto_type = typedArray.getInt(R.styleable.AutoWidthHeightView_auto_view_type, -1);
    31.         typedArray.recycle();
    32.     }
    33.  
    34.     /**
    35.      * @docRoot
    36.      */
    37.     @Override
    38.     public void setAutoViewInfo(int autoWidth, int autoHeight) {
    39.         this.auto_width = autoWidth;
    40.         this.auto_height = autoHeight;
    41.         requestLayout();
    42.     }
    43.  
    44.     /**
    45.      * @docRoot
    46.      */
    47.     @Override
    48.     public void setAutoViewInfo(@AutoType int autoType, int autoWidth, int autoHeight) {
    49.         this.auto_type = autoType;
    50.         this.auto_width = autoWidth;
    51.         this.auto_height = autoHeight;
    52.         requestLayout();
    53.     }
    54.  
    55.     @Override
    56.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    57.         if (auto_type == -1) {
    58.             super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    59.         } else {
    60.             setMeasuredDimension(getDefaultSize(0, widthMeasureSpec), getDefaultSize(0, heightMeasureSpec));
    61.             measureChildren(widthMeasureSpec, heightMeasureSpec);
    62.             int viewWidth = getMeasuredWidth();
    63.             int viewHeight = getMeasuredHeight();
    64.             switch (auto_type) {
    65.                 case 0: // 动态计算出控件宽
    66.                     viewWidth = (int) (viewHeight * ((auto_width * 1.0f) / auto_height));
    67.                     break;
    68.                 case 1: // 动态计算出控件高
    69.                     viewHeight = (int) (viewWidth * ((auto_height * 1.0f) / auto_width));
    70.                     break;
    71.             }
    72.             widthMeasureSpec = MeasureSpec.makeMeasureSpec(viewWidth, MeasureSpec.EXACTLY);
    73.             heightMeasureSpec = MeasureSpec.makeMeasureSpec(viewHeight, MeasureSpec.EXACTLY);
    74.             super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    75.         }
    76.     }
    77. }

    其他AutoLinearLayout，AutoImageView，AutoFrameLayout布局

    都是一样的

    4.4创建自定义布局适配attrs

    1.  
    2.     <declare-styleable name="AutoWidthHeightView">
    3.         <attr name="auto_view_width" format="integer" />
    4.         <attr name="auto_view_height" format="integer" />
    5.         <attr name="auto_view_type" format="enum">
    6.             <enum name="auto_view_width" value="0" />
    7.             <enum name="auto_view_height" value="1" />
    8.         attr>
    9.     declare-styleable>

    5.圆角相对布局 RadiusRelativeLayout

    1. public class RadiusRelativeLayout extends AutoRelativeLayout implements IRadiusLayout {
    2.     // 控件宽高
    3.     private int width, height;
    4.     // 圆角参数
    5.     private int leftTopRadius;
    6.     private int rightTopRadius;
    7.     private int rightBottomRadius;
    8.     private int leftBottomRadius;
    9.  
    10.     private RadiusDrawable radiusDrawable;
    11.     private ColorStateList bgColorStateList;
    12.     // 渐变背景
    13.     private int[] bgShaderColors; // 背景渐变颜色值，优先级高于 bgColorStateList
    14.     private int bgShaderType; // 渐变类型
    15.     private int bgShaderLinearOrientation; // 线性渐变方向
    16.  
    17.     // 边框参数
    18.     private int solidWidth;
    19.     private ColorStateList solidColorStateList;
    20.     private DashPathEffect dashPathEffect = null;
    21.     // 渐变边框
    22.     private int[] solidShaderColors; // 边框渐变颜色值，优先级高于 bgColorStateList
    23.     private int solidShaderType; // 边框类型
    24.     private int solidShaderLinearOrientation; // 线性渐变方向
    25.     // 是否需要强制重新布局
    26.     private boolean forceRefreshLayout;
    27.  
    28.     public RadiusRelativeLayout(Context context) {
    29.         this(context, null);
    30.     }
    31.  
    32.     public RadiusRelativeLayout(Context context, AttributeSet attrs) {
    33.         this(context, attrs, 0);
    34.     }
    35.  
    36.     public RadiusRelativeLayout(Context context, AttributeSet attrs, int defStyleAttr) {
    37.         super(context, attrs, defStyleAttr);
    38.         init(context, attrs);
    39.     }
    40.  
    41.     @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    42.     public RadiusRelativeLayout(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    43.         super(context, attrs, defStyleAttr, defStyleRes);
    44.         init(context, attrs);
    45.     }
    46.  
    47.     @Override
    48.     protected void init(Context context, AttributeSet attrs) {
    49.         super.init(context, attrs);
    50.         setWillNotDraw(false);
    51.         if (Build.VERSION.SDK_INT < 18) setLayerType(View.LAYER_TYPE_SOFTWARE, null);
    52.         // 读取圆角配置
    53.         TypedArray radiusType = context.obtainStyledAttributes(attrs, R.styleable.RadiusView);
    54.         int radius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_all, DEFAULT_RADIUS);
    55.         leftTopRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_leftTop, DEFAULT_RADIUS);
    56.         rightTopRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_rightTop, DEFAULT_RADIUS);
    57.         rightBottomRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_rightBottom, DEFAULT_RADIUS);
    58.         leftBottomRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_leftBottom, DEFAULT_RADIUS);
    59.  
    60.         // 获取背景信息
    61.         bgColorStateList = radiusType.getColorStateList(R.styleable.RadiusView_rv_background_color);
    62.         int startColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_start_color, ShaderUtils.COLOR_VALUE_NONE);
    63.         int middleColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_middle_color, ShaderUtils.COLOR_VALUE_NONE);
    64.         int middleColor2 = radiusType.getColor(R.styleable.RadiusView_rv_shader_middle_color2, ShaderUtils.COLOR_VALUE_NONE);
    65.         int middleColor3 = radiusType.getColor(R.styleable.RadiusView_rv_shader_middle_color3, ShaderUtils.COLOR_VALUE_NONE);
    66.         int endColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_end_color, ShaderUtils.COLOR_VALUE_NONE);
    67.         bgShaderType = radiusType.getInt(R.styleable.RadiusView_rv_shader_type, ShaderUtils.SHADER_TYPE_NONE);
    68.         bgShaderLinearOrientation = radiusType.getInt(R.styleable.RadiusView_rv_shader_linear_orientation, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    69.         bgShaderColors = ShaderUtils.createColorsArray(startColor, middleColor, middleColor2, middleColor3, endColor);
    70.         if (bgShaderColors == null)
    71.             bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    72.  
    73.  
    74.         // 获取边框信息
    75.         solidWidth = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_width, 0);
    76.         solidColorStateList = radiusType.getColorStateList(R.styleable.RadiusView_rv_solid_color);
    77.         int dashGap = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_dashGap, 0);
    78.         int dashWidth = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_dashWidth, 0);
    79.         int lineType = radiusType.getInt(R.styleable.RadiusView_rv_solid_type, SOLID_TYPE_SOLID);
    80.         int solidStartColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_start_color, ShaderUtils.COLOR_VALUE_NONE);
    81.         int solidMiddleColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_middle_color, ShaderUtils.COLOR_VALUE_NONE);
    82.         int solidMiddleColor2 = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_middle_color2, ShaderUtils.COLOR_VALUE_NONE);
    83.         int solidMiddleColor3 = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_middle_color3, ShaderUtils.COLOR_VALUE_NONE);
    84.         int solidEndColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_end_color, ShaderUtils.COLOR_VALUE_NONE);
    85.         solidShaderType = radiusType.getInt(R.styleable.RadiusView_rv_solid_shader_type, ShaderUtils.SHADER_TYPE_NONE);
    86.         solidShaderLinearOrientation = radiusType.getInt(R.styleable.RadiusView_rv_solid_shader_linear_orientation, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    87.         solidShaderColors = ShaderUtils.createColorsArray(solidStartColor, solidMiddleColor, solidMiddleColor2, solidMiddleColor3, solidEndColor);
    88.         if (solidShaderColors == null)
    89.             solidShaderType = ShaderUtils.SHADER_TYPE_NONE;
    90.  
    91.         radiusType.recycle();
    92.  
    93.         // 角度边长不能小于0
    94.         if (DEFAULT_RADIUS >= radius) radius = DEFAULT_RADIUS;
    95.         //如果四个角的值没有设置，那么就使用通用的radius的值。
    96.         if (DEFAULT_RADIUS >= leftTopRadius) leftTopRadius = radius;
    97.         if (DEFAULT_RADIUS >= rightTopRadius) rightTopRadius = radius;
    98.         if (DEFAULT_RADIUS >= rightBottomRadius) rightBottomRadius = radius;
    99.         if (DEFAULT_RADIUS >= leftBottomRadius) leftBottomRadius = radius;
    100.  
    101.  
    102.         if (bgColorStateList == null) {
    103.             bgColorStateList = ColorStateList.valueOf(Color.TRANSPARENT);
    104.         }
    105.         if (solidColorStateList == null) {
    106.             solidColorStateList = ColorStateList.valueOf(Color.TRANSPARENT);
    107.         }
    108.  
    109.         if (lineType == SOLID_TYPE_DASH) {
    110.             dashPathEffect = new DashPathEffect(new float[]{dashWidth, dashGap}, 0);
    111.         } else {
    112.             dashPathEffect = null;
    113.         }
    114.     }
    115.  
    116.     @Override
    117.     public void setBackgroundColor(int color) {
    118.         this.bgColorStateList = ColorStateList.valueOf(color);
    119.         this.bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    120.         if (radiusDrawable != null) {
    121.             radiusDrawable.setBackground(bgColorStateList, solidColorStateList);
    122.         }
    123.         forceRefreshLayout();
    124.     }
    125.  
    126.     @Override
    127.     public void setBackgroundColor(ColorStateList bgColorStateList) {
    128.         this.bgColorStateList = bgColorStateList;
    129.         this.bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    130.         if (radiusDrawable != null) {
    131.             radiusDrawable.setBackground(this.bgColorStateList, solidColorStateList);
    132.         }
    133.         forceRefreshLayout();
    134.     }
    135.  
    136.     @Override
    137.     public void setSolidDashPathEffect(DashPathEffect dashPathEffect) {
    138.         if (dashPathEffect != null) {
    139.             this.dashPathEffect = dashPathEffect;
    140.             forceRefreshLayout();
    141.         }
    142.     }
    143.  
    144.     @Override
    145.     public void setSolidColor(int color) {
    146.         this.solidColorStateList = ColorStateList.valueOf(color);
    147.         if (radiusDrawable != null) {
    148.             radiusDrawable.setBackground(this.bgColorStateList, solidColorStateList);
    149.         }
    150.         forceRefreshLayout();
    151.     }
    152.  
    153.     @Override
    154.     public void setSolidColor(ColorStateList solidColorStateList) {
    155.         this.solidColorStateList = solidColorStateList;
    156.         if (radiusDrawable != null) {
    157.             radiusDrawable.setBackground(bgColorStateList, this.solidColorStateList);
    158.         }
    159.         forceRefreshLayout();
    160.     }
    161.  
    162.     @Override
    163.     public void setRadius(int radius) {
    164.         if (radius >= 0) {
    165.             leftTopRadius = radius;
    166.             rightTopRadius = radius;
    167.             rightBottomRadius = radius;
    168.             leftBottomRadius = radius;
    169.             forceRefreshLayout();
    170.         }
    171.     }
    172.  
    173.     @Override
    174.     public void setRadius(int leftTopRadius, int rightTopRadius, int rightBottomRadius, int leftBottomRadius) {
    175.         this.leftTopRadius = leftTopRadius;
    176.         this.rightTopRadius = rightTopRadius;
    177.         this.rightBottomRadius = rightBottomRadius;
    178.         this.leftBottomRadius = leftBottomRadius;
    179.         forceRefreshLayout();
    180.     }
    181.  
    182.     @Override
    183.     public void setLeftTopRadius(int leftTopRadius) {
    184.         this.leftTopRadius = leftTopRadius;
    185.         forceRefreshLayout();
    186.     }
    187.  
    188.     @Override
    189.     public void setRightTopRadius(int rightTopRadius) {
    190.         this.rightTopRadius = rightTopRadius;
    191.         forceRefreshLayout();
    192.     }
    193.  
    194.     @Override
    195.     public void setRightBottomRadius(int rightBottomRadius) {
    196.         this.rightBottomRadius = rightBottomRadius;
    197.         forceRefreshLayout();
    198.     }
    199.  
    200.     @Override
    201.     public void setLeftBottomRadius(int leftBottomRadius) {
    202.         this.leftBottomRadius = leftBottomRadius;
    203.         forceRefreshLayout();
    204.     }
    205.  
    206.     @Override
    207.     public void setShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors) {
    208.         setShaderInfo(shapeType, shapeColors, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    209.     }
    210.  
    211.     @Override
    212.     public void setShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors, @ShaderUtils.LinearOrientation int shaderLinearOrientation) {
    213.         if (shapeColors == null || shapeColors.length <= 0)
    214.             return;
    215.         this.bgShaderType = shapeType;
    216.         this.bgShaderColors = shapeColors;
    217.         this.bgShaderLinearOrientation = shaderLinearOrientation;
    218.         forceRefreshLayout();
    219.     }
    220.  
    221.     @Override
    222.     public void setSolidShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors) {
    223.         setSolidShaderInfo(shapeType, shapeColors, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    224.     }
    225.  
    226.     @Override
    227.     public void setSolidShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors, @ShaderUtils.LinearOrientation int shaderLinearOrientation) {
    228.         if (shapeColors == null || shapeColors.length <= 0)
    229.             return;
    230.         this.solidShaderType = shapeType;
    231.         this.solidShaderColors = shapeColors;
    232.         this.solidShaderLinearOrientation = shaderLinearOrientation;
    233.         forceRefreshLayout();
    234.     }
    235.  
    236.     @Override
    237.     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    238.         super.onLayout(changed, left, top, right, bottom);
    239.  
    240.         // 没有发生改变，并且不需要强制刷新就不在重新layout
    241.         if (!changed && !this.forceRefreshLayout) {
    242.             return;
    243.         }
    244.         this.forceRefreshLayout = false;
    245.  
    246.         width = getWidth();
    247.         height = getHeight();
    248.  
    249.         final Path bgPath = setBackground();
    250.  
    251.         // 手动设置阴影，使用裁剪后的路径，防止阴影直角矩形显示
    252.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    253.             float elevation = Math.max(getElevation(), getTranslationZ());
    254.             if (elevation > 0) {
    255.                 setElevation(elevation);
    256.                 setOutlineProvider(new ViewOutlineProvider() {
    257.                     @Override
    258.                     public void getOutline(View view, Outline outline) {
    259.                         if (bgPath.isConvex()) {
    260.                             outline.setConvexPath(bgPath);
    261.                         } else {
    262.                             outline.setConvexPath(RadiusUtils.calculateBgPath(leftTopRadius, rightTopRadius,
    263.                                     leftBottomRadius, rightBottomRadius, width, height, false));
    264.                         }
    265.                     }
    266.                 });
    267.                 setClipToOutline(true);
    268.             }
    269.         }
    270.     }
    271.  
    272.     private void forceRefreshLayout() {
    273.         this.forceRefreshLayout = true;
    274.         requestLayout();
    275.     }
    276.  
    277.     private Path setBackground() {
    278.         Path bgPath = RadiusUtils.calculateBgPath(leftTopRadius, rightTopRadius,
    279.                 leftBottomRadius, rightBottomRadius, width, height);
    280.  
    281.         Shader bgShader = null;
    282.         if (bgShaderType != ShaderUtils.SHADER_TYPE_NONE) {
    283.             bgShader = ShaderUtils.createShader(bgShaderType, width, height, bgShaderColors, bgShaderLinearOrientation);
    284.         }
    285.  
    286.         // 边框
    287.         if (solidWidth > 0) {
    288.             Shader solidShader = null;
    289.             if (solidShaderType != ShaderUtils.SHADER_TYPE_NONE) {
    290.                 solidShader = ShaderUtils.createShader(solidShaderType, width, height, solidShaderColors, solidShaderLinearOrientation);
    291.             }
    292.  
    293.             Path[] solidPathArray = RadiusUtils.calculateSocketPath(leftTopRadius, rightTopRadius,
    294.                     leftBottomRadius, rightBottomRadius, width, height, solidWidth);
    295.             List solidPath = Arrays.asList(solidPathArray);
    296.  
    297.             radiusDrawable = new RadiusDrawable(bgColorStateList, bgShader, bgPath, solidWidth, solidColorStateList, solidShader, solidPath, dashPathEffect);
    298.         } else {
    299.             radiusDrawable = new RadiusDrawable(bgColorStateList, bgShader, bgPath);
    300.         }
    301.         setBackground(radiusDrawable);
    302.         return bgPath;
    303.     }
    304. }

    6.圆角线性布局  RadiusLinearLayout

    1. public class RadiusLinearLayout extends AutoLinearLayout implements IRadiusLayout {
    2.     // 控件宽高
    3.     private int width, height;
    4.     // 圆角参数
    5.     private int leftTopRadius;
    6.     private int rightTopRadius;
    7.     private int rightBottomRadius;
    8.     private int leftBottomRadius;
    9.  
    10.     private RadiusDrawable radiusDrawable;
    11.     private ColorStateList bgColorStateList;
    12.     // 渐变背景
    13.     private int[] bgShaderColors; // 背景渐变颜色值，优先级高于 bgColorStateList
    14.     private int bgShaderType; // 渐变类型
    15.     private int bgShaderLinearOrientation; // 线性渐变方向
    16.  
    17.     // 边框参数
    18.     private int solidWidth;
    19.     private ColorStateList solidColorStateList;
    20.     private DashPathEffect dashPathEffect = null;
    21.     // 渐变边框
    22.     private int[] solidShaderColors; // 边框渐变颜色值，优先级高于 bgColorStateList
    23.     private int solidShaderType; // 边框类型
    24.     private int solidShaderLinearOrientation; // 线性渐变方向
    25.     // 是否需要强制重新布局
    26.     private boolean forceRefreshLayout;
    27.  
    28.     public RadiusLinearLayout(Context context) {
    29.         this(context, null, 0);
    30.     }
    31.  
    32.     public RadiusLinearLayout(Context context, @Nullable AttributeSet attrs) {
    33.         this(context, attrs, 0);
    34.     }
    35.  
    36.     public RadiusLinearLayout(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
    37.         super(context, attrs, defStyleAttr);
    38.         init(context, attrs);
    39.     }
    40.  
    41.     @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    42.     public RadiusLinearLayout(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    43.         super(context, attrs, defStyleAttr, defStyleRes);
    44.         init(context, attrs);
    45.     }
    46.  
    47.     @Override
    48.     protected void init(Context context, AttributeSet attrs) {
    49.         super.init(context, attrs);
    50.         setWillNotDraw(false);
    51.         if (Build.VERSION.SDK_INT < 18) setLayerType(View.LAYER_TYPE_SOFTWARE, null);
    52.         // 读取圆角配置
    53.         TypedArray radiusType = context.obtainStyledAttributes(attrs, R.styleable.RadiusView);
    54.         int radius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_all, DEFAULT_RADIUS);
    55.         leftTopRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_leftTop, DEFAULT_RADIUS);
    56.         rightTopRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_rightTop, DEFAULT_RADIUS);
    57.         rightBottomRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_rightBottom, DEFAULT_RADIUS);
    58.         leftBottomRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_leftBottom, DEFAULT_RADIUS);
    59.  
    60.         // 获取背景信息
    61.         bgColorStateList = radiusType.getColorStateList(R.styleable.RadiusView_rv_background_color);
    62.         int startColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_start_color, ShaderUtils.COLOR_VALUE_NONE);
    63.         int middleColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_middle_color, ShaderUtils.COLOR_VALUE_NONE);
    64.         int endColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_end_color, ShaderUtils.COLOR_VALUE_NONE);
    65.         bgShaderType = radiusType.getInt(R.styleable.RadiusView_rv_shader_type, ShaderUtils.SHADER_TYPE_NONE);
    66.         bgShaderLinearOrientation = radiusType.getInt(R.styleable.RadiusView_rv_shader_linear_orientation, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    67.         bgShaderColors = ShaderUtils.createColorsArray(startColor, middleColor, endColor);
    68.         if (bgShaderColors == null)
    69.             bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    70.  
    71.  
    72.         // 获取边框信息
    73.         solidWidth = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_width, 0);
    74.         solidColorStateList = radiusType.getColorStateList(R.styleable.RadiusView_rv_solid_color);
    75.         int dashGap = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_dashGap, 0);
    76.         int dashWidth = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_dashWidth, 0);
    77.         int lineType = radiusType.getInt(R.styleable.RadiusView_rv_solid_type, SOLID_TYPE_SOLID);
    78.         int solidStartColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_start_color, ShaderUtils.COLOR_VALUE_NONE);
    79.         int solidMiddleColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_middle_color, ShaderUtils.COLOR_VALUE_NONE);
    80.         int solidEndColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_end_color, ShaderUtils.COLOR_VALUE_NONE);
    81.         solidShaderType = radiusType.getInt(R.styleable.RadiusView_rv_solid_shader_type, ShaderUtils.SHADER_TYPE_NONE);
    82.         solidShaderLinearOrientation = radiusType.getInt(R.styleable.RadiusView_rv_solid_shader_linear_orientation, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    83.         solidShaderColors = ShaderUtils.createColorsArray(solidStartColor, solidMiddleColor, solidEndColor);
    84.         if (solidShaderColors == null)
    85.             solidShaderType = ShaderUtils.SHADER_TYPE_NONE;
    86.  
    87.         radiusType.recycle();
    88.  
    89.         // 角度边长不能小于0
    90.         if (DEFAULT_RADIUS >= radius) radius = DEFAULT_RADIUS;
    91.         //如果四个角的值没有设置，那么就使用通用的radius的值。
    92.         if (DEFAULT_RADIUS >= leftTopRadius) leftTopRadius = radius;
    93.         if (DEFAULT_RADIUS >= rightTopRadius) rightTopRadius = radius;
    94.         if (DEFAULT_RADIUS >= rightBottomRadius) rightBottomRadius = radius;
    95.         if (DEFAULT_RADIUS >= leftBottomRadius) leftBottomRadius = radius;
    96.  
    97.  
    98.         if (bgColorStateList == null) {
    99.             bgColorStateList = ColorStateList.valueOf(Color.TRANSPARENT);
    100.         }
    101.         if (solidColorStateList == null) {
    102.             solidColorStateList = ColorStateList.valueOf(Color.TRANSPARENT);
    103.         }
    104.  
    105.         if (lineType == SOLID_TYPE_DASH) {
    106.             dashPathEffect = new DashPathEffect(new float[]{dashWidth, dashGap}, 0);
    107.         } else {
    108.             dashPathEffect = null;
    109.         }
    110.     }
    111.  
    112.     @Override
    113.     public void setBackgroundColor(int color) {
    114.         this.bgColorStateList = ColorStateList.valueOf(color);
    115.         this.bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    116.         if (radiusDrawable != null) {
    117.             radiusDrawable.setBackground(bgColorStateList, solidColorStateList);
    118.         }
    119.         forceRefreshLayout();
    120.     }
    121.  
    122.     @Override
    123.     public void setBackgroundColor(ColorStateList bgColorStateList) {
    124.         this.bgColorStateList = bgColorStateList;
    125.         this.bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    126.         if (radiusDrawable != null) {
    127.             radiusDrawable.setBackground(this.bgColorStateList, solidColorStateList);
    128.         }
    129.         forceRefreshLayout();
    130.     }
    131.  
    132.     @Override
    133.     public void setSolidDashPathEffect(DashPathEffect dashPathEffect) {
    134.         if (dashPathEffect != null) {
    135.             this.dashPathEffect = dashPathEffect;
    136.             forceRefreshLayout();
    137.         }
    138.     }
    139.  
    140.     @Override
    141.     public void setSolidColor(int color) {
    142.         this.solidColorStateList = ColorStateList.valueOf(color);
    143.         if (radiusDrawable != null) {
    144.             radiusDrawable.setBackground(this.bgColorStateList, solidColorStateList);
    145.         }
    146.         forceRefreshLayout();
    147.     }
    148.  
    149.     @Override
    150.     public void setSolidColor(ColorStateList solidColorStateList) {
    151.         this.solidColorStateList = solidColorStateList;
    152.         if (radiusDrawable != null) {
    153.             radiusDrawable.setBackground(bgColorStateList, this.solidColorStateList);
    154.         }
    155.         forceRefreshLayout();
    156.     }
    157.  
    158.     @Override
    159.     public void setRadius(int radius) {
    160.         if (radius >= 0) {
    161.             leftTopRadius = radius;
    162.             rightTopRadius = radius;
    163.             rightBottomRadius = radius;
    164.             leftBottomRadius = radius;
    165.             forceRefreshLayout();
    166.         }
    167.     }
    168.  
    169.     @Override
    170.     public void setRadius(int leftTopRadius, int rightTopRadius, int rightBottomRadius, int leftBottomRadius) {
    171.         this.leftTopRadius = leftTopRadius;
    172.         this.rightTopRadius = rightTopRadius;
    173.         this.rightBottomRadius = rightBottomRadius;
    174.         this.leftBottomRadius = leftBottomRadius;
    175.         forceRefreshLayout();
    176.     }
    177.  
    178.     @Override
    179.     public void setLeftTopRadius(int leftTopRadius) {
    180.         this.leftTopRadius = leftTopRadius;
    181.         forceRefreshLayout();
    182.     }
    183.  
    184.     @Override
    185.     public void setRightTopRadius(int rightTopRadius) {
    186.         this.rightTopRadius = rightTopRadius;
    187.         forceRefreshLayout();
    188.     }
    189.  
    190.     @Override
    191.     public void setRightBottomRadius(int rightBottomRadius) {
    192.         this.rightBottomRadius = rightBottomRadius;
    193.         forceRefreshLayout();
    194.     }
    195.  
    196.     @Override
    197.     public void setLeftBottomRadius(int leftBottomRadius) {
    198.         this.leftBottomRadius = leftBottomRadius;
    199.         forceRefreshLayout();
    200.     }
    201.  
    202.     @Override
    203.     public void setShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors) {
    204.         setShaderInfo(shapeType, shapeColors, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    205.     }
    206.  
    207.     @Override
    208.     public void setShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors, @ShaderUtils.LinearOrientation int shaderLinearOrientation) {
    209.         if (shapeColors == null || shapeColors.length <= 0)
    210.             return;
    211.         this.bgShaderType = shapeType;
    212.         this.bgShaderColors = shapeColors;
    213.         this.bgShaderLinearOrientation = shaderLinearOrientation;
    214.         forceRefreshLayout();
    215.     }
    216.  
    217.     @Override
    218.     public void setSolidShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors) {
    219.         setSolidShaderInfo(shapeType, shapeColors, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    220.     }
    221.  
    222.     @Override
    223.     public void setSolidShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors, @ShaderUtils.LinearOrientation int shaderLinearOrientation) {
    224.         if (shapeColors == null || shapeColors.length <= 0)
    225.             return;
    226.         this.solidShaderType = shapeType;
    227.         this.solidShaderColors = shapeColors;
    228.         this.solidShaderLinearOrientation = shaderLinearOrientation;
    229.         forceRefreshLayout();
    230.     }
    231.  
    232.     @Override
    233.     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    234.         super.onLayout(changed, left, top, right, bottom);
    235.  
    236.         // 没有发生改变，并且不需要强制刷新就不在重新layout
    237.         if (!changed && !this.forceRefreshLayout) {
    238.             return;
    239.         }
    240.         this.forceRefreshLayout = false;
    241.  
    242.         width = getWidth();
    243.         height = getHeight();
    244.  
    245.         final Path bgPath = setBackground();
    246.  
    247.         // 手动设置阴影，使用裁剪后的路径，防止阴影直角矩形显示
    248.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    249.             float elevation = Math.max(getElevation(), getTranslationZ());
    250.             if (elevation > 0) {
    251.                 setElevation(elevation);
    252.                 setOutlineProvider(new ViewOutlineProvider() {
    253.                     @Override
    254.                     public void getOutline(View view, Outline outline) {
    255.                         if (bgPath.isConvex()) {
    256.                             outline.setConvexPath(bgPath);
    257.                         } else {
    258.                             outline.setConvexPath(RadiusUtils.calculateBgPath(leftTopRadius, rightTopRadius,
    259.                                     leftBottomRadius, rightBottomRadius, width, height, false));
    260.                         }
    261.                     }
    262.                 });
    263.                 setClipToOutline(true);
    264.             }
    265.         }
    266.     }
    267.  
    268.     private void forceRefreshLayout() {
    269.         this.forceRefreshLayout = true;
    270.         requestLayout();
    271.     }
    272.  
    273.     private Path setBackground() {
    274.         Path bgPath = RadiusUtils.calculateBgPath(leftTopRadius, rightTopRadius,
    275.                 leftBottomRadius, rightBottomRadius, width, height);
    276.  
    277.         Shader bgShader = null;
    278.         if (bgShaderType != ShaderUtils.SHADER_TYPE_NONE) {
    279.             bgShader = ShaderUtils.createShader(bgShaderType, width, height, bgShaderColors, bgShaderLinearOrientation);
    280.         }
    281.  
    282.         // 边框
    283.         if (solidWidth > 0) {
    284.             Shader solidShader = null;
    285.             if (solidShaderType != ShaderUtils.SHADER_TYPE_NONE) {
    286.                 solidShader = ShaderUtils.createShader(solidShaderType, width, height, solidShaderColors, solidShaderLinearOrientation);
    287.             }
    288.  
    289.             Path[] solidPathArray = RadiusUtils.calculateSocketPath(leftTopRadius, rightTopRadius,
    290.                     leftBottomRadius, rightBottomRadius, width, height, solidWidth);
    291.             List solidPath = Arrays.asList(solidPathArray);
    292.  
    293.             radiusDrawable = new RadiusDrawable(bgColorStateList, bgShader, bgPath, solidWidth, solidColorStateList, solidShader, solidPath, dashPathEffect);
    294.         } else {
    295.             radiusDrawable = new RadiusDrawable(bgColorStateList, bgShader, bgPath);
    296.         }
    297.         setBackground(radiusDrawable);
    298.         return bgPath;
    299.     }
    300. }

    7.圆角TextView   RadiusTextView

    1. public class RadiusTextView extends AppCompatTextView implements IRadiusLayout {
    2.     // 控件宽高
    3.     private int width, height;
    4.     // 圆角参数
    5.     private int leftTopRadius;
    6.     private int rightTopRadius;
    7.     private int rightBottomRadius;
    8.     private int leftBottomRadius;
    9.  
    10.     private RadiusDrawable radiusDrawable;
    11.     private ColorStateList bgColorStateList;
    12.     // 渐变背景
    13.     private int[] bgShaderColors; // 背景渐变颜色值，优先级高于 bgColorStateList
    14.     private int bgShaderType; // 渐变类型
    15.     private int bgShaderLinearOrientation; // 线性渐变方向
    16.  
    17.     // 边框参数
    18.     private int solidWidth;
    19.     private ColorStateList solidColorStateList;
    20.     private DashPathEffect dashPathEffect = null;
    21.     // 渐变边框
    22.     private int[] solidShaderColors; // 边框渐变颜色值，优先级高于 bgColorStateList
    23.     private int solidShaderType; // 边框类型
    24.     private int solidShaderLinearOrientation; // 线性渐变方向
    25.     // 是否需要强制重新布局
    26.     private boolean forceRefreshLayout;
    27.  
    28.     public RadiusTextView(Context context) {
    29.         this(context, null);
    30.     }
    31.  
    32.     public RadiusTextView(Context context, AttributeSet attrs) {
    33.         this(context, attrs, 0);
    34.     }
    35.  
    36.     public RadiusTextView(Context context, AttributeSet attrs, int defStyleAttr) {
    37.         super(context, attrs, defStyleAttr);
    38.         init(context, attrs);
    39.     }
    40.  
    41.     protected void init(Context context, AttributeSet attrs) {
    42.         if (Build.VERSION.SDK_INT < 18) setLayerType(View.LAYER_TYPE_SOFTWARE, null);
    43.         // 读取圆角配置
    44.         TypedArray radiusType = context.obtainStyledAttributes(attrs, R.styleable.RadiusView);
    45.         int radius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_all, DEFAULT_RADIUS);
    46.         leftTopRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_leftTop, DEFAULT_RADIUS);
    47.         rightTopRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_rightTop, DEFAULT_RADIUS);
    48.         rightBottomRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_rightBottom, DEFAULT_RADIUS);
    49.         leftBottomRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_leftBottom, DEFAULT_RADIUS);
    50.  
    51.         // 获取背景信息
    52.         bgColorStateList = radiusType.getColorStateList(R.styleable.RadiusView_rv_background_color);
    53.         int startColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_start_color, ShaderUtils.COLOR_VALUE_NONE);
    54.         int middleColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_middle_color, ShaderUtils.COLOR_VALUE_NONE);
    55.         int endColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_end_color, ShaderUtils.COLOR_VALUE_NONE);
    56.         bgShaderType = radiusType.getInt(R.styleable.RadiusView_rv_shader_type, ShaderUtils.SHADER_TYPE_NONE);
    57.         bgShaderLinearOrientation = radiusType.getInt(R.styleable.RadiusView_rv_shader_linear_orientation, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    58.         bgShaderColors = ShaderUtils.createColorsArray(startColor, middleColor, endColor);
    59.         if (bgShaderColors == null)
    60.             bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    61.  
    62.  
    63.         // 获取边框信息
    64.         solidWidth = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_width, 0);
    65.         solidColorStateList = radiusType.getColorStateList(R.styleable.RadiusView_rv_solid_color);
    66.         int dashGap = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_dashGap, 0);
    67.         int dashWidth = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_dashWidth, 0);
    68.         int lineType = radiusType.getInt(R.styleable.RadiusView_rv_solid_type, SOLID_TYPE_SOLID);
    69.         int solidStartColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_start_color, ShaderUtils.COLOR_VALUE_NONE);
    70.         int solidMiddleColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_middle_color, ShaderUtils.COLOR_VALUE_NONE);
    71.         int solidEndColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_end_color, ShaderUtils.COLOR_VALUE_NONE);
    72.         solidShaderType = radiusType.getInt(R.styleable.RadiusView_rv_solid_shader_type, ShaderUtils.SHADER_TYPE_NONE);
    73.         solidShaderLinearOrientation = radiusType.getInt(R.styleable.RadiusView_rv_solid_shader_linear_orientation, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    74.         solidShaderColors = ShaderUtils.createColorsArray(solidStartColor, solidMiddleColor, solidEndColor);
    75.         if (solidShaderColors == null)
    76.             solidShaderType = ShaderUtils.SHADER_TYPE_NONE;
    77.  
    78.         radiusType.recycle();
    79.  
    80.         // 角度边长不能小于0
    81.         if (DEFAULT_RADIUS >= radius) radius = DEFAULT_RADIUS;
    82.         //如果四个角的值没有设置，那么就使用通用的radius的值。
    83.         if (DEFAULT_RADIUS >= leftTopRadius) leftTopRadius = radius;
    84.         if (DEFAULT_RADIUS >= rightTopRadius) rightTopRadius = radius;
    85.         if (DEFAULT_RADIUS >= rightBottomRadius) rightBottomRadius = radius;
    86.         if (DEFAULT_RADIUS >= leftBottomRadius) leftBottomRadius = radius;
    87.  
    88.  
    89.         if (bgColorStateList == null) {
    90.             bgColorStateList = ColorStateList.valueOf(Color.TRANSPARENT);
    91.         }
    92.         if (solidColorStateList == null) {
    93.             solidColorStateList = ColorStateList.valueOf(Color.TRANSPARENT);
    94.         }
    95.  
    96.         if (lineType == SOLID_TYPE_DASH) {
    97.             dashPathEffect = new DashPathEffect(new float[]{dashWidth, dashGap}, 0);
    98.         } else {
    99.             dashPathEffect = null;
    100.         }
    101.     }
    102.  
    103.     @Override
    104.     public void setBackgroundColor(int color) {
    105.         this.bgColorStateList = ColorStateList.valueOf(color);
    106.         this.bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    107.         if (radiusDrawable != null) {
    108.             radiusDrawable.setBackground(bgColorStateList, solidColorStateList);
    109.         }
    110.         forceRefreshLayout();
    111.     }
    112.  
    113.     @Override
    114.     public void setBackgroundColor(ColorStateList bgColorStateList) {
    115.         this.bgColorStateList = bgColorStateList;
    116.         this.bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    117.         if (radiusDrawable != null) {
    118.             radiusDrawable.setBackground(this.bgColorStateList, solidColorStateList);
    119.         }
    120.         forceRefreshLayout();
    121.     }
    122.  
    123.     @Override
    124.     public void setSolidDashPathEffect(DashPathEffect dashPathEffect) {
    125.         if (dashPathEffect != null) {
    126.             this.dashPathEffect = dashPathEffect;
    127.             forceRefreshLayout();
    128.         }
    129.     }
    130.  
    131.     @Override
    132.     public void setSolidColor(int color) {
    133.         this.solidColorStateList = ColorStateList.valueOf(color);
    134.         if (radiusDrawable != null) {
    135.             radiusDrawable.setBackground(this.bgColorStateList, solidColorStateList);
    136.         }
    137.         forceRefreshLayout();
    138.     }
    139.  
    140.     @Override
    141.     public void setSolidColor(ColorStateList solidColorStateList) {
    142.         this.solidColorStateList = solidColorStateList;
    143.         if (radiusDrawable != null) {
    144.             radiusDrawable.setBackground(bgColorStateList, this.solidColorStateList);
    145.         }
    146.         forceRefreshLayout();
    147.     }
    148.  
    149.     @Override
    150.     public void setRadius(int radius) {
    151.         if (radius >= 0) {
    152.             leftTopRadius = radius;
    153.             rightTopRadius = radius;
    154.             rightBottomRadius = radius;
    155.             leftBottomRadius = radius;
    156.             forceRefreshLayout();
    157.         }
    158.     }
    159.  
    160.     @Override
    161.     public void setRadius(int leftTopRadius, int rightTopRadius, int rightBottomRadius, int leftBottomRadius) {
    162.         this.leftTopRadius = leftTopRadius;
    163.         this.rightTopRadius = rightTopRadius;
    164.         this.rightBottomRadius = rightBottomRadius;
    165.         this.leftBottomRadius = leftBottomRadius;
    166.         forceRefreshLayout();
    167.     }
    168.  
    169.     @Override
    170.     public void setLeftTopRadius(int leftTopRadius) {
    171.         this.leftTopRadius = leftTopRadius;
    172.         forceRefreshLayout();
    173.     }
    174.  
    175.     @Override
    176.     public void setRightTopRadius(int rightTopRadius) {
    177.         this.rightTopRadius = rightTopRadius;
    178.         forceRefreshLayout();
    179.     }
    180.  
    181.     @Override
    182.     public void setRightBottomRadius(int rightBottomRadius) {
    183.         this.rightBottomRadius = rightBottomRadius;
    184.         forceRefreshLayout();
    185.     }
    186.  
    187.     @Override
    188.     public void setLeftBottomRadius(int leftBottomRadius) {
    189.         this.leftBottomRadius = leftBottomRadius;
    190.         forceRefreshLayout();
    191.     }
    192.  
    193.     @Override
    194.     public void setShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors) {
    195.         setShaderInfo(shapeType, shapeColors, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    196.     }
    197.  
    198.     @Override
    199.     public void setShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors, @ShaderUtils.LinearOrientation int shaderLinearOrientation) {
    200.         if (shapeColors == null || shapeColors.length <= 0)
    201.             return;
    202.         this.bgShaderType = shapeType;
    203.         this.bgShaderColors = shapeColors;
    204.         this.bgShaderLinearOrientation = shaderLinearOrientation;
    205.         forceRefreshLayout();
    206.     }
    207.  
    208.     @Override
    209.     public void setSolidShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors) {
    210.         setSolidShaderInfo(shapeType, shapeColors, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    211.     }
    212.  
    213.     @Override
    214.     public void setSolidShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors, @ShaderUtils.LinearOrientation int shaderLinearOrientation) {
    215.         if (shapeColors == null || shapeColors.length <= 0)
    216.             return;
    217.         this.solidShaderType = shapeType;
    218.         this.solidShaderColors = shapeColors;
    219.         this.solidShaderLinearOrientation = shaderLinearOrientation;
    220.         forceRefreshLayout();
    221.     }
    222.  
    223.     @Override
    224.     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    225.         super.onLayout(changed, left, top, right, bottom);
    226.  
    227.         // 没有发生改变，并且不需要强制刷新就不在重新layout
    228.         if (!changed && !this.forceRefreshLayout) {
    229.             return;
    230.         }
    231.         this.forceRefreshLayout = false;
    232.  
    233.         width = getWidth();
    234.         height = getHeight();
    235.  
    236.         final Path bgPath = setBackground();
    237.  
    238.         // 手动设置阴影，使用裁剪后的路径，防止阴影直角矩形显示
    239.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    240.             float elevation = Math.max(getElevation(), getTranslationZ());
    241.             if (elevation > 0) {
    242.                 setElevation(elevation);
    243.                 setOutlineProvider(new ViewOutlineProvider() {
    244.                     @Override
    245.                     public void getOutline(View view, Outline outline) {
    246.                         if (bgPath.isConvex()) {
    247.                             outline.setConvexPath(bgPath);
    248.                         } else {
    249.                             outline.setConvexPath(RadiusUtils.calculateBgPath(leftTopRadius, rightTopRadius,
    250.                                     leftBottomRadius, rightBottomRadius, width, height, false));
    251.                         }
    252.                     }
    253.                 });
    254.                 setClipToOutline(true);
    255.             }
    256.         }
    257.     }
    258.  
    259.     private void forceRefreshLayout() {
    260.         this.forceRefreshLayout = true;
    261.         requestLayout();
    262.     }
    263.  
    264.     private Path setBackground() {
    265.         Path bgPath = RadiusUtils.calculateBgPath(leftTopRadius, rightTopRadius,
    266.                 leftBottomRadius, rightBottomRadius, width, height);
    267.  
    268.         Shader bgShader = null;
    269.         if (bgShaderType != ShaderUtils.SHADER_TYPE_NONE) {
    270.             bgShader = ShaderUtils.createShader(bgShaderType, width, height, bgShaderColors, bgShaderLinearOrientation);
    271.         }
    272.  
    273.         // 边框
    274.         if (solidWidth > 0) {
    275.             Shader solidShader = null;
    276.             if (solidShaderType != ShaderUtils.SHADER_TYPE_NONE) {
    277.                 solidShader = ShaderUtils.createShader(solidShaderType, width, height, solidShaderColors, solidShaderLinearOrientation);
    278.             }
    279.  
    280.             Path[] solidPathArray = RadiusUtils.calculateSocketPath(leftTopRadius, rightTopRadius,
    281.                     leftBottomRadius, rightBottomRadius, width, height, solidWidth);
    282.             List solidPath = Arrays.asList(solidPathArray);
    283.  
    284.             radiusDrawable = new RadiusDrawable(bgColorStateList, bgShader, bgPath, solidWidth, solidColorStateList, solidShader, solidPath, dashPathEffect);
    285.         } else {
    286.             radiusDrawable = new RadiusDrawable(bgColorStateList, bgShader, bgPath);
    287.         }
    288.         setBackground(radiusDrawable);
    289.         return bgPath;
    290.     }
    291. }

    8.圆角Image  RadiusImageView

    1. public class RadiusImageView extends AutoImageView {
    2.     // 默认没有圆角
    3.     private final int DEFAULT_RADIUS = 0;
    4.     private static final Bitmap.Config BITMAP_CONFIG = Bitmap.Config.ARGB_8888;
    5.     private static final int COLOR_DRAWABLE_DIMENSION = 2;
    6.     public static final int TYPE_SOLID = 0; // 实线
    7.     public static final int TYPE_DASH = 1;  // 虚线
    8.  
    9.     // 控件宽高
    10.     private int width, height;
    11.     // 圆角参数
    12.     private int leftTopRadius;
    13.     private int rightTopRadius;
    14.     private int rightBottomRadius;
    15.     private int leftBottomRadius;
    16.  
    17.     // 画图片的画笔
    18.     private Paint bitmapPaint;
    19.     // 画边框的画笔
    20.     private Paint solidPaint;
    21.     // 3x3 矩阵，主要用于缩小放大
    22.     private Matrix matrix;
    23.     //渲染图像，使用图像为绘制图形着色
    24.     private BitmapShader bitmapShader;
    25.  
    26.     // 边框参数
    27.     private int solidWidth;
    28.     private int solidColor;
    29.  
    30.     // 是否需要强制重新布局
    31.     private boolean forceRefreshLayout;
    32.  
    33.     public RadiusImageView(Context context) {
    34.         this(context, null);
    35.     }
    36.  
    37.     public RadiusImageView(Context context, AttributeSet attrs) {
    38.         this(context, attrs, 0);
    39.     }
    40.  
    41.     public RadiusImageView(Context context, AttributeSet attrs, int defStyleAttr) {
    42.         super(context, attrs, defStyleAttr);
    43.         init(context, attrs);
    44.     }
    45.  
    46.     @Override
    47.     protected void init(Context context, AttributeSet attrs) {
    48.         super.init(context, attrs);
    49.         if (Build.VERSION.SDK_INT < 18) setLayerType(View.LAYER_TYPE_SOFTWARE, null);
    50.         // 读取圆角配置
    51.         TypedArray radiusType = context.obtainStyledAttributes(attrs, R.styleable.RadiusView);
    52.         int radius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_all, DEFAULT_RADIUS);
    53.         leftTopRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_leftTop, DEFAULT_RADIUS);
    54.         rightTopRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_rightTop, DEFAULT_RADIUS);
    55.         rightBottomRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_rightBottom, DEFAULT_RADIUS);
    56.         leftBottomRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_leftBottom, DEFAULT_RADIUS);
    57.  
    58.         solidWidth = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_width, 0);
    59.         solidColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_color, Color.TRANSPARENT);
    60.  
    61.         int dashGap = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_dashGap, 0);
    62.         int dashWidth = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_dashWidth, 0);
    63.         int lineType = radiusType.getInt(R.styleable.RadiusView_rv_solid_type, TYPE_SOLID);
    64.         radiusType.recycle();
    65.  
    66.         // 角度边长不能小于0
    67.         if (DEFAULT_RADIUS >= radius) radius = DEFAULT_RADIUS;
    68.         //如果四个角的值没有设置，那么就使用通用的radius的值。
    69.         if (DEFAULT_RADIUS >= leftTopRadius) leftTopRadius = radius;
    70.         if (DEFAULT_RADIUS >= rightTopRadius) rightTopRadius = radius;
    71.         if (DEFAULT_RADIUS >= rightBottomRadius) rightBottomRadius = radius;
    72.         if (DEFAULT_RADIUS >= leftBottomRadius) leftBottomRadius = radius;
    73.  
    74.         matrix = new Matrix();
    75.         bitmapPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    76.         bitmapPaint.setDither(true);
    77.  
    78.         solidPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    79.         solidPaint.setDither(true);
    80.         solidPaint.setStyle(Paint.Style.STROKE);
    81.         solidPaint.setColor(solidColor);
    82.         solidPaint.setStrokeWidth(solidWidth);
    83.         if (lineType == TYPE_SOLID) {
    84.             setLineTypeStyle(TYPE_SOLID, 0, 0, false);
    85.         } else {
    86.             setLineTypeStyle(TYPE_DASH, dashGap, dashWidth, false);
    87.         }
    88.     }
    89.  
    90.     // 设置线的类型和虚线样式
    91.     private void setLineTypeStyle(int lineType, float dashGap, float dashWidth, boolean invalidate) {
    92.         if (lineType == TYPE_DASH) {
    93.             DashPathEffect dashPathEffect = null;
    94.             if (dashWidth > 0) {
    95.                 dashPathEffect = new DashPathEffect(new float[]{dashWidth, dashGap}, 0);
    96.             }
    97.             solidPaint.setPathEffect(dashPathEffect);
    98.         } else {
    99.             solidPaint.setPathEffect(null);
    100.         }
    101.         if (invalidate) invalidate();
    102.     }
    103.  
    104.     public void setSolidColor(int color) {
    105.         solidPaint.setColor(color);
    106.         forceRefreshLayout();
    107.     }
    108.  
    109.     public void setRadius(int radius) {
    110.         if (radius >= 0) {
    111.             leftTopRadius = radius;
    112.             rightTopRadius = radius;
    113.             rightBottomRadius = radius;
    114.             leftBottomRadius = radius;
    115.             forceRefreshLayout();
    116.         }
    117.     }
    118.  
    119.     public void setRadius(int leftTopRadius, int rightTopRadius, int rightBottomRadius, int leftBottomRadius) {
    120.         this.leftTopRadius = leftTopRadius;
    121.         this.rightTopRadius = rightTopRadius;
    122.         this.rightBottomRadius = rightBottomRadius;
    123.         this.leftBottomRadius = leftBottomRadius;
    124.         forceRefreshLayout();
    125.     }
    126.  
    127.     public void setLeftTopRadius(int leftTopRadius) {
    128.         this.leftTopRadius = leftTopRadius;
    129.         forceRefreshLayout();
    130.     }
    131.  
    132.     public void setRightTopRadius(int rightTopRadius) {
    133.         this.rightTopRadius = rightTopRadius;
    134.         forceRefreshLayout();
    135.     }
    136.  
    137.     public void setRightBottomRadius(int rightBottomRadius) {
    138.         this.rightBottomRadius = rightBottomRadius;
    139.         forceRefreshLayout();
    140.     }
    141.  
    142.     public void setLeftBottomRadius(int leftBottomRadius) {
    143.         this.leftBottomRadius = leftBottomRadius;
    144.         forceRefreshLayout();
    145.     }
    146.  
    147.     @Override
    148.     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    149.         super.onLayout(changed, left, top, right, bottom);
    150.  
    151.         // 没有发生改变，并且不需要强制刷新就不在重新layout
    152.         if (!changed && !this.forceRefreshLayout) {
    153.             return;
    154.         }
    155.         this.forceRefreshLayout = false;
    156.  
    157.         width = getWidth();
    158.         height = getHeight();
    159.  
    160.         // 手动设置阴影，使用裁剪后的路径，防止阴影直角矩形显示
    161.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    162.             float elevation = Math.max(getElevation(), getTranslationZ());
    163.             if (elevation > 0) {
    164.                 setElevation(elevation);
    165.                 setOutlineProvider(new ViewOutlineProvider() {
    166.                     @Override
    167.                     public void getOutline(View view, Outline outline) {
    168.                         Path path = RadiusUtils.calculateBgPath(leftTopRadius, rightTopRadius, leftBottomRadius, rightBottomRadius, width, height, false);
    169.                         outline.setConvexPath(path);
    170.                     }
    171.                 });
    172.                 setClipToOutline(true);
    173.             }
    174.         }
    175.     }
    176.  
    177.     private void forceRefreshLayout() {
    178.         this.forceRefreshLayout = true;
    179.         requestLayout();
    180.     }
    181.  
    182.     @Override
    183.     protected void onDraw(Canvas canvas) {
    184.         if (leftTopRadius <= DEFAULT_RADIUS && leftBottomRadius <= DEFAULT_RADIUS &&
    185.                 rightTopRadius <= DEFAULT_RADIUS && rightBottomRadius <= DEFAULT_RADIUS) {
    186.             super.onDraw(canvas);
    187.  
    188.             // 边框
    189.             if (solidWidth > 0)
    190.                 canvas.drawPath(RadiusUtils.calculateRectSocketPath(width, height, solidWidth), solidPaint);
    191.         } else {
    192.             Path path = RadiusUtils.calculateBgPath(leftTopRadius, rightTopRadius, leftBottomRadius, rightBottomRadius, width, height);
    193.             Bitmap bitmap = getBitmapFromDrawable(getDrawable());
    194.             if (bitmap != null) {
    195.                 bitmapShader = new BitmapShader(bitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
    196.                 configureBounds(getDrawable());
    197.                 // 设置变换矩阵
    198.                 bitmapShader.setLocalMatrix(matrix);
    199.                 // 设置shader
    200.                 bitmapPaint.setShader(bitmapShader);
    201.                 canvas.drawPath(path, bitmapPaint);
    202.             }
    203.  
    204.             // 边框
    205.             if (solidWidth > 0) {
    206.                 Path[] result = RadiusUtils.calculateSocketPath(leftTopRadius, rightTopRadius, leftBottomRadius, rightBottomRadius, width, height, solidWidth);
    207.                 canvas.drawPath(result[0], solidPaint);
    208.                 canvas.drawPath(result[1], solidPaint);
    209.             }
    210.         }
    211.     }
    212.  
    213.     // 获取图片资源
    214.     private Bitmap getBitmapFromDrawable(Drawable drawable) {
    215.         if (drawable == null) {
    216.             return null;
    217.         }
    218.  
    219.         if (drawable instanceof BitmapDrawable) {
    220.             return ((BitmapDrawable) drawable).getBitmap();
    221.         }
    222.  
    223.         try {
    224.             Bitmap bitmap;
    225.  
    226.             if (drawable instanceof ColorDrawable) {
    227.                 bitmap = Bitmap.createBitmap(COLOR_DRAWABLE_DIMENSION, COLOR_DRAWABLE_DIMENSION, BITMAP_CONFIG);
    228.             } else {
    229.                 bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), BITMAP_CONFIG);
    230.             }
    231.  
    232.             Canvas canvas = new Canvas(bitmap);
    233.             drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
    234.             drawable.draw(canvas);
    235.             return bitmap;
    236.         } catch (Exception e) {
    237.             e.printStackTrace();
    238.             return null;
    239.         }
    240.     }
    241.  
    242.     // 根据 ScaleType 进行矩阵变换
    243.     private void configureBounds(Drawable drawable) {
    244.         if (drawable == null) {
    245.             return;
    246.         }
    247.  
    248.         final ImageView.ScaleType scaleType = getScaleType();
    249.         final int intrinsicWidth = drawable.getIntrinsicWidth();
    250.         final int intrinsicHeight = drawable.getIntrinsicHeight();
    251.         final int vWidth = width - getPaddingLeft() - getPaddingRight();
    252.         final int vHeight = height - getPaddingTop() - getPaddingBottom();
    253.         final boolean fits = (intrinsicWidth < 0 || vWidth == intrinsicWidth)
    254.                 && (intrinsicHeight < 0 || vHeight == intrinsicHeight);
    255.  
    256.         if (intrinsicWidth <= 0 || intrinsicHeight <= 0 || ImageView.ScaleType.FIT_XY == scaleType) {
    257.             matrix = null;
    258.         } else {
    259.             if (ImageView.ScaleType.MATRIX == scaleType) {
    260.                 matrix = null;
    261.             } else if (fits) {
    262.                 matrix = null;
    263.             } else if (ImageView.ScaleType.CENTER == scaleType) {
    264.                 if (matrix == null)
    265.                     matrix = new Matrix();
    266.                 matrix.setTranslate(Math.round((vWidth - intrinsicWidth) * 0.5f),
    267.                         Math.round((vHeight - intrinsicHeight) * 0.5f));
    268.             } else if (ImageView.ScaleType.CENTER_CROP == scaleType) {
    269.                 float scale;
    270.                 float dx = 0, dy = 0;
    271.  
    272.                 if (intrinsicWidth * vHeight > vWidth * intrinsicHeight) {
    273.                     scale = (float) vHeight / (float) intrinsicHeight;
    274.                     dx = (vWidth - intrinsicWidth * scale) * 0.5f;
    275.                 } else {
    276.                     scale = (float) vWidth / (float) intrinsicWidth;
    277.                     dy = (vHeight - intrinsicHeight * scale) * 0.5f;
    278.                 }
    279.  
    280.                 if (matrix == null)
    281.                     matrix = new Matrix();
    282.                 matrix.setScale(scale, scale);
    283.                 matrix.postTranslate(Math.round(dx), Math.round(dy));
    284.             } else if (ImageView.ScaleType.CENTER_INSIDE == scaleType) {
    285.                 float scale;
    286.                 float dx;
    287.                 float dy;
    288.  
    289.                 if (intrinsicWidth <= vWidth && intrinsicHeight <= vHeight) {
    290.                     scale = 1.0f;
    291.                 } else {
    292.                     scale = Math.min((float) vWidth / (float) intrinsicWidth,
    293.                             (float) vHeight / (float) intrinsicHeight);
    294.                 }
    295.  
    296.                 dx = Math.round((vWidth - intrinsicWidth * scale) * 0.5f);
    297.                 dy = Math.round((vHeight - intrinsicHeight * scale) * 0.5f);
    298.  
    299.                 if (matrix == null)
    300.                     matrix = new Matrix();
    301.                 matrix.setScale(scale, scale);
    302.                 matrix.postTranslate(dx, dy);
    303.             } else {
    304.                 RectF mTempSrc = new RectF();
    305.                 RectF mTempDst = new RectF();
    306.                 mTempSrc.set(0, 0, intrinsicWidth, intrinsicHeight);
    307.                 mTempDst.set(0, 0, vWidth, vHeight);
    308.                 if (matrix == null)
    309.                     matrix = new Matrix();
    310.                 matrix.setRectToRect(mTempSrc, mTempDst, Matrix.ScaleToFit.CENTER);
    311.             }
    312.         }
    313.     }
    314. }

    9.圆角FrameLayout     RadiusFrameLayout

    1. public class RadiusFrameLayout extends AutoFrameLayout implements IRadiusLayout{
    2.  
    3.     // 控件宽高
    4.     private int width, height;
    5.     // 圆角参数
    6.     private int leftTopRadius;
    7.     private int rightTopRadius;
    8.     private int rightBottomRadius;
    9.     private int leftBottomRadius;
    10.  
    11.     private RadiusDrawable radiusDrawable;
    12.     private ColorStateList bgColorStateList;
    13.     // 渐变背景
    14.     private int[] bgShaderColors; // 背景渐变颜色值，优先级高于 bgColorStateList
    15.     private int bgShaderType; // 渐变类型
    16.     private int bgShaderLinearOrientation; // 线性渐变方向
    17.  
    18.     // 边框参数
    19.     private int solidWidth;
    20.     private ColorStateList solidColorStateList;
    21.     private DashPathEffect dashPathEffect = null;
    22.     // 渐变边框
    23.     private int[] solidShaderColors; // 边框渐变颜色值，优先级高于 bgColorStateList
    24.     private int solidShaderType; // 边框类型
    25.     private int solidShaderLinearOrientation; // 线性渐变方向
    26.     // 是否需要强制重新布局
    27.     private boolean forceRefreshLayout;
    28.  
    29.     public RadiusFrameLayout(Context context) {
    30.         this(context, null);
    31.     }
    32.  
    33.     public RadiusFrameLayout(Context context, AttributeSet attrs) {
    34.         this(context, attrs, 0);
    35.     }
    36.  
    37.     public RadiusFrameLayout(Context context, AttributeSet attrs, int defStyleAttr) {
    38.         super(context, attrs, defStyleAttr);
    39.         init(context, attrs);
    40.     }
    41.  
    42.     @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    43.     public RadiusFrameLayout(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    44.         super(context, attrs, defStyleAttr, defStyleRes);
    45.         init(context, attrs);
    46.     }
    47.  
    48.     @Override
    49.     protected void init(Context context, AttributeSet attrs) {
    50.         super.init(context, attrs);
    51.         setWillNotDraw(false);
    52.         if (Build.VERSION.SDK_INT < 18) setLayerType(View.LAYER_TYPE_SOFTWARE, null);
    53.         // 读取圆角配置
    54.         TypedArray radiusType = context.obtainStyledAttributes(attrs, R.styleable.RadiusView);
    55.         int radius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_all, DEFAULT_RADIUS);
    56.         leftTopRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_leftTop, DEFAULT_RADIUS);
    57.         rightTopRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_rightTop, DEFAULT_RADIUS);
    58.         rightBottomRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_rightBottom, DEFAULT_RADIUS);
    59.         leftBottomRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_leftBottom, DEFAULT_RADIUS);
    60.  
    61.         // 获取背景信息
    62.         bgColorStateList = radiusType.getColorStateList(R.styleable.RadiusView_rv_background_color);
    63.         int startColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_start_color, ShaderUtils.COLOR_VALUE_NONE);
    64.         int middleColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_middle_color, ShaderUtils.COLOR_VALUE_NONE);
    65.         int endColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_end_color, ShaderUtils.COLOR_VALUE_NONE);
    66.         bgShaderType = radiusType.getInt(R.styleable.RadiusView_rv_shader_type, ShaderUtils.SHADER_TYPE_NONE);
    67.         bgShaderLinearOrientation = radiusType.getInt(R.styleable.RadiusView_rv_shader_linear_orientation, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    68.         bgShaderColors = ShaderUtils.createColorsArray(startColor, middleColor, endColor);
    69.         if (bgShaderColors == null)
    70.             bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    71.  
    72.  
    73.         // 获取边框信息
    74.         solidWidth = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_width, 0);
    75.         solidColorStateList = radiusType.getColorStateList(R.styleable.RadiusView_rv_solid_color);
    76.         int dashGap = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_dashGap, 0);
    77.         int dashWidth = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_dashWidth, 0);
    78.         int lineType = radiusType.getInt(R.styleable.RadiusView_rv_solid_type, SOLID_TYPE_SOLID);
    79.         int solidStartColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_start_color, ShaderUtils.COLOR_VALUE_NONE);
    80.         int solidMiddleColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_middle_color, ShaderUtils.COLOR_VALUE_NONE);
    81.         int solidEndColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_end_color, ShaderUtils.COLOR_VALUE_NONE);
    82.         solidShaderType = radiusType.getInt(R.styleable.RadiusView_rv_solid_shader_type, ShaderUtils.SHADER_TYPE_NONE);
    83.         solidShaderLinearOrientation = radiusType.getInt(R.styleable.RadiusView_rv_solid_shader_linear_orientation, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    84.         solidShaderColors = ShaderUtils.createColorsArray(solidStartColor, solidMiddleColor, solidEndColor);
    85.         if (solidShaderColors == null)
    86.             solidShaderType = ShaderUtils.SHADER_TYPE_NONE;
    87.  
    88.         radiusType.recycle();
    89.  
    90.         // 角度边长不能小于0
    91.         if (DEFAULT_RADIUS >= radius) radius = DEFAULT_RADIUS;
    92.         //如果四个角的值没有设置，那么就使用通用的radius的值。
    93.         if (DEFAULT_RADIUS >= leftTopRadius) leftTopRadius = radius;
    94.         if (DEFAULT_RADIUS >= rightTopRadius) rightTopRadius = radius;
    95.         if (DEFAULT_RADIUS >= rightBottomRadius) rightBottomRadius = radius;
    96.         if (DEFAULT_RADIUS >= leftBottomRadius) leftBottomRadius = radius;
    97.  
    98.  
    99.         if (bgColorStateList == null) {
    100.             bgColorStateList = ColorStateList.valueOf(Color.TRANSPARENT);
    101.         }
    102.         if (solidColorStateList == null) {
    103.             solidColorStateList = ColorStateList.valueOf(Color.TRANSPARENT);
    104.         }
    105.  
    106.         if (lineType == SOLID_TYPE_DASH) {
    107.             dashPathEffect = new DashPathEffect(new float[]{dashWidth, dashGap}, 0);
    108.         } else {
    109.             dashPathEffect = null;
    110.         }
    111.     }
    112.  
    113.     @Override
    114.     public void setBackgroundColor(int color) {
    115.         this.bgColorStateList = ColorStateList.valueOf(color);
    116.         this.bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    117.         if (radiusDrawable != null) {
    118.             radiusDrawable.setBackground(bgColorStateList, solidColorStateList);
    119.         }
    120.         forceRefreshLayout();
    121.     }
    122.  
    123.     @Override
    124.     public void setBackgroundColor(ColorStateList bgColorStateList) {
    125.         this.bgColorStateList = bgColorStateList;
    126.         this.bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    127.         if (radiusDrawable != null) {
    128.             radiusDrawable.setBackground(this.bgColorStateList, solidColorStateList);
    129.         }
    130.         forceRefreshLayout();
    131.     }
    132.  
    133.     @Override
    134.     public void setSolidDashPathEffect(DashPathEffect dashPathEffect) {
    135.         if (dashPathEffect != null) {
    136.             this.dashPathEffect = dashPathEffect;
    137.             forceRefreshLayout();
    138.         }
    139.     }
    140.  
    141.     @Override
    142.     public void setSolidColor(int color) {
    143.         this.solidColorStateList = ColorStateList.valueOf(color);
    144.         if (radiusDrawable != null) {
    145.             radiusDrawable.setBackground(this.bgColorStateList, solidColorStateList);
    146.         }
    147.         forceRefreshLayout();
    148.     }
    149.  
    150.     @Override
    151.     public void setSolidColor(ColorStateList solidColorStateList) {
    152.         this.solidColorStateList = solidColorStateList;
    153.         if (radiusDrawable != null) {
    154.             radiusDrawable.setBackground(bgColorStateList, this.solidColorStateList);
    155.         }
    156.         forceRefreshLayout();
    157.     }
    158.  
    159.     @Override
    160.     public void setRadius(int radius) {
    161.         if (radius >= 0) {
    162.             leftTopRadius = radius;
    163.             rightTopRadius = radius;
    164.             rightBottomRadius = radius;
    165.             leftBottomRadius = radius;
    166.             forceRefreshLayout();
    167.         }
    168.     }
    169.  
    170.     @Override
    171.     public void setRadius(int leftTopRadius, int rightTopRadius, int rightBottomRadius, int leftBottomRadius) {
    172.         this.leftTopRadius = leftTopRadius;
    173.         this.rightTopRadius = rightTopRadius;
    174.         this.rightBottomRadius = rightBottomRadius;
    175.         this.leftBottomRadius = leftBottomRadius;
    176.         forceRefreshLayout();
    177.     }
    178.  
    179.     @Override
    180.     public void setLeftTopRadius(int leftTopRadius) {
    181.         this.leftTopRadius = leftTopRadius;
    182.         forceRefreshLayout();
    183.     }
    184.  
    185.     @Override
    186.     public void setRightTopRadius(int rightTopRadius) {
    187.         this.rightTopRadius = rightTopRadius;
    188.         forceRefreshLayout();
    189.     }
    190.  
    191.     @Override
    192.     public void setRightBottomRadius(int rightBottomRadius) {
    193.         this.rightBottomRadius = rightBottomRadius;
    194.         forceRefreshLayout();
    195.     }
    196.  
    197.     @Override
    198.     public void setLeftBottomRadius(int leftBottomRadius) {
    199.         this.leftBottomRadius = leftBottomRadius;
    200.         forceRefreshLayout();
    201.     }
    202.  
    203.     @Override
    204.     public void setShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors) {
    205.         setShaderInfo(shapeType, shapeColors, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    206.     }
    207.  
    208.     @Override
    209.     public void setShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors, @ShaderUtils.LinearOrientation int shaderLinearOrientation) {
    210.         if (shapeColors == null || shapeColors.length <= 0)
    211.             return;
    212.         this.bgShaderType = shapeType;
    213.         this.bgShaderColors = shapeColors;
    214.         this.bgShaderLinearOrientation = shaderLinearOrientation;
    215.         forceRefreshLayout();
    216.     }
    217.  
    218.     @Override
    219.     public void setSolidShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors) {
    220.         setSolidShaderInfo(shapeType, shapeColors, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    221.     }
    222.  
    223.     @Override
    224.     public void setSolidShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors, @ShaderUtils.LinearOrientation int shaderLinearOrientation) {
    225.         if (shapeColors == null || shapeColors.length <= 0)
    226.             return;
    227.         this.solidShaderType = shapeType;
    228.         this.solidShaderColors = shapeColors;
    229.         this.solidShaderLinearOrientation = shaderLinearOrientation;
    230.         forceRefreshLayout();
    231.     }
    232.  
    233.     @Override
    234.     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    235.         super.onLayout(changed, left, top, right, bottom);
    236.  
    237.         // 没有发生改变，并且不需要强制刷新就不在重新layout
    238.         if (!changed && !this.forceRefreshLayout) {
    239.             return;
    240.         }
    241.         this.forceRefreshLayout = false;
    242.  
    243.         width = getWidth();
    244.         height = getHeight();
    245.  
    246.         final Path bgPath = setBackground();
    247.  
    248.         // 手动设置阴影，使用裁剪后的路径，防止阴影直角矩形显示
    249.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    250.             float elevation = Math.max(getElevation(), getTranslationZ());
    251.             if (elevation > 0) {
    252.                 setElevation(elevation);
    253.                 setOutlineProvider(new ViewOutlineProvider() {
    254.                     @Override
    255.                     public void getOutline(View view, Outline outline) {
    256.                         if (bgPath.isConvex()) {
    257.                             outline.setConvexPath(bgPath);
    258.                         } else {
    259.                             outline.setConvexPath(RadiusUtils.calculateBgPath(leftTopRadius, rightTopRadius,
    260.                                     leftBottomRadius, rightBottomRadius, width, height, false));
    261.                         }
    262.                     }
    263.                 });
    264.                 setClipToOutline(true);
    265.             }
    266.         }
    267.     }
    268.  
    269.     private void forceRefreshLayout() {
    270.         this.forceRefreshLayout = true;
    271.         requestLayout();
    272.     }
    273.  
    274.     private Path setBackground() {
    275.         final Path bgPath = RadiusUtils.calculateBgPath(leftTopRadius, rightTopRadius,
    276.                 leftBottomRadius, rightBottomRadius, width, height);
    277.  
    278.         Shader bgShader = null;
    279.         if (bgShaderType != ShaderUtils.SHADER_TYPE_NONE) {
    280.             bgShader = ShaderUtils.createShader(bgShaderType, width, height, bgShaderColors, bgShaderLinearOrientation);
    281.         }
    282.         // 边框
    283.         if (solidWidth > 0) {
    284.             Shader solidShader = null;
    285.             if (solidShaderType != ShaderUtils.SHADER_TYPE_NONE) {
    286.                 solidShader = ShaderUtils.createShader(solidShaderType, width, height, solidShaderColors, solidShaderLinearOrientation);
    287.             }
    288.  
    289.             Path[] solidPathArray = RadiusUtils.calculateSocketPath(leftTopRadius, rightTopRadius,
    290.                     leftBottomRadius, rightBottomRadius, width, height, solidWidth);
    291.             List solidPath = Arrays.asList(solidPathArray);
    292.  
    293.             radiusDrawable = new RadiusDrawable(bgColorStateList, bgShader, bgPath, solidWidth, solidColorStateList, solidShader, solidPath, dashPathEffect);
    294.         } else {
    295.             radiusDrawable = new RadiusDrawable(bgColorStateList, bgShader, bgPath);
    296.         }
    297.         setBackground(radiusDrawable);
    298.         return bgPath;
    299.     }
    300. }

    10.圆角EditText    RadiusEditText

    1. public class RadiusEditText extends ClearAbleEditText implements IRadiusLayout {
    2.     // 控件宽高
    3.     private int width, height;
    4.     // 圆角参数
    5.     private int leftTopRadius;
    6.     private int rightTopRadius;
    7.     private int rightBottomRadius;
    8.     private int leftBottomRadius;
    9.  
    10.     private RadiusDrawable radiusDrawable;
    11.     private ColorStateList bgColorStateList;
    12.     // 渐变背景
    13.     private int[] bgShaderColors; // 背景渐变颜色值，优先级高于 bgColorStateList
    14.     private int bgShaderType; // 渐变类型
    15.     private int bgShaderLinearOrientation; // 线性渐变方向
    16.  
    17.     // 边框参数
    18.     private int solidWidth;
    19.     private ColorStateList solidColorStateList;
    20.     private DashPathEffect dashPathEffect = null;
    21.     // 渐变边框
    22.     private int[] solidShaderColors; // 边框渐变颜色值，优先级高于 bgColorStateList
    23.     private int solidShaderType; // 边框类型
    24.     private int solidShaderLinearOrientation; // 线性渐变方向
    25.     // 是否需要强制重新布局
    26.     private boolean forceRefreshLayout;
    27.  
    28.     public RadiusEditText(Context context) {
    29.         this(context, null);
    30.     }
    31.  
    32.     public RadiusEditText(Context context, AttributeSet attrs) {
    33.         this(context, attrs, 0);
    34.     }
    35.  
    36.     public RadiusEditText(Context context, AttributeSet attrs, int defStyleAttr) {
    37.         super(context, attrs, defStyleAttr);
    38.         init(context, attrs);
    39.     }
    40.  
    41.     protected void init(Context context, AttributeSet attrs) {
    42.         setFocusableInTouchMode(true);
    43.         if (Build.VERSION.SDK_INT < 18) setLayerType(View.LAYER_TYPE_SOFTWARE, null);
    44.         // 读取圆角配置
    45.         TypedArray radiusType = context.obtainStyledAttributes(attrs, R.styleable.RadiusView);
    46.         int radius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_all, DEFAULT_RADIUS);
    47.         leftTopRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_leftTop, DEFAULT_RADIUS);
    48.         rightTopRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_rightTop, DEFAULT_RADIUS);
    49.         rightBottomRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_rightBottom, DEFAULT_RADIUS);
    50.         leftBottomRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_leftBottom, DEFAULT_RADIUS);
    51.  
    52.         // 获取背景信息
    53.         bgColorStateList = radiusType.getColorStateList(R.styleable.RadiusView_rv_background_color);
    54.         int startColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_start_color, ShaderUtils.COLOR_VALUE_NONE);
    55.         int middleColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_middle_color, ShaderUtils.COLOR_VALUE_NONE);
    56.         int endColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_end_color, ShaderUtils.COLOR_VALUE_NONE);
    57.         bgShaderType = radiusType.getInt(R.styleable.RadiusView_rv_shader_type, ShaderUtils.SHADER_TYPE_NONE);
    58.         bgShaderLinearOrientation = radiusType.getInt(R.styleable.RadiusView_rv_shader_linear_orientation, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    59.         bgShaderColors = ShaderUtils.createColorsArray(startColor, middleColor, endColor);
    60.         if (bgShaderColors == null)
    61.             bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    62.  
    63.  
    64.         // 获取边框信息
    65.         solidWidth = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_width, 0);
    66.         solidColorStateList = radiusType.getColorStateList(R.styleable.RadiusView_rv_solid_color);
    67.         int dashGap = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_dashGap, 0);
    68.         int dashWidth = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_dashWidth, 0);
    69.         int lineType = radiusType.getInt(R.styleable.RadiusView_rv_solid_type, SOLID_TYPE_SOLID);
    70.         int solidStartColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_start_color, ShaderUtils.COLOR_VALUE_NONE);
    71.         int solidMiddleColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_middle_color, ShaderUtils.COLOR_VALUE_NONE);
    72.         int solidEndColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_end_color, ShaderUtils.COLOR_VALUE_NONE);
    73.         solidShaderType = radiusType.getInt(R.styleable.RadiusView_rv_solid_shader_type, ShaderUtils.SHADER_TYPE_NONE);
    74.         solidShaderLinearOrientation = radiusType.getInt(R.styleable.RadiusView_rv_solid_shader_linear_orientation, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    75.         solidShaderColors = ShaderUtils.createColorsArray(solidStartColor, solidMiddleColor, solidEndColor);
    76.         if (solidShaderColors == null)
    77.             solidShaderType = ShaderUtils.SHADER_TYPE_NONE;
    78.  
    79.         radiusType.recycle();
    80.  
    81.         // 角度边长不能小于0
    82.         if (DEFAULT_RADIUS >= radius) radius = DEFAULT_RADIUS;
    83.         //如果四个角的值没有设置，那么就使用通用的radius的值。
    84.         if (DEFAULT_RADIUS >= leftTopRadius) leftTopRadius = radius;
    85.         if (DEFAULT_RADIUS >= rightTopRadius) rightTopRadius = radius;
    86.         if (DEFAULT_RADIUS >= rightBottomRadius) rightBottomRadius = radius;
    87.         if (DEFAULT_RADIUS >= leftBottomRadius) leftBottomRadius = radius;
    88.  
    89.  
    90.         if (bgColorStateList == null) {
    91.             bgColorStateList = ColorStateList.valueOf(Color.TRANSPARENT);
    92.         }
    93.         if (solidColorStateList == null) {
    94.             solidColorStateList = ColorStateList.valueOf(Color.TRANSPARENT);
    95.         }
    96.  
    97.         if (lineType == SOLID_TYPE_DASH) {
    98.             dashPathEffect = new DashPathEffect(new float[]{dashWidth, dashGap}, 0);
    99.         } else {
    100.             dashPathEffect = null;
    101.         }
    102.     }
    103.  
    104.     @Override
    105.     public void setBackgroundColor(int color) {
    106.         this.bgColorStateList = ColorStateList.valueOf(color);
    107.         this.bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    108.         if (radiusDrawable != null) {
    109.             radiusDrawable.setBackground(bgColorStateList, solidColorStateList);
    110.         }
    111.         forceRefreshLayout();
    112.     }
    113.  
    114.     @Override
    115.     public void setBackgroundColor(ColorStateList bgColorStateList) {
    116.         this.bgColorStateList = bgColorStateList;
    117.         this.bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    118.         if (radiusDrawable != null) {
    119.             radiusDrawable.setBackground(this.bgColorStateList, solidColorStateList);
    120.         }
    121.         forceRefreshLayout();
    122.     }
    123.  
    124.     @Override
    125.     public void setSolidDashPathEffect(DashPathEffect dashPathEffect) {
    126.         if (dashPathEffect != null) {
    127.             this.dashPathEffect = dashPathEffect;
    128.             forceRefreshLayout();
    129.         }
    130.     }
    131.  
    132.     @Override
    133.     public void setSolidColor(int color) {
    134.         this.solidColorStateList = ColorStateList.valueOf(color);
    135.         if (radiusDrawable != null) {
    136.             radiusDrawable.setBackground(this.bgColorStateList, solidColorStateList);
    137.         }
    138.         forceRefreshLayout();
    139.     }
    140.  
    141.     @Override
    142.     public void setSolidColor(ColorStateList solidColorStateList) {
    143.         this.solidColorStateList = solidColorStateList;
    144.         if (radiusDrawable != null) {
    145.             radiusDrawable.setBackground(bgColorStateList, this.solidColorStateList);
    146.         }
    147.         forceRefreshLayout();
    148.     }
    149.  
    150.     @Override
    151.     public void setRadius(int radius) {
    152.         if (radius >= 0) {
    153.             leftTopRadius = radius;
    154.             rightTopRadius = radius;
    155.             rightBottomRadius = radius;
    156.             leftBottomRadius = radius;
    157.             forceRefreshLayout();
    158.         }
    159.     }
    160.  
    161.     @Override
    162.     public void setRadius(int leftTopRadius, int rightTopRadius, int rightBottomRadius, int leftBottomRadius) {
    163.         this.leftTopRadius = leftTopRadius;
    164.         this.rightTopRadius = rightTopRadius;
    165.         this.rightBottomRadius = rightBottomRadius;
    166.         this.leftBottomRadius = leftBottomRadius;
    167.         forceRefreshLayout();
    168.     }
    169.  
    170.     @Override
    171.     public void setLeftTopRadius(int leftTopRadius) {
    172.         this.leftTopRadius = leftTopRadius;
    173.         forceRefreshLayout();
    174.     }
    175.  
    176.     @Override
    177.     public void setRightTopRadius(int rightTopRadius) {
    178.         this.rightTopRadius = rightTopRadius;
    179.         forceRefreshLayout();
    180.     }
    181.  
    182.     @Override
    183.     public void setRightBottomRadius(int rightBottomRadius) {
    184.         this.rightBottomRadius = rightBottomRadius;
    185.         forceRefreshLayout();
    186.     }
    187.  
    188.     @Override
    189.     public void setLeftBottomRadius(int leftBottomRadius) {
    190.         this.leftBottomRadius = leftBottomRadius;
    191.         forceRefreshLayout();
    192.     }
    193.  
    194.     @Override
    195.     public void setShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors) {
    196.         setShaderInfo(shapeType, shapeColors, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    197.     }
    198.  
    199.     @Override
    200.     public void setShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors, @ShaderUtils.LinearOrientation int shaderLinearOrientation) {
    201.         if (shapeColors == null || shapeColors.length <= 0)
    202.             return;
    203.         this.bgShaderType = shapeType;
    204.         this.bgShaderColors = shapeColors;
    205.         this.bgShaderLinearOrientation = shaderLinearOrientation;
    206.         forceRefreshLayout();
    207.     }
    208.  
    209.     @Override
    210.     public void setSolidShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors) {
    211.         setSolidShaderInfo(shapeType, shapeColors, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    212.     }
    213.  
    214.     @Override
    215.     public void setSolidShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors, @ShaderUtils.LinearOrientation int shaderLinearOrientation) {
    216.         if (shapeColors == null || shapeColors.length <= 0)
    217.             return;
    218.         this.solidShaderType = shapeType;
    219.         this.solidShaderColors = shapeColors;
    220.         this.solidShaderLinearOrientation = shaderLinearOrientation;
    221.         forceRefreshLayout();
    222.     }
    223.  
    224.     @Override
    225.     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    226.         super.onLayout(changed, left, top, right, bottom);
    227.  
    228.         // 没有发生改变，并且不需要强制刷新就不在重新layout
    229.         if (!changed && !this.forceRefreshLayout) {
    230.             return;
    231.         }
    232.         this.forceRefreshLayout = false;
    233.  
    234.         width = getWidth();
    235.         height = getHeight();
    236.  
    237.         final Path bgPath = setBackground();
    238.  
    239.         // 手动设置阴影，使用裁剪后的路径，防止阴影直角矩形显示
    240.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    241.             float elevation = Math.max(getElevation(), getTranslationZ());
    242.             if (elevation > 0) {
    243.                 setElevation(elevation);
    244.                 setOutlineProvider(new ViewOutlineProvider() {
    245.                     @Override
    246.                     public void getOutline(View view, Outline outline) {
    247.                         if (bgPath.isConvex()) {
    248.                             outline.setConvexPath(bgPath);
    249.                         } else {
    250.                             outline.setConvexPath(RadiusUtils.calculateBgPath(leftTopRadius, rightTopRadius,
    251.                                     leftBottomRadius, rightBottomRadius, width, height, false));
    252.                         }
    253.                     }
    254.                 });
    255.                 setClipToOutline(true);
    256.             }
    257.         }
    258.     }
    259.  
    260.     private void forceRefreshLayout() {
    261.         this.forceRefreshLayout = true;
    262.         requestLayout();
    263.     }
    264.  
    265.     private Path setBackground() {
    266.         Path bgPath = RadiusUtils.calculateBgPath(leftTopRadius, rightTopRadius,
    267.                 leftBottomRadius, rightBottomRadius, width, height);
    268.  
    269.         Shader bgShader = null;
    270.         if (bgShaderType != ShaderUtils.SHADER_TYPE_NONE) {
    271.             bgShader = ShaderUtils.createShader(bgShaderType, width, height, bgShaderColors, bgShaderLinearOrientation);
    272.         }
    273.         // 边框
    274.         if (solidWidth > 0) {
    275.             Shader solidShader = null;
    276.             if (solidShaderType != ShaderUtils.SHADER_TYPE_NONE) {
    277.                 solidShader = ShaderUtils.createShader(solidShaderType, width, height, solidShaderColors, solidShaderLinearOrientation);
    278.             }
    279.  
    280.             Path[] solidPathArray = RadiusUtils.calculateSocketPath(leftTopRadius, rightTopRadius,
    281.                     leftBottomRadius, rightBottomRadius, width, height, solidWidth);
    282.             List  solidPath = Arrays.asList(solidPathArray);
    283.  
    284.             radiusDrawable = new RadiusDrawable(bgColorStateList, bgShader, bgPath, solidWidth, solidColorStateList, solidShader, solidPath, dashPathEffect);
    285.         } else {
    286.             radiusDrawable = new RadiusDrawable(bgColorStateList, bgShader, bgPath);
    287.         }
    288.         setBackground(radiusDrawable);
    289.         return bgPath;
    290.     }
    291. }

    11.圆角Button  RadiusButton

    1. public class RadiusButton extends AppCompatButton implements IRadiusLayout {
    2.     // 控件宽高
    3.     private int width, height;
    4.     // 圆角参数
    5.     private int leftTopRadius;
    6.     private int rightTopRadius;
    7.     private int rightBottomRadius;
    8.     private int leftBottomRadius;
    9.  
    10.     private RadiusDrawable radiusDrawable;
    11.     private ColorStateList bgColorStateList;
    12.     // 渐变背景
    13.     private int[] bgShaderColors; // 背景渐变颜色值，优先级高于 bgColorStateList
    14.     private int bgShaderType; // 渐变类型
    15.     private int bgShaderLinearOrientation; // 线性渐变方向
    16.  
    17.     // 边框参数
    18.     private int solidWidth;
    19.     private ColorStateList solidColorStateList;
    20.     private DashPathEffect dashPathEffect = null;
    21.     // 渐变边框
    22.     private int[] solidShaderColors; // 边框渐变颜色值，优先级高于 bgColorStateList
    23.     private int solidShaderType; // 边框类型
    24.     private int solidShaderLinearOrientation; // 线性渐变方向
    25.     // 是否需要强制重新布局
    26.     private boolean forceRefreshLayout;
    27.  
    28.     public RadiusButton(Context context) {
    29.         this(context, null);
    30.     }
    31.  
    32.     public RadiusButton(Context context, AttributeSet attrs) {
    33.         this(context, attrs, 0);
    34.     }
    35.  
    36.     public RadiusButton(Context context, AttributeSet attrs, int defStyleAttr) {
    37.         super(context, attrs, defStyleAttr);
    38.         init(context, attrs);
    39.     }
    40.  
    41.     protected void init(Context context, AttributeSet attrs) {
    42.         if (Build.VERSION.SDK_INT < 18) setLayerType(View.LAYER_TYPE_SOFTWARE, null);
    43.         // 读取圆角配置
    44.         TypedArray radiusType = context.obtainStyledAttributes(attrs, R.styleable.RadiusView);
    45.         int radius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_all, DEFAULT_RADIUS);
    46.         leftTopRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_leftTop, DEFAULT_RADIUS);
    47.         rightTopRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_rightTop, DEFAULT_RADIUS);
    48.         rightBottomRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_rightBottom, DEFAULT_RADIUS);
    49.         leftBottomRadius = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_radius_leftBottom, DEFAULT_RADIUS);
    50.  
    51.         // 获取背景信息
    52.         bgColorStateList = radiusType.getColorStateList(R.styleable.RadiusView_rv_background_color);
    53.         int startColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_start_color, ShaderUtils.COLOR_VALUE_NONE);
    54.         int middleColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_middle_color, ShaderUtils.COLOR_VALUE_NONE);
    55.         int endColor = radiusType.getColor(R.styleable.RadiusView_rv_shader_end_color, ShaderUtils.COLOR_VALUE_NONE);
    56.         bgShaderType = radiusType.getInt(R.styleable.RadiusView_rv_shader_type, ShaderUtils.SHADER_TYPE_NONE);
    57.         bgShaderLinearOrientation = radiusType.getInt(R.styleable.RadiusView_rv_shader_linear_orientation, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    58.         bgShaderColors = ShaderUtils.createColorsArray(startColor, middleColor, endColor);
    59.         if (bgShaderColors == null)
    60.             bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    61.  
    62.  
    63.         // 获取边框信息
    64.         solidWidth = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_width, 0);
    65.         solidColorStateList = radiusType.getColorStateList(R.styleable.RadiusView_rv_solid_color);
    66.         int dashGap = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_dashGap, 0);
    67.         int dashWidth = radiusType.getDimensionPixelSize(R.styleable.RadiusView_rv_solid_dashWidth, 0);
    68.         int lineType = radiusType.getInt(R.styleable.RadiusView_rv_solid_type, SOLID_TYPE_SOLID);
    69.         int solidStartColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_start_color, ShaderUtils.COLOR_VALUE_NONE);
    70.         int solidMiddleColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_middle_color, ShaderUtils.COLOR_VALUE_NONE);
    71.         int solidEndColor = radiusType.getColor(R.styleable.RadiusView_rv_solid_shader_end_color, ShaderUtils.COLOR_VALUE_NONE);
    72.         solidShaderType = radiusType.getInt(R.styleable.RadiusView_rv_solid_shader_type, ShaderUtils.SHADER_TYPE_NONE);
    73.         solidShaderLinearOrientation = radiusType.getInt(R.styleable.RadiusView_rv_solid_shader_linear_orientation, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    74.         solidShaderColors = ShaderUtils.createColorsArray(solidStartColor, solidMiddleColor, solidEndColor);
    75.         if (solidShaderColors == null)
    76.             solidShaderType = ShaderUtils.SHADER_TYPE_NONE;
    77.  
    78.         radiusType.recycle();
    79.  
    80.         // 角度边长不能小于0
    81.         if (DEFAULT_RADIUS >= radius) radius = DEFAULT_RADIUS;
    82.         //如果四个角的值没有设置，那么就使用通用的radius的值。
    83.         if (DEFAULT_RADIUS >= leftTopRadius) leftTopRadius = radius;
    84.         if (DEFAULT_RADIUS >= rightTopRadius) rightTopRadius = radius;
    85.         if (DEFAULT_RADIUS >= rightBottomRadius) rightBottomRadius = radius;
    86.         if (DEFAULT_RADIUS >= leftBottomRadius) leftBottomRadius = radius;
    87.  
    88.  
    89.         if (bgColorStateList == null) {
    90.             bgColorStateList = ColorStateList.valueOf(Color.TRANSPARENT);
    91.         }
    92.         if (solidColorStateList == null) {
    93.             solidColorStateList = ColorStateList.valueOf(Color.TRANSPARENT);
    94.         }
    95.  
    96.         if (lineType == SOLID_TYPE_DASH) {
    97.             dashPathEffect = new DashPathEffect(new float[]{dashWidth, dashGap}, 0);
    98.         } else {
    99.             dashPathEffect = null;
    100.         }
    101.     }
    102.  
    103.     @Override
    104.     public void setBackgroundColor(int color) {
    105.         this.bgColorStateList = ColorStateList.valueOf(color);
    106.         this.bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    107.         if (radiusDrawable != null) {
    108.             radiusDrawable.setBackground(bgColorStateList, solidColorStateList);
    109.         }
    110.         forceRefreshLayout();
    111.     }
    112.  
    113.     @Override
    114.     public void setBackgroundColor(ColorStateList bgColorStateList) {
    115.         this.bgColorStateList = bgColorStateList;
    116.         this.bgShaderType = ShaderUtils.SHADER_TYPE_NONE;
    117.         if (radiusDrawable != null) {
    118.             radiusDrawable.setBackground(this.bgColorStateList, solidColorStateList);
    119.         }
    120.         forceRefreshLayout();
    121.     }
    122.  
    123.     @Override
    124.     public void setSolidDashPathEffect(DashPathEffect dashPathEffect) {
    125.         if (dashPathEffect != null) {
    126.             this.dashPathEffect = dashPathEffect;
    127.             forceRefreshLayout();
    128.         }
    129.     }
    130.  
    131.     @Override
    132.     public void setSolidColor(int color) {
    133.         this.solidColorStateList = ColorStateList.valueOf(color);
    134.         if (radiusDrawable != null) {
    135.             radiusDrawable.setBackground(this.bgColorStateList, solidColorStateList);
    136.         }
    137.         forceRefreshLayout();
    138.     }
    139.  
    140.     @Override
    141.     public void setSolidColor(ColorStateList solidColorStateList) {
    142.         this.solidColorStateList = solidColorStateList;
    143.         if (radiusDrawable != null) {
    144.             radiusDrawable.setBackground(bgColorStateList, this.solidColorStateList);
    145.         }
    146.         forceRefreshLayout();
    147.     }
    148.  
    149.     @Override
    150.     public void setRadius(int radius) {
    151.         if (radius >= 0) {
    152.             leftTopRadius = radius;
    153.             rightTopRadius = radius;
    154.             rightBottomRadius = radius;
    155.             leftBottomRadius = radius;
    156.             forceRefreshLayout();
    157.         }
    158.     }
    159.  
    160.     @Override
    161.     public void setRadius(int leftTopRadius, int rightTopRadius, int rightBottomRadius, int leftBottomRadius) {
    162.         this.leftTopRadius = leftTopRadius;
    163.         this.rightTopRadius = rightTopRadius;
    164.         this.rightBottomRadius = rightBottomRadius;
    165.         this.leftBottomRadius = leftBottomRadius;
    166.         forceRefreshLayout();
    167.     }
    168.  
    169.     @Override
    170.     public void setLeftTopRadius(int leftTopRadius) {
    171.         this.leftTopRadius = leftTopRadius;
    172.         forceRefreshLayout();
    173.     }
    174.  
    175.     @Override
    176.     public void setRightTopRadius(int rightTopRadius) {
    177.         this.rightTopRadius = rightTopRadius;
    178.         forceRefreshLayout();
    179.     }
    180.  
    181.     @Override
    182.     public void setRightBottomRadius(int rightBottomRadius) {
    183.         this.rightBottomRadius = rightBottomRadius;
    184.         forceRefreshLayout();
    185.     }
    186.  
    187.     @Override
    188.     public void setLeftBottomRadius(int leftBottomRadius) {
    189.         this.leftBottomRadius = leftBottomRadius;
    190.         forceRefreshLayout();
    191.     }
    192.  
    193.     @Override
    194.     public void setShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors) {
    195.         setShaderInfo(shapeType, shapeColors, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    196.     }
    197.  
    198.     @Override
    199.     public void setShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors, @ShaderUtils.LinearOrientation int shaderLinearOrientation) {
    200.         if (shapeColors == null || shapeColors.length <= 0)
    201.             return;
    202.         this.bgShaderType = shapeType;
    203.         this.bgShaderColors = shapeColors;
    204.         this.bgShaderLinearOrientation = shaderLinearOrientation;
    205.         forceRefreshLayout();
    206.     }
    207.  
    208.     @Override
    209.     public void setSolidShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors) {
    210.         setSolidShaderInfo(shapeType, shapeColors, ShaderUtils.LINEAR_ORIENTATION_TOP_TO_BOTTOM);
    211.     }
    212.  
    213.     @Override
    214.     public void setSolidShaderInfo(@ShaderUtils.ShaderType int shapeType, int[] shapeColors, @ShaderUtils.LinearOrientation int shaderLinearOrientation) {
    215.         if (shapeColors == null || shapeColors.length <= 0)
    216.             return;
    217.         this.solidShaderType = shapeType;
    218.         this.solidShaderColors = shapeColors;
    219.         this.solidShaderLinearOrientation = shaderLinearOrientation;
    220.         forceRefreshLayout();
    221.     }
    222.  
    223.     @Override
    224.     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    225.         super.onLayout(changed, left, top, right, bottom);
    226.  
    227.         // 没有发生改变，并且不需要强制刷新就不在重新layout
    228.         if (!changed && !this.forceRefreshLayout) {
    229.             return;
    230.         }
    231.         this.forceRefreshLayout = false;
    232.  
    233.         width = getWidth();
    234.         height = getHeight();
    235.  
    236.         final Path bgPath = setBackground();
    237.  
    238.         // 手动设置阴影，使用裁剪后的路径，防止阴影直角矩形显示
    239.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    240.             float elevation = Math.max(getElevation(), getTranslationZ());
    241.             if (elevation > 0) {
    242.                 setElevation(elevation);
    243.                 setOutlineProvider(new ViewOutlineProvider() {
    244.                     @Override
    245.                     public void getOutline(View view, Outline outline) {
    246.                         if (bgPath.isConvex()) {
    247.                             outline.setConvexPath(bgPath);
    248.                         } else {
    249.                             outline.setConvexPath(RadiusUtils.calculateBgPath(leftTopRadius, rightTopRadius,
    250.                                     leftBottomRadius, rightBottomRadius, width, height, false));
    251.                         }
    252.                     }
    253.                 });
    254.                 setClipToOutline(true);
    255.             }
    256.         }
    257.     }
    258.  
    259.     private void forceRefreshLayout() {
    260.         this.forceRefreshLayout = true;
    261.         requestLayout();
    262.     }
    263.  
    264.     private Path setBackground() {
    265.         Path bgPath = RadiusUtils.calculateBgPath(leftTopRadius, rightTopRadius,
    266.                 leftBottomRadius, rightBottomRadius, width, height);
    267.  
    268.         Shader bgShader = null;
    269.         if (bgShaderType != ShaderUtils.SHADER_TYPE_NONE) {
    270.             bgShader = ShaderUtils.createShader(bgShaderType, width, height, bgShaderColors, bgShaderLinearOrientation);
    271.         }
    272.  
    273.         // 边框
    274.         if (solidWidth > 0) {
    275.             Shader solidShader = null;
    276.             if (solidShaderType != ShaderUtils.SHADER_TYPE_NONE) {
    277.                 solidShader = ShaderUtils.createShader(solidShaderType, width, height, solidShaderColors, solidShaderLinearOrientation);
    278.             }
    279.  
    280.             Path[] solidPathArray = RadiusUtils.calculateSocketPath(leftTopRadius, rightTopRadius,
    281.                     leftBottomRadius, rightBottomRadius, width, height, solidWidth);
    282.             List solidPath = Arrays.asList(solidPathArray);
    283.  
    284.             radiusDrawable = new RadiusDrawable(bgColorStateList, bgShader, bgPath, solidWidth, solidColorStateList, solidShader, solidPath, dashPathEffect);
    285.         } else {
    286.             radiusDrawable = new RadiusDrawable(bgColorStateList, bgShader, bgPath);
    287.         }
    288.         setBackground(radiusDrawable);
    289.         return bgPath;
    290.     }
    291. }

    12.代码使用样式

    1.  <com.sc.scxm.cs.radius.RadiusRelativeLayout
    2.         android:layout_centerInParent="true"
    3.         android:layout_width="@dimen/dp_100"
    4.         android:layout_height="@dimen/dp_100"
    5.         app:rv_radius_all="@dimen/dp_10"
    6.         app:rv_background_color="@color/colorAccent"
    7.         app:rv_solid_width="@dimen/dp_1"
    8.         app:rv_solid_shader_start_color="#CDBC78"
    9.         app:rv_solid_shader_middle_color="#F5FFE3"
    10.         app:rv_solid_shader_middle_color2="#CCBA77"
    11.         app:rv_solid_shader_middle_color3="@color/white"
    12.         app:rv_solid_shader_end_color="#DDC66D"
    13.         app:rv_solid_shader_type="linear"
    14.         />

  • 相关阅读:
    JMeter 做接口性能测试，YYDS！
    L1-028 判断素数
    [数据结构] 图---图的邻接矩阵存储方式模拟实现，包括BFS广度优先遍历和DFS深度优先遍历（上）
    【WIFI】【WPS】如何从log角度判断WPS 已经连接上
    JAVA常见基础面试问题汇集
    麒麟V10服务器搭建FTP服务
    AI大模型的制作：RAG和向量数据库，分别是什么？
    binder通信之Messenger介绍
    第十七章：Java连接数据库jdbc（java和myql数据库连接）
    prometheus中PromQL查询语言
  • 原文地址：https://blog.csdn.net/qq_15059163/article/details/126974784