分享一个android真正实用的游戏框架（来自安卓航班网）

其主要“实用”之处在于：
1.框架整体很小，上手快，做大游戏的公司没多少，做小游戏的个人开发者铺天盖地，相比动则上升到引擎级的庞然大物，小型的框架更加实用，更加考虑大多数开发者的利益。
2.小不等于不完善，之所以剥SDK的游戏示例代码的框架出来，就是学习后发现它对于系统事件的处理比较完善，另外我个人还修正了它对于来电处理等异常事件不完美之处，使其更加完善。
R.layout.main 布局文件

1.    
2.    
3.         xmlns:android="http://schemas.android.com/apk/res/android"
4.         android:orientation="vertical"
5.         android:layout_width="match_parent"
6.         android:layout_height="match_parent">
7.         
8.             android:id="@+id/gameview"
9.             android:layout_width="match_parent"
10.             android:layout_height="match_parent" />
11.         
12.             android:layout_width="match_parent"
13.             android:layout_height="match_parent">
14.             
15.                 android:id="@+id/textview"
16.                 android:layout_width="wrap_content"
17.                 android:layout_height="wrap_content"
18.                 android:layout_centerInParent="true"
19.                 android:gravity="center_horizontal"
20.                 android:textColor="#88ffffff"
21.                 android:textSize="24sp" />
22.         
23.    

复制代码

Activity类

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

复制代码

SurfaceView类

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

复制代码

游戏线程类

1.     package com.mstanford.gameframework;
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;
11.     public class GameThread extends Thread {
13.     // 游戏状态值:ready
14.     public final static int GS_READY = 0;
16.     //游戏线程每执行一次需要睡眠的时间
17.     private final static int DELAY_TIME = 100;
19.     //上下文,方便获取到应用的各项资源,如图片、音乐、字符串等
20.     private Context context;
22.     //与Activity其他View交互用的handler
23.     private Handler handler;
25.     //由SurfaceView提供的SurfaceHolder
26.     private SurfaceHolder surfaceHolder;
28.     //游戏线程运行开关
29.     private boolean running = false;
31.     //游戏状态
32.     private int gameState;
34.     //当前surface/canvas的高度,在surfaceChanged方法中被设置
35.         private int mCanvasHeight = 1;
37.       //当前surface/canvas的宽度,在surfaceChanged方法中被设置
38.         private int mCanvasWidth = 1;
39.       
40.         /**
41.          * 游戏是否暂停
42.          */
43.         private boolean isPaused = false;
45.     public GameThread(SurfaceHolder holder, Context context, Handler handler) {
46.       this.surfaceHolder = holder;
47.       this.context = context;
48.       this.handler = handler;
49.     }
51.     /**
52.       * 设置游戏状态
53.       * @param mode 游戏状态
54.       */
55.     public void setState(int mode) {
56.       synchronized (surfaceHolder) {
57.        setState(mode, null);
58.       }
59.     }
61.     /**
62.       * 设置游戏状态
63.       * @param mode 游戏状态
64.       * @param message 设置游戏状态时的附加文字信息
65.       */
66.     public void setState(int mode, CharSequence message) {
67.       synchronized (surfaceHolder) {
68.        // TODO
69.       }
70.     }
72.     /**
73.       * 暂停游戏
74.       */
75.     public void pause() {
76.       synchronized (surfaceHolder) {
77.        isPaused = true;
78.       }
79.     }
81.     /**
82.       * 恢复运行游戏
83.       */
84.     public void unpause() {
85.       //如果游戏中有时间,别忘记应将其在这里调整到正常
86.       synchronized (surfaceHolder) {
87.        isPaused = false;
88.       }
89.     }
91.     /**
92.       * 当Activity因销毁而被重新创建时,在这里恢复游戏上次运行的数据
93.       * @param saveState Activity传来的保存游戏数据的容器
94.       */
95.     public void restoreState(Bundle saveState) {
96.       //TODO
97.     }
99.     /**
100.       * 在Activity切到后台时保存游戏的数据
101.       * @param outState 保存游戏数据的容器
102.       */
103.     public void saveState(Bundle outState)
104.     {
105.       //TODO
106.     }
108.     /**
109.       * 设置游戏线程运行开关
110.       * @param b 开/关
111.       */
112.     public void setRunning(boolean b) {
113.       running = b;
114.     }
116.     /**
117.       * 处理按下按键的事件
118.       * @param keyCode 按键事件动作值
119.       * @param msg 按键事件对象
120.       * @return 是否处理完
121.       */
122.     public boolean doKeyDown(int keyCode, KeyEvent msg) {
123.       synchronized (surfaceHolder) {
124.        // TODO
125.        return false;
126.       }
127.     }
129.     /**
130.       * 处理弹起按键的事件
131.       * @param keyCode 按键事件动作值
132.       * @param msg 按键事件对象
133.       * @return 是否处理完
134.       */
135.     public boolean doKeyUp(int keyCode, KeyEvent msg) {
136.       synchronized (surfaceHolder) {
137.        // TODO
138.       }
139.       return false;
140.     }
142.     /**
143.       * 设置surface/canvas的宽度和高度
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.     }
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.     }
181.     /**
182.       * 游戏逻辑处理
183.       */
184.     public void logic()
185.     {
186.       Log.v(this.getClass().getName(), "logic");
187.       //TODO
188.     }
190.     /**
191.       * 游戏绘画
192.       */
193.     private void doDraw(Canvas canvas) {
194.       Log.v(this.getClass().getName(), "doDraw");
195.       //TODO
196.     }
198.     /**
199.       * 初始化游戏开始时的参数
200.       */
201.     private void doStart() {
202.       //TODO
203.     }
204.     }

转载于:https://www.cnblogs.com/androidghost/archive/2011/05/06/android2.html