效果图

可以看到这个自定义控件结合了颜色渐变、动态绘制刻度、动态水球效果。接下来我们就来看看这个效果是如何一步一步实现的。

开始自定义控件

和很多自定义控件方式一样需要去基础某种View或者某种ViewGroup

我这里选择的是View，如下所示：

1. public class HuaWeiView extends View { 
2.  
3.     /** 
4.      * 用来初始化画笔等 
5.      * @param context 
6.      * @param attrs 
7.      */ 
8.     public HuaWeiView(Context context, @Nullable AttributeSet attrs) { 
9.         super(context, attrs); 
10.     } 
11.  
12.     /** 
13.      * 用来测量限制view为正方形 
14.      * @param widthMeasureSpec 
15.      * @param heightMeasureSpec 
16.      */ 
17.     @Override 
18.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
19.         super.onMeasure(widthMeasureSpec, heightMeasureSpec); 
20.     } 
21.  
22.     /** 
23.      * 实现各种绘制功能 
24.      * @param canvas 
25.      */ 
26.     @Override 
27.     protected void onDraw(Canvas canvas) { 
28.         super.onDraw(canvas); 
29.     } 
30. }  

其中构造方法用来布局中使用。

onMeasure()方法用来测量和限定view大小

onDraw()方法用来进行具体的绘制功能

1.使用onMeasure()方法将View限制为一个正方形

只有确定了一个矩形才能够去画椭圆，如果这个矩形是正方形，椭圆也就随之变成了圆形。

1. @Override 
2.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
3.         super.onMeasure(widthMeasureSpec, heightMeasureSpec); 
4.         int width=MeasureSpec.getSize(widthMeasureSpec); 
5.         int height = MeasureSpec.getSize(heightMeasureSpec); 
6.         //以最小值为正方形的长 
7.         len=Math.min(width,height); 
8.         //设置测量高度和宽度（必须要调用，不然无效果） 
9.         setMeasuredDimension(len,len); 
10.     }  

分别通过MeasureSpec取得用户设置的宽和高，然后取出最小值，设置给我们的view，这样我们就做好了一个矩形

现在使用在布局中：

1. <?xml version="1.0" encoding="utf-8"?> 
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
3.     xmlns:app="http://schemas.android.com/apk/res-auto" 
4.     xmlns:tools="http://schemas.android.com/tools" 
5.     android:layout_width="match_parent" 
6.     android:layout_height="match_parent" 
7.     android:orientation="vertical" 
8.     android:background="@color/colorPrimary" 
9.     android:padding="20dp" 
10.     tools:context="com.example.huaweiview.MainActivity"> 
11.  
12.     <com.example.huaweiview.HuaWeiView 
13.         android:layout_gravity="center" 
14.         android:background="@color/colorAccent" 
15.         android:layout_width="200dp" 
16.         android:layout_height="300dp" 
17.         /> 
18.  
19. </LinearLayout> 

父布局背景为蓝色背景，控件背景为粉色背景，而且设置的宽高不同，但是控件的显示效果还是一个正方形，而且以小值为准。我们的onMeasure()生效了

接下来就是如何在确定一个圆形区域了

2.onDraw()绘制圆形区域

绘制之前我们需要对Android中的坐标系有个了解

我们都知道手机屏幕左上角为坐标原点，往右为X正轴，往下为Y正轴。其实手机页面就是activity的展示界面，也是一个View。那可不可以说所有的View在绘制图形的时候都有自己的这么一个坐标系呢(个人想法。。。)

也就是所每个View都有自己的一个坐标系，比如现在的自定义View：

现在我们需要在我们自定义的view中绘制一个圆弧，那么这个圆弧的半径就是我们自定义view的长度的一半，即：

radius=len/2;

那么圆心的坐标刚好是(radius,radius)

接下来开始绘制

1. @Override 
2.    protected void onDraw(Canvas canvas) { 
3.        super.onDraw(canvas); 
4.        //画圆弧的方法 
5.        canvas.drawArc(oval, startAngle, sweepAngle, useCenter,paint); 
6.    }  

介绍一下绘制圆弧的方法：

• 参数一oval是一个RectF对象为一个矩形
• 参数二startAngle为圆弧的起始角度
• 参数三sweepAngle为圆弧的经过角度(扫过角度)
• 参数四useCenter为圆弧是一个boolean值，为true时画的是圆弧，为false时画的是割弧
• 参数五paint为一个画笔对象

也就是说只要确定了一个矩形，在确定他起始和经过的角度就能够画出一个圆弧(这点大家可以用画板测试)

下来就是初始化这些参数

初始化矩形

1. @Override 
2.    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
3.        super.onMeasure(widthMeasureSpec, heightMeasureSpec); 
4.        int width = MeasureSpec.getSize(widthMeasureSpec); 
5.        int height = MeasureSpec.getSize(heightMeasureSpec); 
6.        //以最小值为正方形的长 
7.        len = Math.min(width, height); 
8.        //实例化矩形 
9.        oval=new RectF(0,0,len,len); 
10.        //设置测量高度和宽度（必须要调用，不然无效果） 
11.        setMeasuredDimension(len, len); 
12.    }  

画矩形需要确定左上角和右下角的坐标(通过画板可以测试)，通过上面的分析坐标原点就是我们view的左上角，右下角的坐标当然就是len了。

接下来就是初始化起始和经过角度

1. private float startAngle=120; 
2.  
3. private float sweepAngle=300; 

需要搞清楚往下为Y轴正轴，刚好和上学时候学的相反，也就是说90度在下方，-90度在上方

初始化画笔

1. public HuaWeiView(Context context, @Nullable AttributeSet attrs) { 
2.        super(context, attrs); 
3.        paint =new Paint(); 
4.        //设置画笔颜色 
5.        paint.setColor(Color.WHITE); 
6.        //设置画笔抗锯齿 
7.        paint.setAntiAlias(true); 
8.        //让画出的图形是空心的(不填充) 
9.        paint.setStyle(Paint.Style.STROKE); 
10.    }useCenter=false  

到这里真不容易呀，然而发现只画个圆弧没用呀，我要的是刻度线呀，canvas里面又没用给我们提供画刻度线的方法，这个时候就需要我们自己去写一个画刻度线的方法了。

通过观察图片我们可以看出，所有的线都是从圆弧上的点为起点向某个方向画一条直线，那么该如何确定这两个点呢，需要我们做两件事：

移动坐标系

1. @Override 
2.    protected void onDraw(Canvas canvas) { 
3.        super.onDraw(canvas); 
4.        //画圆弧的方法 
5.        canvas.drawArc(oval, startAngle, sweepAngle, useCenter,paint); 
6.        //画刻度线的方法 
7.        drawViewLine(canvas); 
8.    } 
9.  
10.    private void drawViewLine(Canvas canvas) { 
11.        //先保存之前canvas的内容 
12.        canvas.save(); 
13.        //移动canvas(X轴移动距离，Y轴移动距离) 
14.        canvas.translate(radius,radius); 
15.        //操作完成后恢复状态 
16.        canvas.restore(); 
17.    }  

我们自己写了一个绘制刻度线的方法并在onDraw()方法中调用。移动坐标系之前需要保存之前的canvas状态，然后X和Y轴分别移动圆弧半径的距离，如下图：

canvas.translate(radius,radius);方法移动的是坐标系(通过实际效果和查资料所得)

canvas.save()和canvas.restore()要成对出现，就好像流用完要关闭一样。

第一件事情完成后，开始第二件事情，旋转坐标系

只通过移动坐标系，仍然很难确定圆弧点上的坐标，和另外一点的坐标，如果这两个点都在坐标轴上该多好呀，下面实现：

1. private void drawViewLine(Canvas canvas) { 
2.        //先保存之前canvas的内容 
3.        canvas.save(); 
4.        //移动canvas(X轴移动距离，Y轴移动距离) 
5.        canvas.translate(radius,radius); 
6.        //旋转坐标系 
7.        canvas.rotate(30); 
8.        //操作完成后恢复状态 
9.        canvas.restore();    

画刻度线的方法了增加了一个旋转30度的代码，旋转后的坐标系应该怎么样呢;

因为起始点和90度相差30，旋转之后，起始点刚好落在了Y轴上，那么这个点的坐标就很好确定了吧，没错就是(0,radius);如果我们在Y轴上在找一点不就可以画出一条刻度线了吗，那么它的坐标是多少呢?对，应该是(0,radius-y)，因为我们要往内部化刻度线，因此是减去一个值，赶快去试试吧，代码如下：

1. private void drawViewLine(Canvas canvas) { 
2.         //先保存之前canvas的内容 
3.         canvas.save(); 
4.         //移动canvas(X轴移动距离，Y轴移动距离) 
5.         canvas.translate(radius,radius); 
6.         //旋转坐标系 
7.         canvas.rotate(30); 
8.         Paint linePatin=new Paint(); 
9.         //设置画笔颜色 
10.         linePatin.setColor(Color.WHITE); 
11.         //线宽 
12.         linePatin.setStrokeWidth(2); 
13.         //设置画笔抗锯齿 
14.         linePatin.setAntiAlias(true); 
15.         //画一条刻度线 
16.         canvas.drawLine(0,radius,0,radius-40,linePatin); 
17.         //操作完成后恢复状态 
18.         canvas.restore(); 
19.     }  

根据得到的两个点的坐标，画出来一条白线，如图：

当然这些点都是移动后的坐标系在旋转30度得到的，这里画好了一条线，如果画多条呢，还是刚才的思路每次都让它旋转一个小角度然后画条直线不就好了吗，那么旋转多少度呢，比如这里：总共扫过的角度sweepAngle=300;需要100条刻度，那么每次需要旋转的角度rotateAngle=sweepAngle/100，具体代码如下：

1. private void drawViewLine(Canvas canvas) { 
2.         //先保存之前canvas的内容 
3.         canvas.save(); 
4.         //移动canvas(X轴移动距离，Y轴移动距离) 
5.         canvas.translate(radius,radius); 
6.         //旋转坐标系 
7.         canvas.rotate(30); 
8.         Paint linePatin=new Paint(); 
9.         //设置画笔颜色 
10.         linePatin.setColor(Color.WHITE); 
11.         //线宽 
12.         linePatin.setStrokeWidth(2); 
13.         //设置画笔抗锯齿 
14.         linePatin.setAntiAlias(true); 
15.         //确定每次旋转的角度 
16.         float rotateAngle=sweepAngle/99; 
17.         for(int i=0;i<100;i++){ 
18.             //画一条刻度线 
19.             canvas.drawLine(0,radius,0,radius-40,linePatin); 
20.             canvas.rotate(rotateAngle); 
21.         } 
22.  
23.         //操作完成后恢复状态 
24.         canvas.restore(); 
25.     }  

100个刻度，需要101次循环画线(请看你的手表)，画完线就旋转。依次循环，如图

经过这么久的时间总于完成了刻度盘了，接下来就是去确定不同角度显示什么样的颜色，首选我们需要确定要绘制的范围targetAngle:

绘制有色部分

1. private void drawViewLine(Canvas canvas) { 
2.         //先保存之前canvas的内容 
3.         canvas.save(); 
4.         //移动canvas(X轴移动距离，Y轴移动距离) 
5.         canvas.translate(radius,radius); 
6.         //旋转坐标系 
7.         canvas.rotate(30); 
8.         Paint linePatin=new Paint(); 
9.         //设置画笔颜色 
10.         linePatin.setColor(Color.WHITE); 
11.         //线宽 
12.         linePatin.setStrokeWidth(2); 
13.         //设置画笔抗锯齿 
14.         linePatin.setAntiAlias(true); 
15.         //确定每次旋转的角度 
16.         float rotateAngle=sweepAngle/100; 
17.         //绘制有色部分的画笔 
18.         Paint targetLinePatin=new Paint(); 
19.         targetLinePatin.setColor(Color.GREEN); 
20.         targetLinePatin.setStrokeWidth(2); 
21.         targetLinePatin.setAntiAlias(true); 
22.         //记录已经绘制过的有色部分范围 
23.         float hasDraw=0; 
24.         for(int i=0;i<=100;i++){ 
25.             if(hasDraw<=targetAngle&&targetAngle!=0){//需要绘制有色部分的时候 
26.                 //画一条刻度线 
27.                 canvas.drawLine(0,radius,0,radius-40,targetLinePatin); 
28.             }else {//不需要绘制有色部分 
29.                 //画一条刻度线 
30.                 canvas.drawLine(0,radius,0,radius-40,linePatin); 
31.             } 
32.             //累计绘制过的部分 
33.             hasDraw+=rotateAngle; 
34.             //旋转 
35.             canvas.rotate(rotateAngle); 
36.         } 
37.  
38.         //操作完成后恢复状态 
39.         canvas.restore(); 
40.     }  

我们需要不断的去记录绘制过的有效部分，之外的部分画白色。

根据角度的比例，颜色渐变

需要计算出已经绘制过的角度占总角度(300)的比例

1. for(int i=0;i<=100;i++){ 
2.             if(hasDraw<=targetAngle&&targetAngle!=0){//需要绘制有色部分的时候 
3.                 //计算已经绘制的比例 
4.                 float percent=hasDraw/sweepAngle; 
5.                 int red= 255-(int) (255*percent); 
6.                 int green= (int) (255*percent); 
7.                 targetLinePatin.setARGB(255,red,green,0); 
8.                 //画一条刻度线 
9.                 canvas.drawLine(0,radius,0,radius-40,targetLinePatin); 
10.             }else {//不需要绘制有色部分 
11.                 //画一条刻度线 
12.                 canvas.drawLine(0,radius,0,radius-40,linePatin); 
13.             } 
14.             hasDraw+=rotateAngle; 
15.             canvas.rotate(rotateAngle); 
16.         }  

只是在绘制有色部分的时候，利用三元素来实现渐变。所占比例越低红色值越大，反正绿色值越大。

实现动态显示

先想一下它的运动情况，分为前进状态和后退状态，如果正在运动(一次完整的后退和前进没用结束)，就不能开始下次运动，需要两个参数，state和isRunning

1. //判断是否在动 
2.     private boolean isRunning; 
3.     //判断是回退的状态还是前进状态 
4.     private int state = 1; 
5.     public void changeAngle(final float trueAngle) { 
6.         if (isRunning){//如果在动直接返回 
7.             return; 
8.         } 
9.         final Timer timer = new Timer(); 
10.         timer.schedule(new TimerTask() { 
11.             @Override 
12.             public void run() { 
13.                 switch (state) { 
14.                     case 1://后退状态 
15.                     isRunning=true; 
16.                         targetAngle -= 3; 
17.                         if (targetAngle <= 0) {//如果回退到0 
18.                             targetAngle = 0; 
19.                             //改为前进状态 
20.                             state = 2; 
21.                         } 
22.                         break; 
23.                     case 2://前进状态 
24.                         targetAngle += 3; 
25.                         if (targetAngle >= trueAngle) {//如果增加到指定角度 
26.                             targetAngle = trueAngle; 
27.                             //改为后退状态 
28.                             state = 1; 
29.                             isRunning=false; 
30.                             //结束本次运动 
31.                             timer.cancel(); 
32.                         } 
33.                         break; 
34.                     default: 
35.                         break; 
36.                 } 
37.                 //重新绘制（子线程中使用的方法） 
38.                 postInvalidate(); 
39.             } 
40.         }, 500, 30); 
41.     }  

利用时间任务，每个30毫秒去执行一次run方法，每次都重新绘制图片，然后在activity中调用此方法

1. HuaWeiView hwv; 
2.     @Override 
3.     protected void onCreate(Bundle savedInstanceState) { 
4.         super.onCreate(savedInstanceState); 
5.         setContentView(R.layout.activity_main); 
6.         hwv= (HuaWeiView) findViewById(R.id.hwv); 
7.         hwv.setOnClickListener(new View.OnClickListener() { 
8.             @Override 
9.             public void onClick(View v) { 
10.                 //点击事件中，调用动的方法 
11.                 hwv.changeAngle(200); 
12.             } 
13.         }); 
14.  
15.     } 

看到这里了，相信你对坐标系和角度动态变化，以及刻度盘的绘制有了个很好的认识，多多验证会有助于理解。

接下来要实现背景动态渐变

想想咱们的view中哪里用了渐变呢?对，在绘制有色部分的时候，如果我们能将颜色渐变的值不断的传到activity中该多好呀，下面就要用接口传值实现这一功能了：

• 首选在自定义View中声明一个内部接口：

1. private OnAngleColorListener onAngleColorListener; 
2.  
3.    public void setOnAngleColorListener(OnAngleColorListener onAngleColorListener) { 
4.        this.onAngleColorListener = onAngleColorListener; 
5.    } 
6.  
7.    public interface OnAngleColorListener{ 
8.       void colorListener(int red,int green); 
9.    }  

我们在自定义View中声明一个内部接口，并声明一个全局接口对象，提供一个set方法

接口内有个方法用来获取颜色值

接下来就是在合适的地方调用这个方法，那么哪里呢，就是我们绘制颜色刻度时调用：

1. for (int i = 0; i <= 100; i++) { 
2.             if (hasDraw <= targetAngle && targetAngle != 0) {//需要绘制有色部分的时候 
3.                 //计算已经绘制的比例 
4.                 float percent = hasDraw / sweepAngle; 
5.                 int red = 255 - (int) (255 * percent); 
6.                 int green = (int) (255 * percent); 
7.                 //实现接口回调，传递颜色值 
8.                 if (onAngleColorListener!=null){ 
9.                     onAngleColorListener.colorListener(red,green); 
10.                 } 
11.                 targetLinePatin.setARGB(255, red, green, 0); 
12.                 //画一条刻度线 
13.                 canvas.drawLine(0, radius, 0, radius - 40, targetLinePatin); 
14.             } else {//不需要绘制有色部分 
15.                 //画一条刻度线 
16.                 canvas.drawLine(0, radius, 0, radius - 40, linePatin); 
17.             } 

我们在绘制的时候实现了接口回调，接下来去activity中实现接口

1. public class MainActivity extends AppCompatActivity { 
2.  
3.     HuaWeiView hwv; 
4.     LinearLayout ll_parent; 
5.     @Override 
6.     protected void onCreate(Bundle savedInstanceState) { 
7.         super.onCreate(savedInstanceState); 
8.         setContentView(R.layout.activity_main); 
9.         hwv= (HuaWeiView) findViewById(R.id.hwv); 
10.         //实例父布局 
11.         ll_parent= (LinearLayout) findViewById(R.id.ll_parent); 
12.         hwv.setOnClickListener(new View.OnClickListener() { 
13.             @Override 
14.             public void onClick(View v) { 
15.                 //点击事件中，调用动的方法 
16.                 hwv.changeAngle(200); 
17.             } 
18.         }); 
19.         //设置角度颜色变化监听 
20.         hwv.setOnAngleColorListener(new HuaWeiView.OnAngleColorListener() { 
21.             @Override 
22.             public void colorListener(int red, int green) { 
23.                 Color color=new Color(); 
24.                 //通过Color对象将RGB值转为int类型 
25.                 int backColor=color.argb(100,red,green,0); 
26.                 //父布局设置背景 
27.                 ll_parent.setBackgroundColor(backColor); 
28.             } 
29.         }); 
30.  
31.     } 
32. } 

给父布局一个id，然后实例化。给我们的自定义控件设置一个角度颜色变化监听，从而拿到回调中传过来的值，然后借助Color对象将RGB值转为int值，再设置给父布局背景，这里背景稍稍透明一些。效果图：

 

到了这里是不是感觉炫酷了不少呢，其实功能已经实现的差不多了，接下来就是去绘制里面的内容吧

绘制文字

当然不去绘制文字也是可以的，你可以直接在布局中添加textview等。好话不多说，先分析一下绘制的过程吧，在刻度盘的内部有一个小圆，然后这些文字就在小圆内，绘制小圆只需要让它的半径小点就OK了。

1. /** 
2.      * 绘制小圆和文本的方法，小圆颜色同样渐变 
3.      * @param canvas 
4.      */ 
5.     private void drawScoreText(Canvas canvas) { 
6.         //先绘制一个小圆 
7.         Paint smallPaint = new Paint(); 
8.         smallPaint.setARGB(100,red,green,0); 
9.         // 画小圆指定圆心坐标，半径，画笔即可 
10.         int smallRadius=radius-60; 
11.         canvas.drawCircle(radius, radius, radius - 60, smallPaint); 
12.         //绘制文本 
13.         Paint textPaint=new Paint(); 
14.         //设置文本居中对齐 
15.         textPaint.setTextAlign(Paint.Align.CENTER); 
16.         textPaint.setColor(Color.WHITE); 
17.         textPaint.setTextSize(smallRadius/2); 
18.         //score需要通过计算得到 
19.         canvas.drawText(""+score,radius,radius,textPaint); 
20.         //绘制分，在分数的右上方 
21.         textPaint.setTextSize(smallRadius/6); 
22.         canvas.drawText("分",radius+smallRadius/2,radius-smallRadius/4,textPaint); 
23.         //绘制点击优化在分数的下方 
24.         textPaint.setTextSize(smallRadius/6); 
25.         canvas.drawText("点击优化",radius,radius+smallRadius/2,textPaint); 
26.  
27.     }  

这里将之前渐变的red和green提为全局变量，先绘制一个小圆，画笔颜色渐变。然后绘制文字分数score需要通过计算的到

1. //计算得到的分数 
2. score=(int)(targetAngle/sweepAngle*100); 
3. //重新绘制（子线程中使用的方法） 
4. postInvalidate();  

在时间任务中，每次绘制之前计算得到分数，然后在右上方画一个固定值分，再在下方一个固定内容点击优化(这个时候的坐标已经回到最初的模样)

到此为止功能已经写的差不多了，还有一个水波加速球效果，下篇博客中写吧。

本文作者：佚名

来源：51CTO