Android自定义一个属于自己的时间钟表

1、概述

本文主要讲解的是如何自定义一个时间钟表，通过简单的练习可以简单学习Android当中自定义view的一些常用绘图技巧，优化android绘图操作。言归正传，首先看下我们需要实现的效果：

当我们看到这个效果的时候脑子里应该有一定的思路了，我们应该把它分解成以下几个步骤：

1、仪表盘（圆）

2、刻度线（长 中 短）

3、刻度值（1-12）

4、指针（时  分  秒）

5、移动指针，计算指针位置

现在我们已经很清楚自己的思路了，那么我们一个一个来。

第一步：1、自定义View的属性，首先在res/values/  下建立一个attrs.xml ， 在里面定义我们的属性和声明我们的整个样式。

[html]  view plain  copy

1. <span style="font-size:14px;">    <declare-styleable name="ClockView">  
2.   
3.         <attr name="mRadius" format="dimension"/>  
4.         <attr name="mCircleColor" format="color"/>  
5.         <attr name="mCircleWidth" format="dimension"/>  
6.         <attr name="mTextSize" format="dimension"/>  
7.         <attr name="mTextColor" format="color"/>  
8.         <attr name="mBigScaleColor" format="color"/>  
9.         <attr name="mMiddlecaleColor" format="color"/>  
10.         <attr name="mSmallScaleColor" format="color"/>  
11.         <attr name="mHourHandColor" format="color"/>  
12.         <attr name="mMinuteHandColor" format="color"/>  
13.         <attr name="mSecondHandColor" format="color"/>  
14.         <attr name="mHourHandWidth" format="dimension"/>  
15.         <attr name="mMinuteHandWidth" format="dimension"/>  
16.         <attr name="mSecondHandWidth" format="dimension"/>  
17.   
18.     </declare-styleable></span>  

我们定义了钟表的半径，背景颜色 ，刻度值（大，中，小）的颜色及指针（时分秒）的颜色和宽度。

然后自定义一个class类 为ClockView，在MainActivity的布局中引用：

[html]  view plain  copy

1. <span style="font-size:14px;">  <com.dalong.customviewstudy.view.ClockView  
2.       app:mSecondHandColor="@color/colorAccent"  
3.       app:mCircleColor="@android:color/white"  
4.       app:mBigScaleColor="@android:color/black"  
5.       app:mMiddlecaleColor="@android:color/black"  
6.       app:mSmallScaleColor="@color/colorAccent"  
7.       app:mHourHandColor="@android:color/black"  
8.       app:mMinuteHandColor="@android:color/black"  
9.       app:mTextColor="@android:color/black"  
10.       app:mHourHandWidth="13dp"  
11.       app:mSecondHandWidth="5dp"  
12.       app:mMinuteHandWidth="8dp"  
13.       app:mTextSize="16sp"  
14.       android:layout_centerInParent="true"  
15.       android:layout_width="match_parent"  
16.       android:layout_height="match_parent" /></span>  

2、在自定义View的构造方法中，获得我们的自定义的样式

[java]  view plain  copy

1. <span style="font-size:14px;"> //文字画笔对象  
2.     private  Paint mTextPaint;  
3.   
4.     //圆，指针，刻度画笔  
5.     private  Paint mPaint;  
6.   
7.     //半径  
8.     public float mRadius;  
9.   
10.     //外圆的颜色  
11.     public int mCircleColor;  
12.   
13.     // 外圆的宽度  
14.     public float mCircleWidth;  
15.   
16.     //文字的大小  
17.     public float mTextSize;  
18.   
19.     //文字的颜色  
20.     public int mTextColor;  
21.   
22.     //大刻度颜色  
23.     public int mBigScaleColor;  
24.   
25.     //中刻度  
26.     public int mMiddlecaleColor;  
27.   
28.     //小刻度颜色  
29.     public int mSmallScaleColor;  
30.   
31.     //时针颜色  
32.     public int mHourHandColor;  
33.   
34.     //分针颜色  
35.     public int mMinuteHandColor;  
36.   
37.     //秒针颜色  
38.     public int mSecondHandColor;  
39.   
40.     //时针宽度  
41.     public float mHourHandWidth;  
42.   
43.     //分针宽度  
44.     public float mMinuteHandWidth;  
45.   
46.     //秒针宽度  
47.     public float mSecondHandWidth;  
48.   
49.     //控件宽度  
50.     public int mWidth;  
51.   
52.     //控件高度  
53.     public int mHeght;  
54.   
55.     public ClockView(Context context) {  
56.         this(context,null);  
57.     }  
58.   
59.     public ClockView(Context context, AttributeSet attrs) {  
60.         this(context, attrs,0);  
61.     }  
62.   
63.     public ClockView(Context context, AttributeSet attrs, int defStyleAttr) {  
64.         super(context, attrs, defStyleAttr);  
65.   
66.         TypedArray typedArray=context.obtainStyledAttributes(attrs, R.styleable.ClockView);  
67.         mRadius=typedArray.getDimension(R.styleable.ClockView_mRadius,400);  
68.         mCircleColor=typedArray.getColor(R.styleable.ClockView_mCircleColor, Color.WHITE);  
69.         mCircleWidth=typedArray.getDimension(R.styleable.ClockView_mCircleWidth,20);  
70.         mTextSize=typedArray.getDimension(R.styleable.ClockView_mCircleWidth,40);  
71.         mTextColor=typedArray.getColor(R.styleable.ClockView_mTextColor,Color.DKGRAY);  
72.         mBigScaleColor=typedArray.getColor(R.styleable.ClockView_mBigScaleColor,Color.BLACK);  
73.         mSmallScaleColor=typedArray.getColor(R.styleable.ClockView_mSmallScaleColor,Color.RED);  
74.         mMiddlecaleColor=typedArray.getColor(R.styleable.ClockView_mMiddlecaleColor,Color.BLACK);  
75.         mHourHandColor=typedArray.getColor(R.styleable.ClockView_mHourHandColor,Color.BLACK);  
76.         mMinuteHandColor=typedArray.getColor(R.styleable.ClockView_mMinuteHandColor,Color.BLACK);  
77.         mSecondHandColor=typedArray.getColor(R.styleable.ClockView_mSecondHandColor,Color.BLACK);  
78.         mHourHandWidth=typedArray.getDimension(R.styleable.ClockView_mHourHandWidth,20);  
79.         mMinuteHandWidth=typedArray.getDimension(R.styleable.ClockView_mMinuteHandWidth,10);  
80.         mSecondHandWidth=typedArray.getDimension(R.styleable.ClockView_mSecondHandWidth,5);  
81.   
82.         mPaint=new Paint();  
83.         mPaint.setAntiAlias(true);  
84.         mPaint.setStyle(Paint.Style.STROKE);  
85.   
86.         mTextPaint=new Paint();  
87.         mTextPaint.setAntiAlias(true);  
88.         mTextPaint.setStyle(Paint.Style.STROKE);  
89.         mTextPaint.setTextSize(mTextSize);  
90.         mTextPaint.setColor(mTextColor);  
91.   
92.     }  
93. </span>  

3、我们重写onDraw，onMesure调用系统提供的：

onMeure方法

[java]  view plain  copy

1. <span style="font-size:14px;">  @Override  
2.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
3.         setMeasuredDimension(measureSize(widthMeasureSpec),measureSize(heightMeasureSpec));  
4.     }  
5.   
6.     private int measureSize(int mMeasureSpec) {  
7.         int result;  
8.         int mode=MeasureSpec.getMode(mMeasureSpec);  
9.         int size=MeasureSpec.getSize(mMeasureSpec);  
10.         if(mode==MeasureSpec.EXACTLY){  
11.             result=size;  
12.         }else{  
13.             result=400;  
14.             if(mode==MeasureSpec.AT_MOST){  
15.                 result=Math.min(result,size);  
16.             }  
17.         }  
18.         return  result;  
19.     }</span>  

onDraw方法

[java]  view plain  copy

1. <span style="font-size:14px;"> @Override  
2.     protected void onDraw(Canvas canvas) {  
3.         super.onDraw(canvas);  
4.         //设置宽高、半径  
5.         mWidth=getMeasuredWidth()-getPaddingLeft()-getPaddingRight();  
6.         mHeght=getMeasuredHeight()-getPaddingBottom()-getPaddingTop();  
7.         mRadius=Math.min(mWidth/2,mHeght/2);  
8.         //首先绘制圆  
9.         drawCircle(canvas);  
10.         //绘制刻度  
11.         drawScale(canvas);  
12.         //绘制指针  
13.         drawPointer(canvas);  
14.         //发送消息刷新ui  
15.         handler.sendEmptyMessageDelayed(START_CLOCK,1000);  
16.     }  
17. </span>  

其中最核心的代码就是这三个方法：

[java]  view plain  copy

1. <span style="font-size:14px;">       //首先绘制圆  
2.         drawCircle(canvas);  
3.         //绘制刻度  
4.         drawScale(canvas);  
5.         //绘制指针  
6.         drawPointer(canvas);</span>  

首先讲第一个方法：

[java]  view plain  copy

1. <span style="font-size:14px;"> /** 
2.      * 画圆 
3.      * @param canvas 
4.      */  
5.     private void drawCircle(Canvas canvas) {  
6.         mPaint.setStrokeWidth(mCircleWidth);  
7.         mPaint.setStyle(Paint.Style.FILL);  
8.         mPaint.setColor(mCircleColor);  
9.         canvas.drawCircle(mWidth/2,mHeght/2,mRadius,mPaint);  
10.     }</span>  

这个方法其实很简单给我们的画笔设置我们自定义的样式之后取中心为圆心，以我们设定的半径画圆，这里设置的是Paint.Style.FILL一个实心的。也可以设置一个空心的。看下我们执行这个方法后的效果：

第二方法：

[java]  view plain  copy

1. <span style="font-size:14px;"> /** 
2.      * 刻度和文字 
3.      * @param canvas 
4.      */  
5.     private void drawScale(Canvas canvas) {  
6.   
7.         for (int i=0;i<60;i++){  
8.             //设置大刻度  
9.             if(i==0||i==15||i==30||i==45){  
10.                 mPaint.setStrokeWidth(6);  
11.                 mPaint.setColor(mBigScaleColor);  
12.                 canvas.drawLine(mWidth/2,mHeght/2-mWidth/2+mCircleWidth/2,  
13.                         mWidth/2,mHeght/2-mWidth/2+mCircleWidth/2+60,mPaint);  
14.                 String scaleTv=String.valueOf(i==0?12:i/5);  
15.                 canvas.drawText(scaleTv,mWidth/2-mTextPaint.measureText(scaleTv)/2,  
16.                         mHeght/2-mWidth/2+mCircleWidth/2+95,mTextPaint);  
17.             }else if (i==5||i==10||i==20||i==25||i==35||i==40||i==50||i==55)  
18.             //设置中刻度  
19.             {  
20.                 mPaint.setStrokeWidth(4);  
21.                 mPaint.setColor(mMiddlecaleColor);  
22.                 canvas.drawLine(mWidth/2,mHeght/2-mWidth/2+mCircleWidth/2,  
23.                         mWidth/2,mHeght/2-mWidth/2+mCircleWidth/2+40,mPaint);  
24.                 String scaleTv=String.valueOf(i/5);  
25.                 canvas.drawText(scaleTv,mWidth/2-mTextPaint.measureText(scaleTv)/2,  
26.                         mHeght/2-mWidth/2+mCircleWidth/2+75,mTextPaint);  
27.   
28.             }else  
29.             //设置小刻度  
30.             {  
31.                 mPaint.setColor(mSmallScaleColor);  
32.                 mPaint.setStrokeWidth(2);  
33.                 canvas.drawLine(mWidth/2,mHeght/2-mWidth/2+mCircleWidth/2,  
34.                         mWidth/2,mHeght/2-mWidth/2+mCircleWidth+30,mPaint);  
35.             }  
36.             canvas.rotate(6,mWidth/2,mHeght/2);  
37.         }  
38.     }</span>  

这个方法代码看起来也没有什么主要是把一个圆分成60份，因为我们钟表上是有60个刻度，其中设置了4个大刻度分别为0，15，30，45.分别对应的钟表中12点  3点  6点和9点，如果这个地方你有什么疑惑的吧你可以看看你的手表或者钟表就明白了，同时里面也设置了8个中等刻度分别为5，10，20，25，35，40，50，55为中刻度，其实对应的就是1，2，4，5，7，8，10，11点。这里主要是自己觉得这样分明好看而已，如果没有强迫症的你可以直接设置都是大刻度就可以了。其他的都为小刻度，根据自己在attr设置的颜色和尺寸分别设置画笔paint来绘制就可以了。看下我们的效果变成了这样子：

[java]  view plain  copy

1.   

第三个方法就是绘制指针：

[java]  view plain  copy

1. <span style="font-size:14px;"> /** 
2.      * 绘制指针 
3.      * @param canvas 
4.      */  
5.     private void drawPointer(Canvas canvas) {  
6.         Calendar mCalendar=Calendar.getInstance();  
7.         //获取当前小时数  
8.         int hours = mCalendar.get(Calendar.HOUR);  
9.         //获取当前分钟数  
10.         int minutes = mCalendar.get(Calendar.MINUTE);  
11.         //获取当前秒数  
12.         int seconds=mCalendar.get(Calendar.SECOND);  
13.   
14.         mPaint.setStrokeCap(Paint.Cap.ROUND);  
15.         //绘制时针  
16.         canvas.save();  
17.         mPaint.setColor(mHourHandColor);  
18.         mPaint.setStrokeWidth(mHourHandWidth);  
19.         //这里计算时针需要旋转的角度 实现原理是计算出一共多少分钟除以60计算出真实的小时数（带有小数，为了更加准确计算度数），已知12小时是360度，现在求出了实际小时数比例求出角度  
20.         Float hoursAngle = (hours * 60 + minutes) / 60f / 12f  * 360;  
21.         canvas.rotate(hoursAngle, mWidth / 2, mHeght / 2);  
22.         canvas.drawLine(mWidth / 2, mHeght / 2 - mWidth/2f*0.5f, mWidth / 2, mHeght / 2 +  mWidth/2f*0.15f, mPaint);  
23.         canvas.restore();  
24.   
25.   
26.         //绘制分针  
27.         canvas.save();  
28.         mPaint.setColor(mMinuteHandColor);  
29.         mPaint.setStrokeWidth(mMinuteHandWidth);  
30.         //这里计算分针需要旋转的角度  60分钟360度，求出实际分钟数所占的度数  
31.         Float minutesAngle = (minutes*60+seconds) / 60f/ 60f * 360;  
32.         canvas.rotate(minutesAngle, mWidth / 2, mHeght / 2);  
33.         canvas.drawLine(mWidth / 2, mHeght / 2 -  mWidth/2f*0.7f, mWidth / 2, mHeght / 2 +  mWidth/2f*0.15f, mPaint);  
34.         canvas.restore();  
35.   
36.         //绘制中间的圆圈  
37.         canvas.save();  
38.         mPaint.setColor(mSecondHandColor);  
39.         mPaint.setStrokeWidth(mSecondHandWidth);  
40.         mPaint.setStyle(Paint.Style.FILL);  
41.         canvas.drawCircle(mWidth/2,mHeght/2,20,mPaint);  
42.         canvas.restore();  
43.   
44.   
45.         //绘制秒针  
46.         canvas.save();  
47.         mPaint.setColor(mSecondHandColor);  
48.         mPaint.setStrokeWidth(mSecondHandWidth);  
49.         mPaint.setStyle(Paint.Style.STROKE);  
50.         //这里计算秒针需要旋转的角度  60秒360度，求出实际秒数所占的度数  
51.         Float secondAngle = seconds/60f*360;  
52.         canvas.rotate(secondAngle, mWidth / 2, mHeght / 2);  
53.         canvas.drawLine(mWidth / 2, mHeght / 2 -  mWidth/2f*0.8f, mWidth / 2, mHeght / 2 +  mWidth/2f*0.2f, mPaint);  
54.         canvas.restore();  
55.   
56.   
57.     }</span>  

其实这个方法我注释已经写的很详细了，首先我们需要获取到当前的时间，这个大家都是经常写的没啥问题。主要就是如何设定时分秒指针的位置才是关键。这里我使用一个很巧妙的方法，让绘制变得简单了些。

先看下绘制时针：

[java]  view plain  copy

1. <span style="font-size:14px;">  //绘制时针  
2.         canvas.save();  
3.         mPaint.setColor(mHourHandColor);  
4.         mPaint.setStrokeWidth(mHourHandWidth);  
5.         //这里计算时针需要旋转的角度 实现原理是计算出一共多少分钟除以60计算出真实的小时数（带有小数，为了更加准确计算度数），已知12小时是360度，现在求出了实际小时数比例求出角度  
6.         Float hoursAngle = (hours * 60 + minutes) / 60f / 12f  * 360;  
7.         canvas.rotate(hoursAngle, mWidth / 2, mHeght / 2);  
8.         canvas.drawLine(mWidth / 2, mHeght / 2 - mWidth/2f*0.5f, mWidth / 2, mHeght / 2 +  mWidth/2f*0.15f, mPaint);  
9.         canvas.restore();</span>  

前面三行代码就不详细说了，Canvas.save方法作用就是将之前所有已经绘制的图片保存起来。为后续操作在新的图层上操作。和photoshop有点一个意思。大家都知道当我们获取到当前小时数了以后我们就应该直接把时针指到对应的时数上吗？肯定不是吧，比如是3点半时针是指到3与4之间的位置对吧。所以我们这里需要获取到当前的分钟数再加上小时数才是真实的当前小时数（这里其实秒针也需要计算的，但是这里忽略不计了，如果你比我还强迫症的话可以加上）。当我们知道当前实际的小时数的时候，就很简单了，因为我们知道一圈360度平均分了12小时，这个别告诉我不知道啊，要是这个常识都不知道，你去面壁吧，所以只要360/12*真实的小时数就是需要旋转的角度。这么想是不是很简单了。计算出角度以后先吧canvas.rotate旋转这个角度在绘制一个直线就ok了，哈哈哈，是不是so esey，其他分针和秒针一样的道理，这里就不多说了，看代码直接能看懂的。

[java]  view plain  copy

1.   

[java]  view plain  copy

1. <span style="font-size:14px;">  
2.         //绘制分针  
3.         canvas.save();  
4.         mPaint.setColor(mMinuteHandColor);  
5.         mPaint.setStrokeWidth(mMinuteHandWidth);  
6.         //这里计算分针需要旋转的角度  60分钟360度，求出实际分钟数所占的度数  
7.         Float minutesAngle = (minutes*60+seconds) / 60f/ 60f * 360;  
8.         canvas.rotate(minutesAngle, mWidth / 2, mHeght / 2);  
9.         canvas.drawLine(mWidth / 2, mHeght / 2 -  mWidth/2f*0.7f, mWidth / 2, mHeght / 2 +  mWidth/2f*0.15f, mPaint);  
10.         canvas.restore();  
11.   
12.         //绘制中间的圆圈  
13.         canvas.save();  
14.         mPaint.setColor(mSecondHandColor);  
15.         mPaint.setStrokeWidth(mSecondHandWidth);  
16.         mPaint.setStyle(Paint.Style.FILL);  
17.         canvas.drawCircle(mWidth/2,mHeght/2,20,mPaint);  
18.         canvas.restore();  
19.   
20.   
21.         //绘制秒针  
22.         canvas.save();  
23.         mPaint.setColor(mSecondHandColor);  
24.         mPaint.setStrokeWidth(mSecondHandWidth);  
25.         mPaint.setStyle(Paint.Style.STROKE);  
26.         //这里计算秒针需要旋转的角度  60秒360度，求出实际秒数所占的度数  
27.         Float secondAngle = seconds/60f*360;  
28.         canvas.rotate(secondAngle, mWidth / 2, mHeght / 2);  
29.         canvas.drawLine(mWidth / 2, mHeght / 2 -  mWidth/2f*0.8f, mWidth / 2, mHeght / 2 +  mWidth/2f*0.2f, mPaint);  
30.         canvas.restore();</span>  

其中有个绘制中间的圆圈是我的强迫症所致，觉得中间加个圆圈好看点。执行这个方法后我们的效果就成这样了：

哈哈下面就剩下最后一步了，就是让指针动起来，没错就是动起来，其实大家也在意了我们绘制指针的时候是在方法里直接获取了当前时间设置指针的位置的，所以说只要我们搞个定时器一秒刷新下ui就大功告成了，这里就搞个hander发个空消息。

[java]  view plain  copy

1. private Handler handler=new Handler(){  
2.     @Override  
3.     public void handleMessage(Message msg) {  
4.         super.handleMessage(msg);  
5.         switch (msg.what){  
6.             case START_CLOCK:  
7.                 //更新时分秒  
8.                 invalidate();  
9.                 //每隔1秒更新一次  
10.                 handler.sendEmptyMessageDelayed(START_CLOCK,1000);  
11.                 break;  
12.         }  
13.   
14.     }  
15. };  

就成了下面的效果了：