Android实现万能自定义阴影控件实例代码

前端之家收集整理的这篇文章主要介绍了Android实现万能自定义阴影控件实例代码前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

目录介绍

  • 01.阴影效果有哪些实现方式
  • 02.实现阴影效果Api
  • 03.设置阴影需要注意哪些
  • 04.常见Shape实现阴影效果
  • 05.自定义阴影效果控件
  • 06.如何使用该阴影控件
  • 07.在recyclerView中使用注意点

01.阴影效果有哪些实现方式

阴影效果有哪些实现方式

  • 第一种:使用CardView,但是不能设置阴影颜色
  • 第二种:采用shape叠加,存在后期UI效果不便优化
  • 第三种:UI切图
  • 第四种:自定义View

否定上面前两种方案原因分析?

  • 第一个方案的CardView渐变色和阴影效果很难控制,只能支持线性或者环装形式渐变,这种不满足需要,因为阴影本身是一个四周一层很淡的颜色包围,在一个矩形框的层面上颜色大概一致,而且这个CardView有很多局限性,比如不能修改阴影的颜色,不能修改阴影的深浅。所以这个思路无法实现这个需求。
  • 第二个采用shape叠加,可以实现阴影效果,但是影响UI,且阴影部分是占像素的,而且不灵活。
  • 第三个方案询问了一下ui。他们给出的结果是如果使用切图的话那标注的话很难标,身为一个优秀的设计师大多对像素点都和敏感,界面上的像素点有一点不协调那都是无法容忍的。
  • 在下面开源案例代码中,我会一一展示这几种不同方案实现的阴影效果

网上一些介绍阴影效果方案

  • 所有在深奥的技术,也都是为需求做准备的。也就是需要实践并且可以用到实际开发中,这篇文章不再抽象介绍阴影效果原理,理解三维空间中如何处理偏移光线达到阴影视差等,网上看了一些文章也没看明白或者理解。这篇博客直接通过调用api实现预期的效果

阴影是否占位

  • 使用CardView阴影不占位,不能设置阴影颜色和效果
  • 使用shape阴影是可以设置阴影颜色,但是是占位的

02.实现阴影效果Api

思考一下如何实现View阴影效果

  • 首先要明确阴影的实现思路是什么,其实就是颜色导致的视觉错觉。说白了就是在你的Card周围画一个渐变的体现立体感的颜色。基于上述思路,我们在一个在一个view上画一个矩形的图形,让他周围有渐变色的阴影即可。于是我们想起几个API:
  • 类:Paint 用于在Android上画图的类,相当于画笔
  • 类:Canvas 相当于画布,Android上的view的绘制都与他相关
  • 方法:paint.setShadowLayer可以给绘制的图形增加阴影,还可以设置阴影的颜色

paint.setShadowLayer(float radius,float dx,float dy,int shadowColor);

  • 这个方法可以达到这样一个效果,在使用canvas画图时给视图顺带上一层阴影效果

简单介绍一下这几个参数:

  • radius: 阴影半径,主要可以控制阴影的模糊效果以及阴影扩散出去的大小。
  • dx:阴影在X轴方向上的偏移量
  • dy: 阴影在Y轴方向上的偏移量
  • shadowColor: 阴影颜色。

终于找到了设置颜色的,通过设置shadowColor来控制视图的阴影颜色。

03.设置阴影需要注意哪些

其中涉及到几个属性,阴影的宽度,view到Viewgroup的距离,如果视图和父布局一样大的话,那阴影就不好显示,如果要能够显示出来就必须设置clipChildren=false。

还有就是视图自带的圆角,大部分背景都是有圆角的,比如上图中的圆角,需要达到高度还原阴影的效果就是的阴影的圆角和背景保持一致。

04.常见Shape实现阴影效果

多个drawable叠加

  • 使用layer-list可以将多个drawable按照顺序层叠在一起显示,默认情况下,所有的item中的drawable都会自动根据它附上view的大小而进行缩放,layer-list中的item是按照顺序从下往上叠加的,即先定义的item在下面,后面的依次往上面叠放

阴影效果代码如下所示

  • 这里有多层,就省略了一些。然后直接通过设置控件的background属性即可实现。
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <layer-list xmlns:android="http://schemas.android.com/apk/res/android">
  3. <item>
  4. <shape android:shape="rectangle">
  5. <solid android:color="@color/indexShadowColor_1" />
  6. <corners android:radius="5dip" />
  7. <padding
  8. android:bottom="1dp"
  9. android:left="1dp"
  10. android:right="1dp"
  11. android:top="1dp" />
  12. </shape>
  13. </item>
  14. <item>
  15. <shape android:shape="rectangle">
  16. <solid android:color="@color/indexShadowColor_2" />
  17. <corners android:radius="5dip" />
  18. <padding
  19. android:bottom="1dp"
  20. android:left="1dp"
  21. android:right="1dp"
  22. android:top="1dp" />
  23. </shape>
  24. </item>
  25.  
  26. ……
  27.  
  28. <item>
  29. <shape android:shape="rectangle">
  30. <corners android:radius="5dip" />
  31. <solid android:color="@color/indexColor" />
  32. </shape>
  33. </item>
  34. </layer-list>

05.自定义阴影效果控件

首先自定义属性

  1. <declare-styleable name="ShadowLayout">
  2. <!--阴影的圆角大小-->
  3. <attr name="yc_cornerRadius" format="dimension" />
  4. <!--阴影的扩散范围(也可以理解为扩散程度)-->
  5. <attr name="yc_shadowLimit" format="dimension" />
  6. <!--阴影颜色-->
  7. <attr name="yc_shadowColor" format="color" />
  8. <!--x轴的偏移量-->
  9. <attr name="yc_dx" format="dimension" />
  10. <!--y轴的偏移量-->
  11. <attr name="yc_dy" format="dimension" />
  12. <!--左边是否显示阴影-->
  13. <attr name="yc_leftShow" format="boolean" />
  14. <!--右边是否显示阴影-->
  15. <attr name="yc_rightShow" format="boolean" />
  16. <!--上边是否显示阴影-->
  17. <attr name="yc_topShow" format="boolean" />
  18. <!--下面是否显示阴影-->
  19. <attr name="yc_bottomShow" format="boolean" />
  20. </declare-styleable>

代码如下所示

  1. /**
  2. * <pre>
  3. * @author yangchong
  4. * blog : https://github.com/yangchong211
  5. * time : 2018/7/20
  6. * desc : 自定义阴影
  7. * revise:
  8. */
  9. public class ShadowLayout extends FrameLayout {
  10.  
  11. /**
  12. * 阴影颜色
  13. */
  14. private int mShadowColor;
  15. /**
  16. * 阴影的扩散范围(也可以理解为扩散程度)
  17. */
  18. private float mShadowLimit;
  19. /**
  20. * 阴影的圆角大小
  21. */
  22. private float mCornerRadius;
  23. /**
  24. * x轴的偏移量
  25. */
  26. private float mDx;
  27. /**
  28. * y轴的偏移量
  29. */
  30. private float mDy;
  31. /**
  32. * 左边是否显示阴影
  33. */
  34. private boolean leftShow;
  35. /**
  36. * 右边是否显示阴影
  37. */
  38. private boolean rightShow;
  39. /**
  40. * 上边是否显示阴影
  41. */
  42. private boolean topShow;
  43. /**
  44. * 下面是否显示阴影
  45. */
  46. private boolean bottomShow;
  47.  
  48. private boolean mInvalidateShadowOnSizeChanged = true;
  49. private boolean mForceInvalidateShadow = false;
  50.  
  51. public ShadowLayout(Context context) {
  52. super(context);
  53. initView(context,null);
  54. }
  55.  
  56. public ShadowLayout(Context context,AttributeSet attrs) {
  57. super(context,attrs);
  58. initView(context,attrs);
  59. }
  60.  
  61. public ShadowLayout(Context context,AttributeSet attrs,int defStyleAttr) {
  62. super(context,attrs,defStyleAttr);
  63. initView(context,attrs);
  64. }
  65.  
  66. @Override
  67. protected int getSuggestedMinimumWidth() {
  68. return 0;
  69. }
  70.  
  71. @Override
  72. protected int getSuggestedMinimumHeight() {
  73. return 0;
  74. }
  75.  
  76. @Override
  77. protected void onSizeChanged(int w,int h,int oldw,int oldh) {
  78. super.onSizeChanged(w,h,oldw,oldh);
  79. if (w > 0 && h > 0 && (getBackground() == null || mInvalidateShadowOnSizeChanged
  80. || mForceInvalidateShadow)) {
  81. mForceInvalidateShadow = false;
  82. setBackgroundCompat(w,h);
  83. }
  84. }
  85.  
  86. @Override
  87. protected void onLayout(boolean changed,int left,int top,int right,int bottom) {
  88. super.onLayout(changed,left,top,right,bottom);
  89. if (mForceInvalidateShadow) {
  90. mForceInvalidateShadow = false;
  91. setBackgroundCompat(right - left,bottom - top);
  92. }
  93. }
  94.  
  95. public void setInvalidateShadowOnSizeChanged(boolean invalidateShadowOnSizeChanged) {
  96. mInvalidateShadowOnSizeChanged = invalidateShadowOnSizeChanged;
  97. }
  98.  
  99. public void invalidateShadow() {
  100. mForceInvalidateShadow = true;
  101. requestLayout();
  102. invalidate();
  103. }
  104.  
  105. private void initView(Context context,AttributeSet attrs) {
  106. initAttributes(context,attrs);
  107.  
  108. int xPadding = (int) (mShadowLimit + Math.abs(mDx));
  109. int yPadding = (int) (mShadowLimit + Math.abs(mDy));
  110. int left;
  111. int right;
  112. int top;
  113. int bottom;
  114. if (leftShow) {
  115. left = xPadding;
  116. } else {
  117. left = 0;
  118. }
  119.  
  120. if (topShow) {
  121. top = yPadding;
  122. } else {
  123. top = 0;
  124. }
  125.  
  126. if (rightShow) {
  127. right = xPadding;
  128. } else {
  129. right = 0;
  130. }
  131.  
  132. if (bottomShow) {
  133. bottom = yPadding;
  134. } else {
  135. bottom = 0;
  136. }
  137.  
  138. setPadding(left,bottom);
  139. }
  140.  
  141. @SuppressWarnings("deprecation")
  142. private void setBackgroundCompat(int w,int h) {
  143. Bitmap bitmap = createShadowBitmap(w,mCornerRadius,mShadowLimit,mDx,mDy,mShadowColor,Color.TRANSPARENT);
  144. BitmapDrawable drawable = new BitmapDrawable(getResources(),bitmap);
  145. if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.JELLY_BEAN) {
  146. setBackgroundDrawable(drawable);
  147. } else {
  148. setBackground(drawable);
  149. }
  150. }
  151.  
  152. private void initAttributes(Context context,AttributeSet attrs) {
  153. TypedArray attr = getTypedArray(context,R.styleable.ShadowLayout);
  154. if (attr == null) {
  155. return;
  156. }
  157.  
  158. try {
  159. //默认是显示
  160. leftShow = attr.getBoolean(R.styleable.ShadowLayout_yc_leftShow,true);
  161. rightShow = attr.getBoolean(R.styleable.ShadowLayout_yc_rightShow,true);
  162. bottomShow = attr.getBoolean(R.styleable.ShadowLayout_yc_bottomShow,true);
  163. topShow = attr.getBoolean(R.styleable.ShadowLayout_yc_topShow,true);
  164.  
  165. mCornerRadius = attr.getDimension(R.styleable.ShadowLayout_yc_cornerRadius,0);
  166. mShadowLimit = attr.getDimension(R.styleable.ShadowLayout_yc_shadowLimit,0);
  167. mDx = attr.getDimension(R.styleable.ShadowLayout_yc_dx,0);
  168. mDy = attr.getDimension(R.styleable.ShadowLayout_yc_dy,0);
  169. mShadowColor = attr.getColor(R.styleable.ShadowLayout_yc_shadowColor,getResources().getColor(R.color.default_shadow_color));
  170. } finally {
  171. attr.recycle();
  172. }
  173. }
  174.  
  175. private TypedArray getTypedArray(Context context,AttributeSet attributeSet,int[] attr) {
  176. return context.obtainStyledAttributes(attributeSet,attr,0);
  177. }
  178.  
  179. private Bitmap createShadowBitmap(int shadowWidth,int shadowHeight,float cornerRadius,float shadowRadius,int shadowColor,int fillColor) {
  180.  
  181. //根据宽高创建bitmap背景
  182. Bitmap output = Bitmap.createBitmap(shadowWidth,shadowHeight,Bitmap.Config.ARGB_8888);
  183. //用画板canvas进行绘制
  184. Canvas canvas = new Canvas(output);
  185. RectF shadowRect = new RectF(shadowRadius,shadowRadius,shadowWidth - shadowRadius,shadowHeight - shadowRadius);
  186.  
  187. if (dy > 0) {
  188. shadowRect.top += dy;
  189. shadowRect.bottom -= dy;
  190. } else if (dy < 0) {
  191. shadowRect.top += Math.abs(dy);
  192. shadowRect.bottom -= Math.abs(dy);
  193. }
  194.  
  195. if (dx > 0) {
  196. shadowRect.left += dx;
  197. shadowRect.right -= dx;
  198. } else if (dx < 0) {
  199. shadowRect.left += Math.abs(dx);
  200. shadowRect.right -= Math.abs(dx);
  201. }
  202.  
  203. Paint shadowPaint = new Paint();
  204. shadowPaint.setAntiAlias(true);
  205. shadowPaint.setColor(fillColor);
  206. shadowPaint.setStyle(Paint.Style.FILL);
  207. if (!isInEditMode()) {
  208. shadowPaint.setShadowLayer(shadowRadius,dx,dy,shadowColor);
  209. }
  210. canvas.drawRoundRect(shadowRect,cornerRadius,shadowPaint);
  211. return output;
  212. }
  213. }
  214. ```

06.如何使用该阴影控件

十分简单,如下所示

  1. <com.ns.yc.yccardviewlib.shadow.ShadowLayout
  2. android:layout_width="wrap_content"
  3. android:layout_height="wrap_content"
  4. android:layout_gravity="center_horizontal"
  5. android:layout_marginTop="10dp"
  6. app:yc_cornerRadius="18dp"
  7. app:yc_dx="0dp"
  8. app:yc_dy="0dp"
  9. app:yc_shadowColor="#2a000000"
  10. app:yc_shadowLimit="5dp">
  11.  
  12. <TextView
  13. android:layout_width="wrap_content"
  14. android:layout_height="36dp"
  15. android:background="@drawable/shape_show_"
  16. android:gravity="center"
  17. android:paddingLeft="10dp"
  18. android:paddingRight="10dp"
  19. android:text="完全圆形圆角"
  20. android:textColor="#000" />
  21.  
  22. </com.ns.yc.yccardviewlib.shadow.ShadowLayout>

07.在recyclerView中使用注意点

在createShadowBitmap方法中,其实也可以看到需要创建bitmap对象。大家都知道bitmap比较容易造成内存过大,如果是给recyclerView中的item设置阴影效果,那么如何避免重复创建,这时候可以用到缓存。所以可以在上面的基础上再优化一下代码

先创建key,主要是用于map集合的键。这里为何用对象Key作为map的键呢,这里是借鉴了glide缓存图片的思路,可以创建Key对象的时候传入bitmap名称和宽高属性,并且需要重写hashCode和equals方法

  1. public class Key {
  2.  
  3. private final String name;
  4. private final int width;
  5. private final int height;
  6.  
  7. public Key(String name,int width,int height) {
  8. this.name = name;
  9. this.width = width;
  10. this.height = height;
  11. }
  12.  
  13. public String getName() {
  14. return name;
  15. }
  16.  
  17. public int getWidth() {
  18. return width;
  19. }
  20.  
  21. public int getHeight() {
  22. return height;
  23. }
  24.  
  25. @Override
  26. public boolean equals(Object o) {
  27. if (this == o) {
  28. return true;
  29. }
  30. if (o == null || getClass() != o.getClass()) {
  31. return false;
  32. }
  33. Key key = (Key) o;
  34. if (width != key.width) {
  35. return false;
  36. }
  37. if (height != key.height) {
  38. return false;
  39. }
  40. return name != null ? name.equals(key.name) : key.name == null;
  41. }
  42.  
  43. @Override
  44. public int hashCode() {
  45. int result = name != null ? name.hashCode() : 0;
  46. result = 31 * result + width;
  47. result = 31 * result + height;
  48. return result;
  49. }
  50. }

然后存取操作如下所示

  • 在查找的时候,通过Key进行查找。注意:Bitmap需要同时满足三个条件(高度、宽度、名称)都相同时才能算是同一个 Bitmap。
  1. Key key = new Key("bitmap",shadowWidth,shadowHeight);
  2. Bitmap output = cache.get(key);
  3. if(output == null){
  4. //根据宽高创建bitmap背景
  5. output = Bitmap.createBitmap(shadowWidth,Bitmap.Config.ARGB_8888);
  6. cache.put(key,output);
  7. LogUtil.v("bitmap对象-----","----直接创建对象,然后存入缓存之中---");
  8. } else {
  9. LogUtil.v("bitmap对象-----","----从缓存中取出对象---");
  10. }

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,谢谢大家对我们的支持

猜你在找的Android相关文章