本站文章均为 李华明Himi 原创,转载务必在明显处注明：

转载自【黑米GameDev街区】 原文链接: http://www.himigame.com/android-game/298.html

    各位童鞋请你们注意：surfaceview中确实有 onDraw这个方法，但是surfaceview不会自己去调用！！！

    而我代码中的ondraw 也好 draw 也好，都是我自己定义的一个方法。。。放在线程中不断调用的，一定要注意！!

其实上一篇分析surfaceview的文章就是一个简单的游戏框架了，当然这里再强调一下，简单的游戏框架，所以不要高手们不要乱喷~

这个Demo是给群里一童鞋写的一个对图片操作以及按键处理，游戏简单框架的一个demo，这里放出给大家分享~

1. package com.himi;
2. import android.content.Context;
3. import android.content.res.Resources;
4. import android.graphics.Bitmap;
5. import android.graphics.BitmapFactory;
6. import android.graphics.Canvas;
7. import android.graphics.Color;
8. import android.graphics.Paint;
9. import android.util.Log;
10. import android.view.KeyEvent;
11. import android.view.SurfaceHolder;
12. import android.view.SurfaceView;
13. import android.view.SurfaceHolder.Callback;
14. public class MySurfaceView extends SurfaceView implements Callback, Runnable {
15. private Thread th = new Thread(this);
16. private SurfaceHolder sfh;
17. private int SH, SW;
18. private Canvas canvas;
19. private Paint p;
20. private Paint p2;
21. private Resources res;
22. private Bitmap bmp;
23. private int bmp_x = 100, bmp_y = 100;
24. private boolean UP, DOWN, LEFT, RIGHT;
25. private int animation_up[] = { 3, 4, 5 };
26. private int animation_down[] = { 0, 1, 2 };
27. private int animation_left[] = { 6, 7, 8 };
28. private int animation_right[] = { 9, 10, 11 };
29. private int animation_init[] = animation_down;
30. private int frame_count;
31. public MySurfaceView(Context context) {
32. super(context);
33. this.setKeepScreenOn(true);
34. res = this.getResources();
35. bmp = BitmapFactory.decodeResource(res, R.drawable.enemy1);
36. sfh = this.getHolder();
37. sfh.addCallback(this);
38. p = new Paint();
39. p.setColor(Color.YELLOW);
40. p2 = new Paint();
41. p2.setColor(Color.RED);
42. p.setAntiAlias(true);
43. setFocusable(true);  //备注1
44. }
45. public void surfaceCreated(SurfaceHolder holder) {
46. SH = this.getHeight();
47. SW = this.getWidth();
48. th.start();
49. }
50. public void draw() {
51. canvas = sfh.lockCanvas();
52. canvas.drawRect(0, 0, SW, SH, p);   //备注2
53. canvas.save();   //备注3
54. canvas.drawText("Himi", bmp_x-2, bmp_y-10, p2);
55. canvas.clipRect(bmp_x, bmp_y, bmp_x + bmp.getWidth() / 13, bmp_y+bmp.getHeight());
56. if (animation_init == animation_up) {
57. canvas.drawBitmap(bmp, bmp_x - animation_up[frame_count] * (bmp.getWidth() / 13), bmp_y, p);
58. } else if (animation_init == animation_down) {
59. canvas.drawBitmap(bmp, bmp_x - animation_down[frame_count] * (bmp.getWidth() / 13), bmp_y, p);
60. } else if (animation_init == animation_left) {
61. canvas.drawBitmap(bmp, bmp_x - animation_left[frame_count] * (bmp.getWidth() / 13), bmp_y, p);
62. } else if (animation_init == animation_right) {
63. canvas.drawBitmap(bmp, bmp_x - animation_right[frame_count] * (bmp.getWidth() / 13), bmp_y, p);
64. }
65. canvas.restore();  //备注3
66. sfh.unlockCanvasAndPost(canvas);
67. }
68. public void cycle() {
69. if (DOWN) {
70. bmp_y += 5;
71. } else if (UP) {
72. bmp_y -= 5;
73. } else if (LEFT) {
74. bmp_x -= 5;
75. } else if (RIGHT) {
76. bmp_x += 5;
77. }
78. if (DOWN || UP || LEFT || RIGHT) {
79. if (frame_count < 2) {
80. frame_count++;
81. } else {
82. frame_count = 0;
83. }
84. }
85. if (DOWN == false && UP == false && LEFT == false && RIGHT == false) {
86. frame_count = 0;
87. }
88. }
89. @Override
90. public boolean onKeyDown(int key, KeyEvent event) {
91. if (key == KeyEvent.KEYCODE_DPAD_UP) {
92. if (UP == false) {
93. animation_init = animation_up;
94. }
95. UP = true;
96. } else if (key == KeyEvent.KEYCODE_DPAD_DOWN) {
97. if (DOWN == false) {
98. animation_init = animation_down;
99. }
100. DOWN = true;
101. } else if (key == KeyEvent.KEYCODE_DPAD_LEFT) {
102. if (LEFT == false) {
103. animation_init = animation_left;
104. }
105. LEFT = true;
106. } else if (key == KeyEvent.KEYCODE_DPAD_RIGHT) {
107. if (RIGHT == false) {
108. animation_init = animation_right;
109. }
110. RIGHT = true;
111. }
112. return super.onKeyDown(key, event);
113. }
114. /* (non-Javadoc)
115. * @see android.view.View#onKeyUp(int, android.view.KeyEvent)
116. */
117. @Override
118. public boolean onKeyUp(int keyCode, KeyEvent event) {
119. if (DOWN) {
120. DOWN = false;
121. } else if (UP) {
122. UP = false;
123. } else if (LEFT) {
124. LEFT = false;
125. } else if (RIGHT) {
126. RIGHT = false;
127. }
128. return super.onKeyUp(keyCode, event);
129. }
130. @Override
131. public void run() {
132. // TODO Auto-generated method stub
133. while (true) {
134. draw();
135. cycle();
136. try {
137. Thread.sleep(100);
138. } catch (Exception ex) {
139. }
140. }
141. }
142. @Override
143. public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
144. // TODO Auto-generated method stub
145. }
146. @Override
147. public void surfaceDestroyed(SurfaceHolder holder) {
148. // TODO Auto-generated method stub
149. }
150. }

备注1

此方法是用来响应按键！如果是自己定义一个继承自View的类,重新实现onKeyDown方法后,只有当该View获得焦点时才会调用onKeyDown方法,Actvity中的onKeyDown方法是当所有控件均没有处理该按键事件时,才会调用.

备注2

这里也是对屏幕进行刷屏操作，其实这也只是一种，之前文章里我也用到drawRGB的方法同样实现，当然也可以用fillRect等来刷屏。

那么这里我想说下，在继承view中，因为onDraw方法是系统自动调用的，不像在surfaceview这里这样去在run里面自己去不断调用，在view中我们可以抵用 invalidate()/postInvalidate() 这两种方法实现让系统调用onDraw方法，这里也是和surfaceview中的不同之一！

备注3

这里canvas.save();和canvas.restore();是两个相互匹配出现的，作用是用来保存画布的状态和取出保存的状态的。这里稍微解释一下，当我们对画布进行旋转，缩放，平移等操作的时候其实我们是想对特定的元素进行操作，比如图片，一个矩形等，但是当你用canvas的方法来进行这些操作的时候，其实是对整个画布进行了操作，那么之后在画布上的元素都会受到影响，所以我们在操作之前调用canvas.save()来保存画布当前的状态，当操作之后取出之前保存过的状态，这样就不会对其他的元素进行影响。

对于 canvas.save();和canvas.restore(); 还有不少童鞋不懂，OK、我再补充点：

代码段1：

1. public void draw() {
2. Canvas canvas = sfh.lockCanvas();
3. canvas.drawColor(Color.BLACK);
4. canvas.drawBitmap(bmp1, 0,0,paint);
5. canvas.save();
6. canvas.scale(1.5f, 1.5f);
7. canvas.restore();
8. canvas.drawBitmap(bmp2, 0,0,paint);
9. sfh.unlockCanvasAndPost(canvas);
10. }

代码段2：

1. public void draw() {
2. Canvas canvas = sfh.lockCanvas();
3. canvas.drawColor(Color.BLACK);
4. canvas.drawBitmap(bmp1, 0,0,paint);
5. canvas.scale(1.5f, 1.5f);
6. canvas.drawBitmap(bmp2, 0,0,paint);
7. sfh.unlockCanvasAndPost(canvas);
8. }

上面这两个代码片段中我们都假设有两张图片 bmp1和bmp2，并且都画在画布上!

那么代码段1和代码段2的不同:

    代码段1中我们进行画布缩放的之前保存了画布状态，做了缩放操作之后又取出之前保存的状态，这样做是为了保证bmp2正常画出来不受到缩放的影响！

    代码段2里，画了bmp1后就执行了缩放操作，并且没有保存状态！紧接着画了bmp2，那么bmp2也会一样受到缩放的影响！！

所以我们如果单独处理一张图片的时候，而且不想影响其他部分的绘制，那么应该如下来做：

1. public void draw() {
2. Canvas canvas = sfh.lockCanvas();
3. canvas.drawColor(Color.BLACK);
4. canvas.drawBitmap(bmp1, 0,0,paint);
5. canvas.save();
6. canvas.scale(1.5f, 1.5f);
7. canvas.drawBitmap(bmp2, 0,0,paint);
8. canvas.restore();
9. sfh.unlockCanvasAndPost(canvas);
10. }

(推荐大家订阅本博客，因为咱的更新速度可是很快的~娃哈哈)

×××地址： http://www.himigame.com/android-game/298.html