Question

android自带时钟应用的这个效果是怎么做的

Answer 1

次的小程序是一个Android小时钟。主要用到知识有Handler，Thread,Canvas,Path.

     Handler:主要是用来接收子线程发送的数据，并用此数据配合主线程更新UI。Handler运行在主线程，通过message来与子线程传递数据。我只用到了sendMessage（Message）方法。

    Thread在Java中刚学过了，所以用起来还是比较简单的，就不多说了。

Canvas类就是表示一块画布，你可以在上面画你想画的东西。当然，你还可以设置画布的属性，如画布的颜色/尺寸等。

    这东西我是第一次用，所以查了下canvas提供的方法。在时钟小程序中，我主要用的是rotate(),旋转画布。

Path也是第一次用到。moveTo和lineTo是用来设置开始的基点和最后的基点。我用path来画时钟的分针、秒针和时针。

    关于android画图方面的知识是第一次接触到，（其实本来是想从网上下载一个时钟表盘的图片直接拿来用的），但是由于找不到合适的指针的图片，所以还是用画的了，虽然这样就会显得很朴素了，但是基本功能还是实现了。截图如下：

上面例子来源于android学习手册，360手机助手中可以下载，里面有108个android例子，源码文档都可在里面看，下面是截图

package clock.zlp;  
import android.annotation.SuppressLint;  
import android.app.Activity;  
import android.os.Bundle;  
import android.os.Handler;  
import android.os.Message;  
import android.view.View;  
import android.widget.LinearLayout;  
import android.widget.TextView;  
  
public class clock extends Activity {  
    private LinearLayout myClock;  
    private draw drawClock;  
    protected static final int MESSAGE = 123;  
    public Handler handler;  
    private Thread mthread;  
    TextView tv = null;  
  
    @SuppressLint("HandlerLeak")  
    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        View view = this.getWindow().getDecorView(); // getDecorView  
        view.setBackgroundDrawable(this.getResources().getDrawable(  
                R.drawable.abc));  
        setContentView(R.layout.main);  
  
        myClock = (LinearLayout) findViewById(R.id.clock);  
        drawClock = new draw(this);  
        myClock.addView(drawClock);  
  
        handler = new Handler() {  
            public void handleMessage(Message mess) {  
                if (mess.what == clock.MESSAGE) {  
                    myClock.removeView(drawClock);  
                    drawClock = new draw(clock.this);  
                    myClock.addView(drawClock);  
                }  
                super.handleMessage(mess);  
            }  
        };  
  
        mthread = new myThread();  
        mthread.start();  
    }  
  
    class myThread extends Thread {  
        public void run() {  
            super.run();  
            while (Thread.interrupted() == false) {  
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                Message m = new Message();  
                m.what = clock.MESSAGE;  
                clock.this.handler.sendMessage(m);  
            }  
        }  
    }  
}

package clock.zlp;

  
import java.util.Calendar;  
  
import android.annotation.SuppressLint;  
import android.content.Context;  
import android.graphics.Canvas;  
import android.graphics.Color;  
import android.graphics.Paint;  
import android.graphics.Path;  
import android.view.View;  
  
@SuppressLint({ "ResourceAsColor", "DrawAllocation" })  
public class draw extends View {  
    public draw(Context context) {  
        super(context);  
    }  
  
    public void onDraw(Canvas canvas) {  
        Paint paint = new Paint();  
        paint.setAntiAlias(true);  
        paint.setColor(Color.BLACK);  
        paint.setStyle(Paint.Style.STROKE); // 空心的画笔  
        paint.setStrokeWidth(3); // 设置paint的外框宽度  
  
        drawDial(canvas, paint); // 绘制表盘  
        drawHand(canvas, paint); // 绘制时针、分针、秒针  
  
    }  
  
    public void drawHand(Canvas canvas, Paint paint) {  
        int x = 310;  
        int y = x;  
        int hour;  
        int minute;  
        int second;  
  
        final Calendar calendar = Calendar.getInstance();  
        hour = calendar.get(Calendar.HOUR);  
        minute = calendar.get(Calendar.MINUTE);  
        second = calendar.get(Calendar.SECOND);  
  
        float h = ((hour + (float) minute / 60) / 12) * 360;  
        float m = ((minute + (float) second / 60) / 60) * 360;  
        float s = ((float) second / 60) * 360;  
  
        // 时针  
        paint.setColor(Color.WHITE);  
        canvas.save(); // 线锁定画布  
        canvas.rotate(h, x / 2, y / 2); // 旋转画布  
        Path path1 = new Path();  
        path1.moveTo(x / 2, y / 2); // 开始的基点  
        path1.lineTo(x / 2, y / 4); // 最后的基点  
        canvas.drawPath(path1, paint);  
        canvas.restore();  
  
        // 分针  
        paint.setColor(R.color.MediumSlateBlue);  
        canvas.save();  
        canvas.rotate(m, x / 2, y / 2); // 旋转画布  
        Path path2 = new Path();  
        path2.moveTo(x / 2, y / 2); // 开始的基点  
        path2.lineTo(x / 2, y / 6); // 最后的基点  
        canvas.drawPath(path2, paint);  
        canvas.restore();  
  
        // 秒针  
        paint.setColor(Color.BLUE);  
        canvas.save();  
        canvas.rotate(s, x / 2, y / 2); // 旋转画布  
        Path path3 = new Path();  
        path3.moveTo(x / 2, y / 2); // 开始的基点  
        path3.lineTo(x / 2, y / 9); // 最后的基点  
        canvas.drawPath(path3, paint);  
        canvas.restore();  
  
    }  
  
    public void drawDial(Canvas canvas, Paint paint) {  
        int x = 310;  
        int y = x;  
        paint.setColor(Color.WHITE);  
  
        canvas.drawCircle(x / 2, y / 2, x / 2 - 2, paint);  
        canvas.drawCircle(x / 2, y / 2, x / 40, paint);  
  
        Path path9 = new Path(); // 接下来的是，画时针的刻度  
        path9.moveTo(2, y / 2);  
        path9.lineTo(y / 18, y / 2);  
        canvas.drawPath(path9, paint);  
  
        Path path12 = new Path();  
        path12.moveTo(x / 2, 2);  
        path12.lineTo(x / 2, y / 18);  
        canvas.drawPath(path12, paint);  
  
        Path path3 = new Path();  
        path3.moveTo(x - 2, y / 2);  
        path3.lineTo(x - x / 18, y / 2);  
        canvas.drawPath(path3, paint);  
  
        Path path6 = new Path();  
        path6.moveTo(x / 2, y - 2);  
        path6.lineTo(x / 2, y - y / 18);  
        canvas.drawPath(path6, paint);  
  
        canvas.save();  
        canvas.rotate(32, x / 2, y / 2);  
        Path path10 = new Path();  
        path10.moveTo(2, y / 2);  
        path10.lineTo(x / 32, y / 2);  
        canvas.drawPath(path10, paint);  
  
        Path path1 = new Path();  
        path1.moveTo(x / 2, 2);  
        path1.lineTo(x / 2, y / 32);  
        canvas.drawPath(path1, paint);  
  
        Path path4 = new Path();  
        path4.moveTo(x - 1, y / 2);  
        path4.lineTo(x - x / 32, y / 2);  
        canvas.drawPath(path4, paint);  
  
        Path path7 = new Path();  
        path7.moveTo(x / 2, y - 2);  
        path7.lineTo(x / 2, y - y / 32);  
        canvas.drawPath(path7, paint);  
        canvas.restore();  
  
        canvas.save();  
        canvas.rotate(60, x / 2, y / 2);  
        Path path11 = new Path();  
        path11.moveTo(2, y / 2);  
        path11.lineTo(x / 32, y / 2);  
        canvas.drawPath(path11, paint);  
  
        Path path2 = new Path();  
        path2.moveTo(x / 2, 2);  
        path2.lineTo(x / 2, y / 32);  
        canvas.drawPath(path2, paint);  
  
        Path path5 = new Path();  
        path5.moveTo(x - 2, y / 2);  
        path5.lineTo(x - x / 32, y / 2);  
        canvas.drawPath(path5, paint);  
  
        Path path8 = new Path();  
        path8.moveTo(x / 2, y - 2);  
        path8.lineTo(x / 2, y - y / 32);  
        canvas.drawPath(path8, paint);  
        canvas.restore();  
    }  
}