Service是安卓系统提供的四种组件之一，功能与activity类似，只不过没有activity 的使用频率高。顾名思义Service就是运行在后台的一种服务程序一般很少与用户交互，没有可视化界面。

定义一个service非常简单，只要继承就可以了，实现其中的那些方法就可以了。service必须在AndroidManifest.xml配置文件中定义

intent-filter制定如何访问该service

onBind(Intent intent)：是必须实现的一个方法返回接口

onCreate():当service第一次被创建有系统调用

onStart(Intent intent ,int startid):当通过startservice()方法启动service是该方法被调用

onDestory():当service不再使用，系统调用该方法

创建一个service代码

Java代码
public classs Myservice extends Service

}

欢迎访问我的博客进行交流

线程的方法比较多，常用的有：

start()；

run()；

sleep()；

stop()；

destroy()；

join();

suspend()；

resume()；

yield()；
wait()；
notify()；

线程启动一定要使用start方法,线程操作使用run方法，线程休眠使用sleep方法，线程停止使用stop,线程销毁使用destroy方法,线程同步使用JOIN方法，前面三种最常用，一般来说这三种就可以满足大部分线程使用需求，run结束时线程自动死亡，stop,destroy虽然也能停止线程，但不推荐使用，,前者会产生异常，后者是强制终止，不会释放锁，一般会在RUN里设置一个状态信号来等其自动结束，这里使用volatile boolean bThreadRun。后面是暂停，继续，挂起，由于会产生死锁问题，很少使用。大部分情况会使用wait和notify替代；

这里我使用一个线程来计算变量并更新窗口标题。主要代码如下：使用eclipse创建一个项目。为Activity添加onStart，onPause, onStop等方法，Activity是我们最常使用的一个类，也是android的核心类，为应用程序管理并显示一个屏幕，开发的人不应该对其陌生。Activity活动主要的方法有，onCreate，onStart，onStop，onPause，onResume， onRestart，onDestroy，onRestoreInstanceState，onSaveInstanceState，一般的执行顺序是，onCreate，onStart，onResume，当窗口不是最顶层时，执行onPause，onstop,为顶层时，执行onRestart，onResume，一直循环，直到onDestroy.如果保存窗口，重载onSaveInstanceState，并在进入时重载onRestoreInstanceState。这里我在Activity的方法onStart里创建线程：

01.MyThread myThread = new MyThread();
02. myThread.start();

在下面添加MyThread的实现代码：

01.public class MyThread extends Thread {
02. // 声明字符串变量
03. public MyThread() {
04. }
05.
06. @Override
07. public void start() {
08. super.start();
09. }
10.
11. // 线程的主要工作方法
12. @Override
13. public void run() {
14. while (true) {
15. try {
16. sleep(5000);
17. if (c > ((1 << 31) - 1)) {
18. c = 0;
19. } else {
20. c++;
21. }
22. Message message = new Message();
23. message.what = 1;
24. mHandler.sendMessage(message);
25. } catch (InterruptedException ex) {
26. }
27. }
28. }
29.
30. }

实现updatetitle方法：

01.public void updateTitle() {
02. setTitle("test thread " + c);
03. }

这里没有使用updatetitle直接更新窗口，而是使用handler,这是因为直接使用是不安全的，会造成线程重启等问题。Android 引进了Handler 这个特殊的类，用它作为Runnable和Activity交互的桥梁，所以我们只能在run方法中发送Message,而在Handler里，通过不同的Message执行不同的任务。为程序添加handler；

01.private Handler mHandler = new Handler() {
02. public void handleMessage(Message msg) {
03. switch (msg.what) {
04. case 1:
05. updateTitle();
06. break;
07. }
08. };
09. };

最后完整的代码如下，使用线程处理数据，并把数据显示在窗口上：

01.package com.test;
02.
03.import android.app.Activity;
04.import android.os.Bundle;
05.import java.lang.Thread;
06.import android.os.Message;
07.import android.os.Handler;
08.import android.graphics.Color;
09.
10.public class TestThreadActivity extends Activity {
11. int c = Color.BLUE;
12. MyThread myThread;
13. volatile boolean bThreadRun = false;
14.
15. /** Called when the activity is first created. */
16. @Override
17. public void onCreate(Bundle savedInstanceState) {
18. super.onCreate(savedInstanceState);
19. setContentView(R.layout.main);
20. }
21.
22. @Override
23. protected void onRestoreInstanceState(android.os.Bundle savedInstanceState) {
24. super.onRestoreInstanceState(savedInstanceState);
25. }
26.
27. @Override
28. protected void onSaveInstanceState(android.os.Bundle outState) {
29. super.onSaveInstanceState(outState);
30. }
31.
32. @Override
33. protected void onStart() {
34. super.onStart();
35. myThread = new MyThread();
36. myThread.start();
37. bThreadRun = true;
38. }
39.
40. @Override
41. protected void onRestart() {
42. super.onRestart();
43. }
44.
45. @Override
46. protected void onResume() {
47. super.onResume();
48. }
49.
50. @Override
51. protected void onPause() {
52. super.onPause();
53. bThreadRun = false;
54. // myThread.stop();
55. }
56.
57. @Override
58. protected void onStop() {
59. super.onStop();
60. onPause();
61. }
62.
63. @Override
64. protected void onDestroy() {
65. super.onDestroy();
66. // myThread.destroy();
67. }
68.
69. private Handler mHandler = new Handler() {
70. public void handleMessage(Message msg) {
71. switch (msg.what) {
72. case 1:
73. updateTitle();
74. break;
75. }
76. };
77. };
78.
79. public void updateTitle() {
80. setTitle("test thread " + c);
81. setTitleColor(c);
82. }
83.
84. public class MyThread extends Thread {
85. // 声明字符串变量
86. public MyThread() {
87. }
88.
89. @Override
90. public void start() {
91. super.start();
92. }
93.
94. // 线程的主要工作方法
95. @Override
96. public void run() {
97. while (bThreadRun) {
98. try {
99. sleep(100);
100. if (c > ((1 << 16) - 1)) {
101. c = 0;
102. } else {
103. c += 100;
104. }
105. Message message = new Message();
106. message.what = 1;
107. mHandler.sendMessage(message);
108. } catch (InterruptedException ex) {
109. }
110. }
111. }
112.
113. }
114.
115.}

线程还有另外一种常用的方法是编写Runnable接口，这里对代码做一些修改，使用线程实现对主窗口重绘，全部代码如下：

01.package com.test;
02.
03.import android.app.Activity;
04.import android.content.Context;
05.import android.os.Bundle;
06.import java.lang.Thread;
07.import android.view.View;
08.import android.graphics.Canvas;
09.import android.graphics.Color;
10.import android.graphics.Paint;
11.import android.graphics.Paint.Style;
12.import android.graphics.Rect;
13.
14.public class TestThreadActivity extends Activity {
15. int c = Color.BLUE;
16. MyThread myThread;
17. volatile boolean bThreadRun = false;
18. MyView mv;
19.
20. /** Called when the activity is first created. */
21. @Override
22. public void onCreate(Bundle savedInstanceState) {
23. super.onCreate(savedInstanceState);
24. // setContentView(R.layout.main);
25. mv = new MyView(this);
26. setContentView(mv);
27. }
28.
29. public class MyView extends View {
30. MyView(Context context) {
31. super(context);
32. }
33.
34. @Override
35. protected void onDraw(Canvas canvas) {
36. // TODO Auto-generated method stub
37. super.onDraw(canvas);
38.
39. // 首先定义一个paint
40. Paint paint = new Paint();
41.
42. // 绘制矩形区域-实心矩形
43. // 设置颜色
44. paint.setColor(c);
45. // 设置样式-填充
46. paint.setStyle(Style.FILL);
47. // 绘制一个矩形
48. canvas.drawRect(new Rect(0, 0, getWidth(), getHeight()), paint);
49. }
50.
51. }
52.
53. @Override
54. protected void onRestoreInstanceState(android.os.Bundle savedInstanceState) {
55. super.onRestoreInstanceState(savedInstanceState);
56. }
57.
58. @Override
59. protected void onSaveInstanceState(android.os.Bundle outState) {
60. super.onSaveInstanceState(outState);
61. }
62.
63. @Override
64. protected void onStart() {
65. super.onStart();
66. //myThread = new MyThread();
67. //myThread.start();
68. new Thread (new MyThread()).start();
69. bThreadRun = true;
70. }
71.
72. @Override
73. protected void onRestart() {
74. super.onRestart();
75. }
76.
77. @Override
78. protected void onResume() {
79. super.onResume();
80. }
81.
82. @Override
83. protected void onPause() {
84. super.onPause();
85. bThreadRun = false;
86. // myThread.stop();
87. }
88.
89. @Override
90. protected void onStop() {
91. super.onStop();
92. onPause();
93. }
94.
95. @Override
96. protected void onDestroy() {
97. super.onDestroy();
98. // myThread.destroy();
99. }
100.
101. public class MyThread implements Runnable{
102. // 线程的主要工作方法
103. @Override
104. public void run() {
105. while (bThreadRun) {
106. try {
107. Thread.sleep(500);
108. if (c > ((1 << 31) - 1)) {
109. c = 0;
110. } else {
111. c += 100;
112. }
113. mv.postInvalidate();
114. } catch(InterruptedException e){
115. }
116. }
117. }
118.
119. }
120.
121.}

1、 Mobile Alert
月黑风高独自走夜路时身后突然窜出一个黑影？荒郊野地里突然胸口一紧心脏不舒服？世事难料，人们总会碰到各种突发情况。这时候最重要的是保持冷静，其次才是用各种方式求救或者自救，比如拨打110或者120，通知你的亲人或好友，大声呼救。或者，你可以掏出手机点下这个神奇的红色按钮。

一家名为Avanquest Mobile Technologies的公司设计了这样一款为突发紧急事件服务的移动应用，打开这款应用，屏幕上会出现一个大大的红色按钮，点击它，软件开始倒数读秒，归零时，应用会启动一系列由用户设定的紧急措施。比如自动拨打当地的急救热线，通过GPS获取用户位置然后将其发送给指定的亲朋好友。对了，这款应用还会让手机发出刺耳的警报声，省的你求救把嗓子喊哑了。

市场上还有一些类似的紧急服务类应用，但是提供的服务不如Avanquest Mobile Technologies全面。值得一提的是，这家公司的盈利模式也不太一样。这款应用并不直接面向消费者，而是卖给便携设备的平台运营商，他们可以将这项应用集成到自己的服务中去，比如保险公司、旅行社。

2、 Pocket（原 read it later）

上网浏览，看见有意思的网页，但是又没有时间或者现在不想看怎么办？添加到收藏夹？不行，里面的收藏已经够多的了。从"历史"里面访问？太麻烦了吧！那还能怎么办？让Read It Later来帮你。碰到喜欢的网页，点一下下图所示的"以后再看"图标，这个网页就被放到Read it later的阅读列表中： 关掉浏览器。随时随地打开手机 Read it later 客户端，直接从列表里面选择，你牵挂着的网页就打开了。目前该程序已经支持很多和平台，Android，iOS。

但是随着用户量的增多，发现很多用户并非read it later, 而是保存在线视频留着“watch it later”，于是，"稍后阅读"工具Read it Later 最近迎来了华丽的变身，宣布正式更名为Pocket，同时发布新版应用Pocket并将整个服务免费。

相比之前黄黑主色调的"稳重"Read it Later，粉白双色搭配的Pocket显得素雅精致。Read It Later重新设计了应用的用户界面和操作方式，尝试打造新一个轻量、干净又富于美感的稍后阅读工具。在Pocket中，图片和视频内容的稍后看功能得到加强，用户不必再保存包含图片或视频内容的网址到阅读列表，专门的图片和视频保存项将为用户代劳这项工作。这项重要更新也是Read it Later上存储内容变化趋势的直接反映。据Read it Later之前发布的数据，YouTube已经成为其第一内容来源，越来越多的用户喜欢稍后看视频。内容类型扩展后，稍后阅读工具的搜索和标签功能就显得更加重要了。Pocket对原有的阅读条目组织方式进行了改进，并加强了内容的编辑和搜索功能。

需要注意的是，从Read it Later升级到Pocket的方式将有少许变化。如果你是Read it Later的付费用户，Pocket的更新将自动推送并安装；如果你是Read it Later的免费用户，则需要重新下载应用。因为，Pocket和原Read it Later是两个完全独立的应用。当然，原有的Read it Later帐户不会受到应用升级的影响，上面保存的内容会直接同步到新应用Pocket中。

Read it Later创立于2007年，用户数超过450万，支持的设备覆盖iPhone, iPad, Android和Kindle Fire。新应用Pocket的下载地址：Android | iOS

参考来源：36氪， 巴士数码

1、JDK、AndroidSDK、Eclipse以及相关插件的安装。

2、Android常用开发工具的使用方法介绍

3、第一个Android应用程序Hello World

2.1 开发环境搭建

Android应用程序程序框架是基于Java的，因此，我们首先需要Java的环境，也就是JDK，然后是开发Java的IDE（集成开发工具），我们选择Eclipse，这也是众多Android开发者所常用的开发工具。有了JDK和Eclipse，我们可以使用Eclipse来编写Java代码，并通过JDK来执行Java应用程序了。但是我们需要开发Android，还需要Android SDK，Android SDK可以用来模拟Android终端的运行环境，让我们在个人电脑上执行Android应用程序。一般来说，我们也不需要直接操作Android SDK，而是通过Google提供的一个Eclipse插件ADT(AndroidDevelopment Tools)来间接跟Android SDK打交道，我们只要告诉ADT我们Android SDK在本机上的存放目录即可。

2.1.1 JDK配置

1、开发Android需要JDK1.5以上，最好使用1.6版本，不要使用最新的1.7版本，JDK不是越新越好，SDK的开发人员也不太可能针对最新的JDK立刻进行兼容性测试和推出新的版本，因此尽量使用官方建议使用的版本，在这里，我们使用1.6。下载地址:http://www.oracle.com/technetwork/java/javasebusiness/downloads/java-archive-downloads-javase6-419409.html

注意下载“Java SE Development Kit 6u**”中的任意一个SDK即可，下面的包含“Runtime Environment ”字样的链接是Java的运行环境，不过因为SDK都已经包含了Runtime Environment，因此你可以不需要下载他们。
如果Oracle的Java页面有更新，注意一点，进入主页之后，找寻“Previous Releases”，然后进去找“JavaSE 6”下载链接。

2、安装和配置JDK。下载之后双击安装包安装，结束之后。在桌面“我的电脑”图标上右键点击“属性”，在其“高级”标签下面找到“环境变量”，打开之后，在“系统变量”中的“Path”下添加你所安装的JDK路径的bin目录，比如默认安装在C盘，一般为“C:\Program Files\Java\jdk1.6.0_18\bin”，可能由于jdk版本不同，“jdk1.6.0_18”字段也相应不同。

配置好Path路径之后，你可以在“开始菜单”下的“运行”里键入“cmd”，打开命令，然后使用它来检查我们的安装是否完好。先键入“java”后回车，如果正常显示，结果会呈现“Usage: java [-options] class [args...]”等字样。再键入“javac”后回车，如果正常显示，结果会呈现“用法：javac ”等字样。如果键入“java -version”，则会出现与版本相关的讯息。当以上讯息显示正常，则表示我们现在可以使用“Javac”命令来编译我们的代码,可以使用“Java”命令来运行我们的程序，实际上这些执行命令均是我们上述Path所指定的bin目录下的相应可执行文件提供的。

1,深入碰撞原理

jpct-ae引擎的碰撞分为：线碰撞、球体碰撞、随圆碰撞 三种，今天的代码原为jse版本，笔者将其转为android版并详加注释，希望对大家有帮助。

2,代码解析
01.package com.threed.jpct.example;
02.
03.import java.lang.reflect.Field;
04.
05.import javax.microedition.khronos.egl.EGL10;
06.import javax.microedition.khronos.egl.EGLConfig;
07.import javax.microedition.khronos.egl.EGLDisplay;
08.import javax.microedition.khronos.opengles.GL10;
09.
10.import android.app.Activity;
11.import android.opengl.GLSurfaceView;
12.import android.os.Bundle;
13.import android.view.KeyEvent;
14.
15.import com.threed.jpct.Camera;
16.import com.threed.jpct.Config;
17.import com.threed.jpct.FrameBuffer;
18.import com.threed.jpct.Light;
19.import com.threed.jpct.Logger;
20.import com.threed.jpct.Object3D;
21.import com.threed.jpct.Primitives;
22.import com.threed.jpct.RGBColor;
23.import com.threed.jpct.SimpleVector;
24.import com.threed.jpct.Texture;
25.import com.threed.jpct.World;
26.import com.threed.jpct.util.MemoryHelper;
27.
28./**
29. * 此示例展示了jpct-ae工作在android版本的碰撞检测
30. *
31. * @author ibm
32. *
33. */
34.public class Collision extends Activity {
35. private static Collision master = null; // activity对象
36. private GLSurfaceView mGLView; // SurfaceView的实现，它使用专用表面显示OpenGL渲染。
37. private MyRenderer renderer = null;// 自定义渲染
38.
39. private static final float DAMPING = 0.1f; // 重力
40. private static final float SPEED = 1f; // 速度
41. private static final float MAXSPEED = 1f; // 最大速度
42.
43. private FrameBuffer fb = null; // FrameBuffer对象
44. private World world = null; // World对象
45.
46. private Object3D plane = null; // 平面
47. private Object3D ramp = null; // 斜面
48. private Object3D cube = null; // 立方体
49. private Object3D cube2 = null; // 立方体
50. private Object3D sphere = null; // 球体
51.
52. private boolean up = false; // 方向上下左右
53. private boolean down = false;
54. private boolean left = false;
55. private boolean right = false;
56.
57. private SimpleVector moveRes = new SimpleVector(0, 0, 0);// 三维矢量
58. private SimpleVector ellipsoid = new SimpleVector(2, 2, 2);// 椭球
59.
60. private RGBColor back = new RGBColor(50, 50, 100); // 颜色
61.
62. private Camera cam; // 记录视野、位置及方向
63.
64. private long time = System.currentTimeMillis(); // 当前毫秒数
65. private long fps = 0; // 帧/秒
66.
67. protected void onCreate(Bundle savedInstanceState) {
68.
69. Logger.log("onCreate");
70.
71. if (master != null) {
72. copy(master);
73. }
74.
75. super.onCreate(savedInstanceState);
76. // 实例化GLSurfaceView
77. mGLView = new GLSurfaceView(getApplication());
78. // 使用自己实现的 EGLConfigChooser,该实现必须在setRenderer(renderer)之前
79. // 如果没有setEGLConfigChooser方法被调用，则默认情况下，视图将选择一个与当前android.view.Surface兼容至少16位深度缓冲深度EGLConfig。
80. mGLView.setEGLConfigChooser(new GLSurfaceView.EGLConfigChooser() {
81. public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
82. int[] attributes = new int[] { EGL10.EGL_DEPTH_SIZE, 16,
83. EGL10.EGL_NONE };
84. EGLConfig[] configs = new EGLConfig[1];
85. int[] result = new int[1];
86. egl.eglChooseConfig(display, attributes, configs, 1, result);
87. return configs[0];
88. }
89. });
90.
91. // 实例化MyRenderer
92. renderer = new MyRenderer();
93. // 设置View的渲染器，同时启动线程调用渲染，以至启动渲染
94. mGLView.setRenderer(renderer);
95. // 设置一个明确的视图
96. setContentView(mGLView);
97.
98. }
99.
100. @Override
101. protected void onPause() { // puase
102. super.onPause();
103. mGLView.onPause();
104. }
105.
106. @Override
107. protected void onResume() { // resume
108. super.onResume();
109. mGLView.onResume();
110. }
111.
112. @Override
113. protected void onStop() {// stop
114. super.onStop();
115. }
116.
117. @Override
118. public boolean onKeyDown(int keyCode, KeyEvent event) { // 按键处理，当上下左右中的一个按下时，则将相应的变量置true
119. switch (keyCode) {
120. case KeyEvent.KEYCODE_DPAD_UP:
121. up = true;
122. break;
123. case KeyEvent.KEYCODE_DPAD_DOWN:
124. down = true;
125. break;
126. case KeyEvent.KEYCODE_DPAD_LEFT:
127. left = true;
128. break;
129. case KeyEvent.KEYCODE_DPAD_RIGHT:
130. right = true;
131. break;
132. }
133. return super.onKeyDown(keyCode, event);
134. }
135.
136. @Override
137. public boolean onKeyUp(int keyCode, KeyEvent event) { // 当松开按键时，才会
138. up = false;
139. down = false;
140. left = false;
141. right = false;
142. return super.onKeyUp(keyCode, event);
143. }
144.
145. private void copy(Object src) {
146. try {
147. // 打印日志
148. Logger.log("Copying data from master Activity!");
149. // 返回一个数组，其中包含目前这个类的的所有字段的Filed对象
150. Field[] fs = src.getClass().getDeclaredFields();
151. // 遍历fs数组
152. for (Field f : fs) {
153. // 尝试设置无障碍标志的值。标志设置为false将使访问检查，设置为true，将其禁用。
154. f.setAccessible(true);
155. // 将取到的值全部装入当前类中
156. f.set(this, f.get(src));
157. }
158. } catch (Exception e) {
159. // 抛出运行时异常
160. throw new RuntimeException(e);
161. }
162.
163. }
164.
165. protected boolean isFullscreenOpaque() {
166. return true;
167. }
168.
169. class MyRenderer implements GLSurfaceView.Renderer {
170.
171. public MyRenderer() {
172. Config.maxPolysVisible = 500; // 最多绘制500个多边形
173. Config.farPlane = 1500; // 最远的合适平面为1500
174. Config.glTransparencyMul = 0.1f;// 在jpct-ae中修改参数计算透明度，公式为trans=offset+objTrans*mul,默认的偏移量为0.1f
175. Config.glTransparencyOffset = 0.1f;// 偏移量,默认为0.1f
176. Config.useVBO = true;// 使用顶点缓冲区代替普通的顶点数组，在某些机器上会变快，默认为true(新版本改为true,原为false)
177. Texture.defaultTo4bpp(true);// ??
178. Texture.defaultToMipmapping(true);// 所有的纹理默认使用mipmaps，默认设置是false
179. }
180.
181. public void onSurfaceChanged(GL10 gl, int w, int h) {
182. if (fb != null) {// 如果fb不为null
183. fb.dispose(); // 销毁清理
184. }
185. fb = new FrameBuffer(gl, w, h); // 在使用前创建一个宽w,高h,内容为支持opengl
186. // 1.0/1.1的FrameBuffer
187. world = new World();// 创建一个新的"世界"。world就像充满对象与光线空的房间
188. if (master == null) { // 如果master对象为空
189. plane = Primitives.getPlane(20, 10); // 得到平面
190. plane.rotateX((float) Math.PI / 2); // 从jpct-ae的坐标旋转到正常坐标系
191. ramp = Primitives.getCube(20); // 得到立方体
192. ramp.rotateX((float) Math.PI / 2);
193. sphere = Primitives.getSphere(30); // 得到球体
194. sphere.translate(-50, 10, 50);
195. cube2 = Primitives.getCube(20);// 立方体
196. cube2.translate(60, -20, 60);
197. cube = Primitives.getCube(2); // 我们可操作的cube,参数表示立方体的缩放
198. cube.translate(-50, -10, -50);
199.
200. plane.setCollisionMode(Object3D.COLLISION_CHECK_OTHERS); // 设置碰撞模式为被碰撞
201. ramp.setCollisionMode(Object3D.COLLISION_CHECK_OTHERS);
202. sphere.setCollisionMode(Object3D.COLLISION_CHECK_OTHERS);
203. cube2.setCollisionMode(Object3D.COLLISION_CHECK_OTHERS);
204. cube.setCollisionMode(Object3D.COLLISION_CHECK_SELF); // 设置碰撞模式为主动碰撞
205.
206. world.addObject(plane); // 将"物体"放到"世界"里
207. world.addObject(ramp);
208. world.addObject(cube);
209. world.addObject(sphere);
210. world.addObject(cube2);
211.
212. Light light = new Light(world); // 为这个"世界"带来光照
213. light.setPosition(new SimpleVector(0, -80, -0)); // 设置光照坐标系
214. light.setIntensity(140, 120, 120); // 设置光照强度
215.
216. cam = world.getCamera(); // 得到当前的Camera
217. cam.moveCamera(Camera.CAMERA_MOVEOUT, 100); // 相对于当前位置向后移动100
218. cam.moveCamera(Camera.CAMERA_MOVEUP, 100); // 向上移动100
219.
220. world.setAmbientLight(20, 20, 20);// 设置环境光
221. MemoryHelper.compact(); // 回收内存
222. if (master == null) { // 实例化Collision对象
223. Logger.log("Saving master Activity!");
224. master = Collision.this;
225. }
226. }
227. }
228.
229. public void onSurfaceCreated(GL10 gl, EGLConfig config) {
230. }
231.
232. public void onDrawFrame(GL10 gl) {
233. move(); // 移动
234.
235. cam.setPositionToCenter(cube);
236. cam.align(cube);
237. cam.rotateCameraX((float) Math.toRadians(30));
238. cam.moveCamera(Camera.CAMERA_MOVEOUT, 100);
239.
240. fb.clear(back);
241. world.renderScene(fb);
242. world.draw(fb);
243. fb.display();
244.
245. if (System.currentTimeMillis() - time >= 1000) {
246. Logger.log(fps + "fps");
247. fps = 0;
248. time = System.currentTimeMillis();
249. }
250. fps++;
251. }
252.
253. public void move() { // 碰撞与移动的设定
254. if (up) { // 按向上方向键
255. SimpleVector t = cube.getZAxis(); // 取得cube的Z轴
256. t.scalarMul(SPEED);// 向里移动
257. moveRes.add(t);
258. }
259. if (down) {
260. SimpleVector t = cube.getZAxis();
261. t.scalarMul(-SPEED); // 向外移动
262. moveRes.add(t);
263. }
264. if (left) {
265. cube.rotateY((float) Math.toRadians(-1));// 向左旋转
266. }
267. if (right) {
268. cube.rotateY((float) Math.toRadians(1)); // 向右旋转
269. }
270.
271. // avoid high speeds;
272. if (moveRes.length() > MAXSPEED) {
273. moveRes.makeEqualLength(new SimpleVector(0, 0, MAXSPEED)); // 设定最大长度为MAXSPEED
274. }
275. cube.translate(0, -0.02f, 0);// 向上移动0.02f
276. moveRes = cube.checkForCollisionEllipsoid(moveRes, ellipsoid, 8); // 设置碰撞
277. cube.translate(moveRes); // 旋转
278.
279. // 重力感应
280. SimpleVector t = new SimpleVector(0, 1, 0);
281. t = cube.checkForCollisionEllipsoid(t, ellipsoid, 1);
282. cube.translate(t);
283.
284. // 阻尼- -#，考虑的还真周到
285. if (moveRes.length() > DAMPING) { // 如果按上方向键或下方向键,产生阻尼
286. moveRes.makeEqualLength(new SimpleVector(0, 0, DAMPING));
287. } else {
288. moveRes = new SimpleVector(0, 0, 0); // 否则不产生
289. }
290. }
291. }
292.}

2、屏幕的宽和高

为了在屏幕中的合适位置绘制图形，我们需要使用屏幕的宽和高作为参考，来确定绘制图形的位置。要获得屏幕的宽和高，首先从Activity对象中获得WindowManager对象，然后从WindowManager对象中获得Display对象，再从Display对象中获得屏幕的宽和高。

// 获得屏幕的宽和高

WindowManager manger = getWindowManager();

Diaplay diaplay = manager.getDefaultDisplay();

int screenWidth = display.getWidth();

int screenHeight = display.getHeight();

3、边界的确定

在很多游戏中都需要对绘制在屏幕中格的视图进行边界的确定。例如，在射击类游戏中我们就需要判断玩家、敌人、子弹等视图的边界位置。边界的判断无非是对上、下、左、右屏幕边界的判断。

如果当前视图的X坐标小于零，则当前视图左越界。如果当前视图的X坐标大于屏幕的宽，则右越界。

如果当前视图的Y坐标小于零，则当前视图上越界。如果当前视图的Y坐标大于屏幕的高，则下越界。

4、视图的移动

游戏的实现过程其实很简单，就是不但改变视图的位置坐标，然后重新将他们绘制在屏幕上。不过这种坐标的位置改变和绘制过程是通过一定逻辑来控制实现的。视图的移动就是通过改变视图坐标位置来实现的。改变了坐标再重新绘制，给我们的感觉是视图在移动。

如果视图水平向左移动，X坐标减小；如果视图水平向右移动，X坐标增大。

如果视图垂直向上移动，Y坐标减小；如果视图垂直向下移动，Y坐标增大。

5、Android游戏开发基本框架

Android游戏开发框架基本对象有三个：一是图层对象，该图层对象定义图层的宽和高、图层的位置、图层的移动以及绘制方法等；二是视图对象，视图对象的主要作用是绘制图层对象、相应键盘事件和处理视图线程等；三是一个Activity控制游戏流程，例如启动游戏、暂停游戏、停止游戏等。

下面我们就来个 基础吧，就是场景的切换，类似于android中activity的切换。下面来看看吧。

切换必须具备的有：1.两个场景或以上， 2.Application.LoadLevel(x)//x可以是场景名或者是场景号。3.那就是一个事件触发。

场景menu

场景yaya

场景yaya1

下面就来贴贴代码了：
01.using UnityEngine;
02.using System.Collections;
03.
04.public class menu : MonoBehaviour {
05.
06. bool flag;
07. void Start () {
08. DontDestroyOnLoad(this);//这个作用是场景切换时，一下代码不撤销

01. flag=true;
02. }
03.
04. void Update () {
05. if(Input.GetKeyDown(KeyCode.Space)){
06. if(flag){
07. flag=false;
08. }
09. else{
10. flag=true;
11. }
12. }
13. }
14. void OnGUI(){
15. if(!flag){
16. return;
17. }
18. if(GUI.Button(new Rect(Screen.width/2-50,Screen.height/2-30,40,60),"yaya1")){
19. Application.LoadLevel(1);
20. }
21. if(GUI.Button(new Rect(Screen.width/2,Screen.height/2-30,40,60),"yaya2")){
22. Application.LoadLevel(2);
23. }
24. if(GUI.Button(new Rect(Screen.width/2+50,Screen.height/2-30,40,60),"Quit")){
25. Application.Quit();
26. }
27. }
28.}
把以上代码绑定在第一个场景（menu）里面；
我们解释一下代码

DontDestroyOnLoad(this);//这个作用是场景切换时，一下代码不撤销，而不是场景中的游戏对象不撤销

Application.Quit(); 退出

我们可以通过制作一个U盘启动盘来在NETBOOK上运行安卓ICS

下面我简单介绍下安装部分。

目前供下载的Android 4.0.3 x86版本有以下几个，我建议用ASUS那个，我朋友机器是AMD的，结果安装AMD那个版本跑不起来。安装了ASUS的却没问题。因此建议用ASUS的版本

android-x86-4.0-asus_laptop-20120101.iso

android-x86-4.0-eeepc-20120101.iso

android-x86-4.0-amd_brazos-20120101.iso

1. U盘启动盘的制作。

由于大部分小本本是没有光驱的，所以只有靠U盘启动，制作U盘启动很容易。

请先到http://unetbootin.sourceforge.net/ 按照你的系统环境下载UNETBOOTIN, 有WIN/MAC/LINUX等等。下载后解压到一个目录

然后将FAT32格式的U盘插入你的电脑，启动UNETBOOTIN软件，选择你放ANDROID IOS的路径，再选择U盘盘符。点OK。一张启动盘就创建好了。

2. U盘启动ANDROID 4.0.3

这个步骤很简单，插上U盘，重启机器，注意你可能需要先进入BIOS里面，将你电脑的启动顺序改成USB启动，如下图

然后再启动电脑。要是一切顺利。就会看到下面几个选项。选择不安装就启动ANDROID好了

然后你就会看到这个图拉。

然后会像真正的安卓机器一样，让你建立GOOGLE帐号等一系列设置。你可以直接忽略。（请注意要是你始终停留在这个界面，那就说明你下的IOS和你的机器不匹配。我的AMD机器就是停在这一步了。

如果一切正常，那么你会看到ANDROID 4.0.3的界面了。其实和ANDROID3差别不大。只是进入关于时候，你能看到4.03这个版本号

注意别在VMWARE里面装。你最好用U盘启动来装。VMWARE里面装很可能失败的

经过一系列基本设置。比如设置WIFI （是的，这个系统支持WIFI)，还有下载好安卓市场等等。你就可以开装软件。大部分软件都能安装的

装了几个小插件和程序。上网也没问题

但是这套系统似乎并不支持触屏。尝试了2台机器都不支持。

这个原版的对VB支持不好。不过有其他开发者的改进版似乎完美支持VB。给出网址在这里

http://www.buildroid.org/blog/

如何设置您的NDK应用

本篇主要介绍NDK应用的开发步骤，调试流程已经如何为英特尔架构设置您的NDK应用。

相关文章

•1. 开发兼容英特尔架构的Android应用(一) 应用架构介绍

•2. 开发兼容英特尔架构的Android应用(二) NDK应用介绍

•3. 开发兼容英特尔架构的Android应用(三) 如何设置您的NDK应用

•1. NDK应用开发步骤

NDK应用的开发流程主要分为五个步骤：

•1、 准备好本地代码

•2、 编写makefile文件，mk文件

•3、 编译本地代码（需要添加X86支持选项）为库文件（so）

•4、 从Java端调用本地代码

•5、 用gdb来调试本地代码

通过以上五个步骤后，应用程序调用流程如下图所示：Android App通过Java Framework调用Java SDK API, 通过JNI调用本地库文件。

•2. 创建本地代码和编写makefile文件

在Android工程的jni文件夹下面创建本例中使用的本地代码hello-jni.c 以及Android.mk，代码如下图所示。 注意，在Android.mk文件中要添加X86的支持项。

•3. 编译本地代码（需要添加X86支持选项）为库文件（so）

进入工程所在目录，运行ndk-build来编译本地代码，运行效果如下次，会分别为ARM和X86生成相应的so文件，从java调用本地代码如下图红色标出所示。

•4. 调试流程

调试流程的要求以及调试过程如下图，需要注意的是在manifest文件中需要设置android:debuggable="true"； 然后使用ndk-gdb来调试即可。

本篇完。

相关文章

•1. 开发兼容英特尔架构的Android应用(一) 应用架构介绍

•2. 开发兼容英特尔架构的Android应用(二) NDK应用介绍

•3. 开发兼容英特尔架构的Android应用(三) 如何设置您的NDK应用

本篇主要介绍NDK应用的架构，运行机制以及代码结构。。

•1. 开发兼容英特尔架构的Android应用(一) 应用架构介绍

•2. 开发兼容英特尔架构的Android应用(二) NDK应用介绍

•3. 开发兼容英特尔架构的Android应用(三) 如何设置您的NDK应用

•1. NDK 介绍

NDK在安卓官方解释为：NDK(Native Development Kit) is a toolset that lets you embed components that make use of native code in your Android applications。是一个本地代码开发套件，通过JNI（Java Native Interface）Java本地接口机制来供Java代码调用。

•2. NDK 应用结构

一个典型的NDK 应用如下图所示，包含四个部分：Android Manifest，Dalvik Classes（Java代码），资源文件和JNI调用的本地库（so文件）。

•3. NDK 应用调用过程

NDK应用调用过程可以简单地用下面这张从网上摘录的图表示。所有的本地代码（C/C++）等等通过Android Makefile文件编译为动态库文件，Java Classes通过JNI接口去调用动态库。

•4. NDK API

Android NDK同样提供了一些本地的API供开发者调用，如libc，libm等等，如果你的库是来自于linux项目，那么将相应的库做一些移植工作即可，比如讲glib相应的参数移至libc下面等等。

•l libc (C library) headers

•l libm (math library) headers

•l JNI interface headers

•l libz (Zlib compression) headers

•l liblog (Android logging) header

•l OpenGL ES 1.1 and OpenGL ES 2.0 (3D graphics libraries) headers

•l libjnigraphics (Pixel buffer access) header (for Android 2.2 and above).

•l A Minimal set of headers for C++ support

•l OpenSL ES native audio libraries

•l Android native application APIS

本篇完。

相关文章

•1. 开发兼容英特尔架构的Android应用(一) 应用架构介绍

•2. 开发兼容英特尔架构的Android应用(二) NDK应用介绍

•3. 开发兼容英特尔架构的Android应用(三) 如何设置您的NDK应用