MySurfaceView
package org.wp.activity;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.Log;
import android.view.KeyEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
/**
* canvas.save() 和 canvas.restore()是两个相互匹配出现的，
* 作用是用来保存画布的状态和取出保存的状态的。
*
* 这里稍微解释一下，
* 当我们对画布进行旋转，缩放，平移等操作的时候其实我们是想对特定的元素进行操作，
* 比如图片，一个矩形等，但是当你用canvas的方法来进行这些操作的时候，
* 其实是对整个画布进行了操作，那么之后在画布上的元素都会受到影响，
* 所以我们在操作之前调用canvas.save()来保存画布当前的状态，
* 当操作之后取出之前保存过的状态，这样就不会对其他的元素进行影响
*
* 代码段1：
* public void draw() {
* Canvas canvas = sfh.lockCanvas();
* canvas.drawColor(Color.BLACK);
* canvas.drawBitmap(bmp1, 0,0,paint);
* canvas.save();
* canvas.scale(1.5f, 1.5f);
* canvas.restore();
* canvas.drawBitmap(bmp2, 0,0,paint);
* sfh.unlockCanvasAndPost(canvas);
* }
*
* 代码段2：
*
* public void draw() {
* Canvas canvas = sfh.lockCanvas();
* canvas.drawColor(Color.BLACK);
* canvas.drawBitmap(bmp1, 0,0,paint);
* canvas.scale(1.5f, 1.5f);
* canvas.drawBitmap(bmp2, 0,0,paint);
* sfh.unlockCanvasAndPost(canvas);
* }
*
* 上面这两个代码片段中我们都假设有两张图片 bmp1和bmp2，并且都画在画布上!
* 那么代码段1和代码段2的不同:
*
* 代码段1中我们进行画布缩放的之前保存了画布状态，
* 做了缩放操作之后又取出之前保存的状态，
* 这样做是为了保证bmp2正常画出来不受到缩放的影响！
*
* 代码段2里，画了bmp1后就执行了缩放操作，并且没有保存状态！
* 紧接着画了bmp2，那么bmp2也会一样受到缩放的影响！！
*
* 所以我们如果单独处理一张图片的时候，而且不想影响其他部分的绘制，那么应该如下来做：
*
* public void draw() {
* Canvas canvas = sfh.lockCanvas();
* canvas.drawColor(Color.BLACK);
* canvas.drawBitmap(bmp1, 0,0,paint);
* canvas.save();
* canvas.scale(1.5f, 1.5f);
* canvas.drawBitmap(bmp2, 0,0,paint);
* canvas.restore();
* sfh.unlockCanvasAndPost(canvas);
* }
*
*
* @author wp
*
*/
public class MySurfaceView extends SurfaceView implements
SurfaceHolder.Callback, Runnable {
private static final String TAG = "MySurfaceView";
private SurfaceHolder sfh;
private Resources res;
private Bitmap bmp;
private Paint p1;
private Paint p2;
private int SH, SW;
private Canvas canvas;
private int bmp_x = 100, bmp_y = 100; // 初始坐标位置
private boolean UP, DOWN, LEFT, RIGHT; // 按键类型标识
private int animation_up[] = { 3, 4, 5 }; // 向上图片位置
private int animation_down[] = { 0, 1, 2 }; // 向下图片位置
private int animation_left[] = { 6, 7, 8 }; // 向左图片位置
private int animation_right[] = { 9, 10, 11 }; // 向右图片位置
private int animation_init[] = animation_down; // 默认人物图片向下
private int frame_count; // 人物对应数组位置
public MySurfaceView(Context context) {
super(context);
this.setKeepScreenOn(true); // 保持屏幕常亮
/*
* 此方法是用来响应按键！如果是自己定义一个继承自View的类,
* 重新实现onKeyDown方法后,只有当该View获得焦点时才会调用onKeyDown方法,
* Actvity中的onKeyDown方法是当所有控件均没有处理该按键事件时,才会调用.
*/
this.setFocusable(true);
sfh = this.getHolder();
sfh.addCallback(this);
res = this.getResources();
bmp = BitmapFactory.decodeResource(res, R.drawable.enemy1);
p1 = new Paint();
p1.setColor(Color.YELLOW);
p1.setAntiAlias(true);
p2 = new Paint();
p2.setColor(Color.RED);
p2.setAntiAlias(true);
}
@Override
public void surfaceCreated(SurfaceHolder holder) {
Log.i(TAG, "surfaceCreated()");
SW = this.getWidth();
SH = this.getHeight();
Log.i(TAG, "SW：" + SW + " SH：" + SH);
new Thread(this).start();
}
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
Log.i(TAG, "surfaceChanged()");
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
Log.i(TAG, "surfaceDestroyed()");
}
@Override
public void run() {
while (true) {
draw();
cycle();
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
}
}
private void draw() {
Log.i(TAG, "draw()");
canvas = sfh.lockCanvas();
/*
* 这里也是对屏幕进行刷屏操作，其实这也只是一种，
* 如果用到drawRGB的方法同样实现，当然也可以用fillRect等来刷屏。
* 在继承view中，因为onDraw方法是系统自动调用的，
* 不像在surfaceview这里这样去在run里面自己去不断调用，
* 在view中我们可以使用invalidate()/postInvalidate()
* 这两种方法实现让系统调用onDraw方法，这里也是和surfaceview中的不同之一！
*/
canvas.drawRect(0, 0, SW, SH, p1);
canvas.save();
canvas.drawText("wp", bmp_x - 1, bmp_y - 10, p2); // 图片上方人物名称
canvas.clipRect(bmp_x, bmp_y, bmp_x + bmp.getWidth() / 13, bmp_y + bmp.getHeight()); // 裁剪图片人物
if (animation_init == animation_up) {
canvas.drawBitmap(bmp, bmp_x - animation_up[frame_count] * (bmp.getWidth() / 13), bmp_y, p1);
} else if (animation_init == animation_down) {
canvas.drawBitmap(bmp, bmp_x - animation_down[frame_count] * (bmp.getWidth() / 13), bmp_y, p1);
} else if (animation_init == animation_left) {
canvas.drawBitmap(bmp, bmp_x - animation_left[frame_count] * (bmp.getWidth() / 13), bmp_y, p1);
} else if (animation_init == animation_right) {
canvas.drawBitmap(bmp, bmp_x - animation_right[frame_count] * (bmp.getWidth() / 13), bmp_y, p1);
}
canvas.restore();
sfh.unlockCanvasAndPost(canvas);
}
private void cycle() {
Log.i(TAG, "cycle()");
if (DOWN) {
bmp_y += 5;
} else if (UP) {
bmp_y -= 5;
} else if (LEFT) {
bmp_x -= 5;
} else if (RIGHT) {
bmp_x += 5;
}
// 按键的行为发生，循环图片位置
if (UP || DOWN || LEFT || RIGHT) {
if (frame_count < 2) {
frame_count++;
} else {
frame_count = 0;
}
}
// 用户松开按键，恢复图片位置
if (UP == false && DOWN == false && LEFT == false && RIGHT == false) {
frame_count = 0;
}
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
if (UP == false) {
animation_init = animation_up;
}
UP = true;
} else if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
if (DOWN == false) {
animation_init = animation_down;
}
DOWN = true;
} else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
if (LEFT == false) {
animation_init = animation_left;
}
LEFT = true;
} else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
if (RIGHT == false) {
animation_init = animation_right;
}
RIGHT = true;
}
return super.onKeyDown(keyCode, event);
}
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
if (UP) {
UP = false;
} else if (DOWN) {
DOWN = false;
} else if (LEFT) {
LEFT = false;
} else if (RIGHT) {
RIGHT = false;
}
return super.onKeyUp(keyCode, event);
}
}
首先创建工程 ThreadDemo 创建Activity
一、Handler
Handler在android里负责发送和处理消息。它的主要用途有：
1）按计划发送消息或执行某个Runnanble(使用POST方法)；
2）从其他线程中发送来的消息放入消息队列中，避免线程冲突（常见于更新UI线程）
默认情况下，Handler接受的是当前线程下的消息循环实例（使用Handler(Looper looper)、Handler(Looper looper, Handler.Callback callback) 可以指定线程），同时一个消息队列可以被当前线程中的多个对象进行分发、处理（在UI线程中，系统已经有一个Activity来处理了，你可以再起若干个 Handler来处理）。在实例化Handler的时候，Looper可以是任意线程的，只要有Handler的指针，任何线程也都可以 sendMessage。Handler对于Message的处理不是并发的。一个Looper 只有处理完一条Message才会读取下一条，所以消息的处理是阻塞形式的（handleMessage()方法里不应该有耗时操作，可以将耗时操作放在 其他线程执行，操作完后发送Message（通过sendMessges方法）,然后由handleMessage()更新UI）。
执行测试后可以发现 setTitle("" +count); 该行代码可以执行 并可以不断改变UI
由于android是单线程模型 所以可见个线程就是运行在UI主线程当中的 通过两次打印的Log也可以看出是同一个线程
也就是说mHandler.post(mRunnable); 执行了run()方法 并没有执行Thread的start()方法开启一个新的线程
所以这种方式不适合比较耗时的操作 会堵塞主线程 UI message队列
另外 mHandler.removeCallbacks(mRunnable); 该行代码如果注释掉会发现即使退出该Acitivity也会继续执行线程的run()
方法 所以这里需要注意
二、 HandlerThread
HandlerThread继承于Thread，所以它本质就是个Thread。与普通Thread的差别就在于，它有个Looper成员变量。这个Looper其实就是对消息队列以及队列处理逻辑的封装，简单说就是 消息队列+消息循环。
当我们需要一个工作者线程，而不是把它当作一次性消耗品，用过即废弃的话，就可以使用它。
注这里需要handlerThread.start();先启动线程 才能 handlerThread.getLooper() 获取当前线程的Looper
通过HandlerThread的run方法可以发现
这里调用了Looper.prepare(); 初始化了Looper
通过执行可以发现 setTitle("" +count); 在这里调用会出现异常
还有通过打印的日志
都可以发现 这里启动的是一个新线程 虽然不能直接操作UI 但可以通过Message发送消息来进行操作
这样可以处理一些比较耗时操作
三、AsyncQueryHandler
这个类继承了Handler 实现了 ContentProvider处理相关的一些操作的异步方式
与其说这个类提供给我们一个处理ContentProvider的方法 我觉得这更给我们提供了一个处理异步的方案
若我们不用AsyncQueryHandler，直接在UI 线程调用ContentResolve去操作数据库比如查询，若你的数据库的数据很少还好，若很多，就会出现ANR了。一般解决ANR,就是开 thread去解决。让UI线程知道何时查询完毕，可以更新UI将查询的结果表现出来
首先分析一下 AsyncQueryHandler 这个类
他的基本策略如下：
1. 当你实例化一个AsyncQueryHandler类时（包括其子类...），它会单件构造一个线程WorkerHandler，这个线程里面会构建一个消息循环。
2. 获得该消息循环的指针，用它做参数实例化另一个Handler类，该类为内部类。至此，就有了两个线程，各自有一个Handler来处理消息。
3. 当调用onXXX的时候，在XXX函数内部会将请求封装成一个内部的参数类，将其作为消息的参数，将此消息发送至另一个线程。
4. 在该线程的Handler中，接受该消息，并分析传入的参数，用初始化时传入的ContentResolver进行XXX操作，并返回Cursor或其他返回值。
5. 构造一个消息，将上述返回值以及其他相关内容绑定在该消息上，发送回主线程。
6. 主线程默认的AsyncQueryHandler类的handleMessage方法（可自定义，但由于都是内部类，基本没有意义...）会分析该消息，并转发给对应的onXXXComplete方法。
7. 用户重写的onXXXComplete方法开始工作。
通过上面的HandlerThread的用法可以看到我们启动新线程进行操作的代码是很冗余很繁琐的 把更多对Handler的操作暴露出来了
这样是很不利于维护和复用的（虽然有时候没有必要 这不显得比较NB嘛）
那通过这个类我们只需要实例化的时候传入ContentResolver 并实现自己的回调方法onXXXComplete 最后调用你需要的操作就可以
确实代码简洁了 想知道怎么回事去反编译android的代码去吧
那我觉得如果有什么非ContentProvider操作，却需要异步多线程执行的话，模拟一套，是个不错的选择
这里我做了个demo
比较耗时的操作可以在WorkerHandler的 方法中进行实现
那调用的方法
Activity，Service属于主线程，在主线程中才能更新UI，如toast等。其他线程中不能直接使用，这时可以使用Handler来处理，Handler可以在Activity和Service中。
关于在非UI线程中进行UI操作会出现问题： Can't create handler inside thread that has not called Looper.prepare()
这时有两种方式来解决：
（一）在该非UI线程中创建消息队列（因为创建的工作线程默认是没有消息循环和消息队列的），Looper.prepare();.....;Looper.loop();
newThread() {
public void run() {
Looper.prepare(); //创建消息队列
todo();
Looper.loop();//进入消息循环
}}.start();
（二）运用Handler机制：
package com.simon;
import android.app.Activity;
import android.os.Bundle;
import android.os.Message;
import android.util.Log;
import android.os.Handler;
public class MyHandler extends Activity {
static final String TAG = "Handler";
Handler h = new Handler(){
public void handleMessage (Message msg)
{
switch(msg.what)
{
case HANDLER_TEST:
Log.d(TAG, "The handler thread id = " + Thread.currentThread().getId() + "\n");
break;
}
}
};
static final int HANDLER_TEST = 1;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.d(TAG, "The main thread id = " + Thread.currentThread().getId() + "\n");
new myThread().start();
setContentView(R.layout.main);
}
class myThread extends Thread
{
public void run()
{
Message msg = new Message();
msg.what = HANDLER_TEST;
h.sendMessage(msg);
Log.d(TAG, "The worker thread id = " + Thread.currentThread().getId() + "\n");
}
}
}
***********************************************分割线************************************************
熟悉Windows编程的朋友可能知道Windows程序是消息驱动的，并且有全局的消息循环系统。而Android应用程序也是消息驱动的，按道理来说也应该提供消息循环机制。实际上谷歌参考了Windows的消息循环机制，也在Android系统中实现了消息循环机制。Android通过Looper、Handler来实现消息循环机制，Android消息循环是针对线程的（每个线程都可以有自己的消息队列和消息循环）。本文深入介绍一下Android消息处理系统原理。
Android系统中Looper负责管理线程的消息队列和消息循环，具体实现请参考Looper的源码。 可以通过Loop.myLooper()得到当前线程的Looper对象，通过Loop.getMainLooper()可以获得当前进程的主线程的Looper对象。
前面提到Android系统的消息队列和消息循环都是针对具体线程的，一个线程可以存在（当然也可以不存在）一个消息队列和一个消息循环（Looper），特定线程的消息只能分发给本线程，不能进行跨线程，跨进程通讯。但是创建的工作线程默认是没有消息循环和消息队列的，如果想让该线程具有消息队列和消息循环，需要在线程中首先调用Looper.prepare()来创建消息队列，然后调用Looper.loop()进入消息循环。如下例所示：
class LooperThread extends Thread { public Handler mHandler;
public void run() { Looper.prepare();
mHandler = new Handler() { public void handleMessage(Message msg) { // process incoming messages here } };
Looper.loop(); } }这样你的线程就具有了消息处理机制了，在Handler中进行消息处理。
这样你的线程就具有了消息处理机制了，在Handler中进行消息处理。
Activity是一个UI线程，运行于主线程中，Android系统在启动的时候会为Activity创建一个消息队列和消息循环（Looper）。详细实现请参考ActivityThread.java文件。
Handler的作用是把消息加入特定的（Looper）消息队列中，并分发和处理该消息队列中的消息。构造Handler的时候可以指定一个Looper对象，如果不指定则利用当前线程的Looper创建。详细实现请参考Looper的源码。
Activity、Looper、Handler的关系如下图所示：
一个Activity中可以创建多个工作线程或者其他的组件，如果这些线程或者组件把他们的消息放入Activity的主线程消息队列，那么该消息就会在主线程中处理了。因为主线程一般负责界面的更新操作，并且Android系统中的weget不是线程安全的，所以这种方式可以很好的实现Android界面更新。在Android系统中这种方式有着广泛的运用。
那么另外一个线程怎样把消息放入主线程的消息队列呢？答案是通过Handle对象，只要Handler对象以主线程的Looper创建，那么调用Handler的sendMessage等接口，将会把消息放入队列都将是放入主线程的消息队列。并且将会在Handler主线程中调用该handler的handleMessage接口来处理消息。
这里面涉及到线程同步问题，请先参考如下例子来理解Handler对象的线程模型：
1、首先创建MyHandler工程。
2、在MyHandler.java中加入如下的代码：
package com.simon;
import android.app.Activity; import android.os.Bundle; import android.os.Message; import android.util.Log; import android.os.Handler;
public class MyHandler extends Activity { static final String TAG = "Handler"; Handler h = new Handler(){ public void handleMessage (Message msg) { switch(msg.what) { case HANDLER_TEST: Log.d(TAG, "The handler thread id = " + Thread.currentThread().getId() + "\n"); break; } } };
static final int HANDLER_TEST = 1; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Log.d(TAG, "The main thread id = " + Thread.currentThread().getId() + "\n");
new myThread().start(); setContentView(R.layout.main); }
class myThread extends Thread { public void run() { Message msg = new Message(); msg.what = HANDLER_TEST; h.sendMessage(msg); Log.d(TAG, "The worker thread id = " + Thread.currentThread().getId() + "\n"); } } }
在这个例子中我们主要是打印，这种处理机制各个模块的所处的线程情况。如下是我的机器运行结果：
09-10 23:40:51.478: DEBUG/Handler(302): The main thread id = 1 09-10 23:40:51.569: DEBUG/Handler(302): The worker thread id = 8 09-10 23:40:52.128: DEBUG/Handler(302): The handler thread id = 1
我们可以看出消息处理是在主线程中处理的，在消息处理函数中可以安全的调用主线程中的任何资源，包括刷新界面。工作线程和主线程运行在不同的线程中，所以必须要注意这两个线程间的竞争关系。
上例中，你可能注意到在工作线程中访问了主线程handler对象，并在调用handler的对象向消息队列加入了一个消息。这个过程中会不会出现消息队列数据不一致问题呢？答案是handler对象不会出问题，因为handler对象管理的Looper对象是线程安全的，不管是加入消息到消息队列和从队列读出消息都是有同步对象保护的，具体请参考Looper.java文件。上例中没有修改handler对象，所以handler对象不可能会出现数据不一致的问题。
通过上面的分析，我们可以得出如下结论：
1、如果通过工作线程刷新界面，推荐使用handler对象来实现。
2、注意工作线程和主线程之间的竞争关系。推荐handler对象在主线程中构造完成（并且启动工作线程之后不要再修改之，否则会出现数据不一致），然后在工作线程中可以放心的调用发送消息SendMessage等接口。
3、除了2所述的hanlder对象之外的任何主线程的成员变量如果在工作线程中调用，仔细考虑线程同步问题。如果有必要需要加入同步对象保护该变量。
4、handler对象的handleMessage接口将会在主线程中调用。在这个函数可以放心的调用主线程中任何变量和函数，进而完成更新UI的任务。
5、Android很多API也利用Handler这种线程特性，作为一种回调函数的变种，来通知调用者。这样Android框架就可以在其线程中将消息发送到调用者的线程消息队列之中，不用担心线程同步的问题。
深入理解Android消息处理机制对于应用程序开发非常重要，也可以让你对线程同步有更加深刻的认识。以上是最近Simon学习Android消息处理机制的一点儿总结，如有错误之处请不吝指教。