从android游戏框架看其生命周期

书本上, 网路上android游戏框架比比皆是, 但是都未深入其生命周期,

以下是我选取的基于servaceView的android游戏框架,

Activity

1 package air.frame;
2
3 import android.app.Activity;
4 import android.os.Bundle;
5 import android.util.Log;
6 import android.view.Menu;
7 import android.view.MenuItem;
8 import android.widget.TextView;
9
10 public class GameActivity extends Activity {
11 private GameSurfaceView gameSurfaceView;
12 private GameThread gameThread;
13 public static final String TAG = "GameFrame";
14
15 @Override
16 public void onCreate(Bundle savedInstanceState) {
17 super.onCreate(savedInstanceState);
18 setContentView(R.layout.main);
19 gameSurfaceView = (GameSurfaceView) this.findViewById(R.id.gameview);
20 gameThread = gameSurfaceView.getThread();
21 gameSurfaceView.setTextView((TextView) findViewById(R.id.textview));
22
23 Log.d(TAG, "onCreate");
24
25 if (savedInstanceState == null) {
26 // 游戏第一次启动时,初始化游戏状态
27 gameThread.doStart();
28 Log.d(TAG, "SIS is null");
29 } else {
30 // 从其他应用界面切回游戏时,如果Activity重新创建,则恢复上次切出游戏时的各项数据
31 gameThread.restoreState(savedInstanceState);
32 Log.d(TAG, "SIS is not null");
33 }
34 }
35
36 /**
37 * 当Activity被切换到后台时调用,存储Activity重新创建时需要恢复的游戏数据
38 */
39 @Override
40 protected void onSaveInstanceState(Bundle outState) {
41 super.onSaveInstanceState(outState);
42 gameThread.saveState(outState);
43 Log.d(TAG, "SIS called");
44 }
45
46 /**
47 * 当Activity被切换到后台时调用,在这里对游戏做"暂停"的处理
48 */
49 @Override
50 protected void onPause() {
51 super.onPause();
52 // 暂停游戏
53 Log.d(TAG, "onPause");
54 gameSurfaceView.getThread().pause();
55 }
56
57 /**
58 * 当Activity切换到前台时调用
59 */
60 @Override
61 protected void onResume() {
62 super.onResume();
63 // 游戏结束暂停状态,游戏正常进行
64 Log.d(TAG, "onResume");
65 gameSurfaceView.getThread().unpause();
66 }
67
68 /**
69 * 创建游戏菜单
70 */
71 @Override
72 public boolean onCreateOptionsMenu(Menu menu) {
73 // TODO Auto-generated method stub
74 Log.d(TAG, "onCreateOptionsMenu");
75 return super.onCreateOptionsMenu(menu);
76 }
77
78 /**
79 * 定义游戏菜单的点击事件处理
80 */
81 @Override
82 public boolean onOptionsItemSelected(MenuItem item) {
83 // TODO Auto-generated method stub
84 Log.d(TAG, "onOptionsItemSelected");
85 return super.onOptionsItemSelected(item);
86 }
87
88 @Override
89 protected void onRestart() {
90 Log.d(TAG, "onRestart");
91 super.onRestart();
92 }
93
94 @Override
95 protected void onRestoreInstanceState(Bundle savedInstanceState) {
96 Log.d(TAG, "onRestoreInstanceState");
97 super.onRestoreInstanceState(savedInstanceState);
98 }
99
100 @Override
101 protected void onStart() {
102 Log.d(TAG, "onStart");
103 super.onStart();
104 }
105
106 @Override
107 protected void onStop() {
108 Log.d(TAG, "onStop");
109 super.onStop();
110 }
111
112 @Override
113 protected void onDestroy() {
114 super.onDestroy();
115 Log.d(TAG, "onDestroy");
116
117 // 停止游戏
118 gameThread.setRunning(false);
119 boolean retry = true;
120 while (retry) {
121 try {
122 // 阻塞Activity的主线程直到游戏线程执行完
123 gameThread.join();
124 retry = false;
125 } catch (InterruptedException e) {
126 }
127 }
128 }
129 }

surfaceView

package air.frame;
2
3 import android.content.Context;
4 import android.os.Handler;
5 import android.os.Message;
6 import android.util.AttributeSet;
7 import android.util.Log;
8 import android.view.KeyEvent;
9 import android.view.SurfaceHolder;
10 import android.view.SurfaceView;
11 import android.view.SurfaceHolder.Callback;
12 import android.widget.TextView;
13
14 public class GameSurfaceView extends SurfaceView implements Callback {
15 private GameThread gameThread;
16 private TextView textview;
17
18 final String TAG = GameActivity.TAG;
19
20 public GameSurfaceView(Context context, AttributeSet attrs) {
21 super(context, attrs);
22 SurfaceHolder holder = getHolder();
23 holder.addCallback(this);
24 gameThread = new GameThread(holder, context, new Handler() {
25 @Override
26 public void handleMessage(Message m) {
27 textview.setText(m.getData().getString("text"));
28 }
29 });
30 // 设置可获得焦点,确保能捕获到KeyEvent
31 setFocusable(true);
32 }
33
34 /**
35 * 获取一个Activity传来的View协助SurfaceView显示游戏视图,View的具体类型可以根据游戏需要来定
36 */
37 public void setTextView(TextView view) {
38 this.textview = view;
39 }
40
41 public GameThread getThread() {
42 return gameThread;
43 }
44
45 @Override
46 public boolean onKeyDown(int keyCode, KeyEvent event) {
47 return gameThread.doKeyDown(keyCode, event);
48 }
49
50 @Override
51 public boolean onKeyUp(int keyCode, KeyEvent event) {
52 return gameThread.doKeyUp(keyCode, event);
53 }
54
55 /**
56 * 当SurfaceView得到或失去焦点时调用,使游戏暂停/恢复运行,
57 */
58 @Override
59 public void onWindowFocusChanged(boolean hasWindowFocus) {
60 if (!hasWindowFocus) {
61 gameThread.pause();
62 } else {
63 gameThread.unpause();
64 }
65 }
66
67 @Override
68 public void surfaceChanged(SurfaceHolder holder, int format, int width,
69 int height) {
70 Log.d(TAG, "surfaceChanged()");
71 gameThread.setSurfaceSize(width, height);
72 gameThread.setRunning(true);
73 if (gameThread.isAlive()) {
74 Log.v(this.getClass().getName(), "unpause gameThread");
75 gameThread.unpause();
76 } else {
77 Log.v(this.getClass().getName(), "start gameThread");
78 gameThread.start();
79 }
80 }
81
82 @Override
83 public void surfaceCreated(SurfaceHolder holder) {
84 Log.d(TAG, "surfaceCreated()");
85 }
86
87 /**
88 * 为防止surface还会被创建(比如来电)导致gameThread再次启动出现错误,且Activity的onPause方法中已做暂停处理,
89 * 这边不对gameThread做处理
90 *
91 * @param holder
92 */
93 @Override
94 public void surfaceDestroyed(SurfaceHolder holder) {
95 Log.d(TAG, "surfaceDestroyed");
96 }
97 }

游戏控制线程

1 package air.frame;
2
3 import android.content.Context;
4 import android.graphics.Canvas;
5 import android.os.Bundle;
6 import android.os.Handler;
7 import android.util.Log;
8 import android.view.KeyEvent;
9 import android.view.SurfaceHolder;
10
11 publicclass GameThreadextends Thread {
12 final String TAG = GameActivity.TAG;
13
14 // 游戏状态值:ready
15 public final staticint GS_READY = 0;
16 // 游戏线程每执行一次需要睡眠的时间
17 private final staticint DELAY_TIME= 100;
18 // 上下文,方便获取到应用的各项资源,如图片、音乐、字符串等
19 private Context context;
20 // 与Activity其他View交互用的handler
21 private Handler handler;
22 // 由SurfaceView提供的SurfaceHolder
23 private SurfaceHolder surfaceHolder;
24 // 游戏线程运行开关
25 private boolean running = false;
26 // 游戏状态
27 private int gameState;
28 // 当前surface/canvas的高度,在surfaceChanged方法中被设置
29 private int mCanvasHeight = 1;
30 // 当前surface/canvas的宽度,在surfaceChanged方法中被设置
31 private int mCanvasWidth = 1;
32
33 /**
34 * 游戏是否暂停
35 */
36 private boolean isPaused= false;
37
38 public GameThread(SurfaceHolder holder, Context context, Handler handler) {
39 this.surfaceHolder = holder;
40 this.context = context;
41 this.handler = handler;
42 }
43
44 /**
45 * 设置游戏状态
46 *
47 * @param mode 游戏状态
48 */
49 public void setState(int mode) {
50 synchronized (surfaceHolder) {
51 setState(mode,null);
52 }
53 }
54
55 /**
56 * 设置游戏状态
57 *
58 * @param mode 游戏状态
59 * @param message 设置游戏状态时的附加文字信息
60 */
61 public void setState(int mode, CharSequence message) {
62 synchronized (surfaceHolder) {
63 // TODO
64 }
65 }
66
67 /**
68 * 暂停游戏
69 */
70 public void pause() {
71 synchronized (surfaceHolder) {
72 isPaused= true;
73 }
74 }
75
76 /**
77 * 恢复运行游戏
78 */
79 public void unpause() {
80 // 如果游戏中有时间,别忘记应将其在这里调整到正常
81 synchronized (surfaceHolder) {
82 isPaused= false;
83 }
84 }
85
86 /**
87 * 当Activity因销毁而被重新创建时,在这里恢复游戏上次运行的数据
88 *
89 * @param saveState Activity传来的保存游戏数据的容器
90 */
91 public void restoreState(Bundle saveState) {
92 // TODO
93 }
94
95 /**
96 * 在Activity切到后台时保存游戏的数据
97 *
98 * @param outState 保存游戏数据的容器
99 */
100 public void saveState(Bundle outState) {
101 // TODO
102 }
103
104 /**
105 * 设置游戏线程运行开关
106 *
107 * @param b 开/关
108 */
109 public void setRunning(boolean b) {
110 running= b;
111 }
112
113 /**
114 * 处理按下按键的事件
115 *
116 * @param keyCode 按键事件动作值
117 * @param msg 按键事件对象
118 * @return 是否处理完
119 */
120 public boolean doKeyDown(int keyCode, KeyEvent msg) {
121 synchronized (surfaceHolder) {
122 // TODO
123 return false;
124 }
125 }
126
127 /**
128 * 处理弹起按键的事件
129 *
130 * @param keyCode 按键事件动作值
131 * @param msg 按键事件对象
132 * @return 是否处理完
133 */
134 public boolean doKeyUp(int keyCode, KeyEvent msg) {
135 synchronized (surfaceHolder) {
136 // TODO
137 }
138 return false;
139 }
140
141 /**
142 * 设置surface/canvas的宽度和高度
143 *
144 * @param width 由SurfaceHolder传来的宽度
145 * @param height 由SurfaceHolder传来的高度
146 */
147 public void setSurfaceSize(int width,int height) {
148 // synchronized to make sure these all change atomically
149 synchronized (surfaceHolder) {
150 mCanvasWidth= width;
151 mCanvasHeight= height;
152 // 不要忘记每次画布的宽度和高度改变时, 在这里对图片等资源做缩放等相关适配屏幕的处理
153 // TODO
154 }
155 }
156
157 public void run() {
158 while (running) {
159 if (!isPaused) {
160 Canvas c= null;
161 try {
162 c= surfaceHolder.lockCanvas(null);
163 synchronized (surfaceHolder) {
164 doDraw(c);
165 }
166 logic();
167 }finally {
168 if (c != null) {
169 surfaceHolder.unlockCanvasAndPost(c);
170 }
171 }
172 try {
173 Thread.sleep(DELAY_TIME);
174 }catch (InterruptedException e) {
175 e.printStackTrace();
176 }
177 }
178 }
179 }
180
181 /**
182 * 游戏逻辑处理
183 */
184 public void logic() {
185 Log.v(this.getClass().getName(),"logic");
186 // TODO
187 }
188
189 /**
190 * 游戏绘画
191 */
192 private void doDraw(Canvas canvas) {
193 Log.v(this.getClass().getName(),"doDraw");
194 // TODO
195 }
196
197
198 /**
199 * 初始化游戏开始时的参数
200 */
201 public void doStart() {
202 // TODO
203 }
204 }

布局文件

main.xml

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <air.frame.GameSurfaceView
        android:id="@+id/gameview"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent" />
    <RelativeLayout
        android:layout_width="fill_parent"
        android:layout_height="fill_parent">
        <TextView
            android:id="@+id/textview"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:gravity="center_horizontal"
            android:textColor="#88ffffff"
            android:textSize="24sp" />
    </RelativeLayout>
</FrameLayout>

生命周期初步信息

如上所示: surfaceView的生命周期寄托在activity的生命周期之上

附:

activity现场保护:(可以用于实现游戏暂停, 也可以持久化存储现场, 在surfaceCreate里面判断恢复)

http://www.cnblogs.com/wumao/archive/2011/04/25/2026483.html

以下链接是恢复现场的几种方法!

http://www.cnblogs.com/xirihanlin/archive/2009/08/05/1539420.html

除了官方的生命周期图之外, 如下链接对生命周期的见解, 我觉得不错!

http://www.cnblogs.com/kofi1122/archive/2011/04/10/2011772.html

另外, 两个不常用的状态:

onSaveInstanceState: Android calls onSaveInstanceState() before the activity becomes vulnerable to being destroyed by the system, but does not bother calling it when the instance is actually being destroyed by a user action (such as pressing the BACK key) /当某个activity变得“容易”被系统销毁时，该activity的onSaveInstanceState就会被执行，除非该activity是被用户主动销毁的，例如当用户按返回键的时候。

onSaveInstanceState触发的时机

1、当用户按下HOME键时。

这是显而易见的，系统不知道你按下HOME后要运行多少其他的程序，自然也不知道activity A是否会被销毁，故系统会调用onSaveInstanceState，让用户有机会保存某些非永久性的数据。以下几种情况的分析都遵循该原则

2、长按HOME键，选择运行其他的程序时。

3、按下电源按键（关闭屏幕显示）时。

4、从activity A中启动一个新的activity时。

5、屏幕方向切换时，例如从竖屏切换到横屏时。

在屏幕切换之前，系统会销毁activity A，在屏幕切换之后系统又会自动地创建activity A，所以onSaveInstanceState一定会被执行

总而言之，onSaveInstanceState的调用遵循一个重要原则，即当系统“未经你许可”时销毁了你的activity，则onSaveInstanceState会被系统调用，这是系统的责任，因为它必须要提供一个机会让你保存你的数据（当然你不保存那就随便你了）。

onRestoreInstanceState: 需要注意的是，onSaveInstanceState方法和onRestoreInstanceState方法“不一定”是成对的被调用的，onRestoreInstanceState被调用的前提是，activity A“确实”被系统销毁了，而如果仅仅是停留在有这种可能性的情况下，则该方法不会被调用，例如，当正在显示activity A的时候，用户按下HOME键回到主界面，然后用户紧接着又返回到activity A，这种情况下activity A一般不会因为内存的原因被系统销毁，故activity A的onRestoreInstanceState方法不会被执

另外，onRestoreInstanceState的bundle参数也会传递到onCreate方法中，你也可以选择在onCreate方法中做数据还原（如例子所示Line25~Line33）。

http://www.cnblogs.com/HelloHolyWorld/archive/2011/09/19/2181890.html