Android手机 屏幕 大小不一，有480x320, 640x360, 800x480.怎样才能让App自动 适应不同的屏幕 呢？
   其实很简单，只需要在res目录下创建不同的layout文件 夹，比如layout-640x360,layout-800x480,所有的layout文件在编译 之后都会写入R.java里，而系统 会根据屏幕 的大小自己选择合适的layout进行使用。

二：hdpi、mdpi、ldpi

在之前的版本中，只有一个drawable，而2.1版本中有drawable-mdpi、drawable-ldpi、drawable-hdpi三个，这三个主要是为了支持多分辨率。

　　drawable- hdpi、drawable- mdpi、drawable-ldpi的区别：

　　(1)drawable-hdpi里面存放高分辨率的图片,如WVGA (480x800),FWVGA (480x854)

　　(2)drawable-mdpi里面存放中等分辨率的图片,如HVGA (320x480)

　　(3)drawable-ldpi里面存放低分辨率的图片,如QVGA (240x320)

　　系统会根据机器的分辨率来分别到这几个文件夹里面去找对应的图片。

　　在开发 程序 时为了兼容不同平台 不同屏幕 ，建议各自文件夹根据需求均存放不同版本图片。

屏幕 方向：

横屏竖屏自动切换：

     可以在res目录下建立layout-port和layout-land两个目录，里面分别放置竖屏和横屏两种布局文件，这样在手机屏幕 方向变化的时候系统会自动调用相应的布局文件，避免一种布局文件无法满足两种屏幕 显示的问题。

不切换：

以下步骤是网上流传的，不过我自己之前是通过图形化界面 实现这个配置，算是殊途同归，有空我会把图片贴上来。

还要说明一点：每个activity 都有这个属性screenOrientation，每个activity都需要设置 ，可以设置为竖屏（portrait），也可以设置为无重力感应（nosensor）。

要让程序界面保持一个方向，不随手机方向转动而变化的处理办法：
 
在AndroidManifest.xml里面配置一下就可以了。加入这一行android :screenOrientation="landscape"。
例如（landscape是横向，portrait是纵向）：

代码 :

view plaincopy to clipboardprint?
<?xml version="1.0" encoding="utf-8"?> 
<manifest xmlns:android="http://schemas.android.com/apk/res/android" 
      package="com.ray.linkit" 
      android:versionCode="1" 
      android:versionName="1.0"> 
    <application android:icon="@drawable/icon" android:label="@string/app_name"> 
        <activity android:name=".Main" 
                  android:label="@string/app_name" 
                  android:screenOrientation="portrait"> 
            <intent-filter> 
                <action android:name="android.intent.action.MAIN" /> 
                <category android:name="android.intent.category.LAUNCHER" /> 
            </intent-filter> 
        </activity> 
                <activity android:name=".GamePlay" 
                android:screenOrientation="portrait"></activity> 
                <activity android:name=".OptionView" 
                android:screenOrientation="portrait"></activity> 
    </application> 
    <uses-sdk android:minSdkVersion="3" /> 
</manifest> 
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.ray.linkit"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".Main"
                  android:label="@string/app_name"
                  android:screenOrientation="portrait">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
                <activity android:name=".GamePlay"
                android:screenOrientation="portrait"></activity>
                <activity android:name=".OptionView"
                android:screenOrientation="portrait"></activity>
    </application>
    <uses-sdk android:minSdkVersion="3" />
</manifest>

另外，android中每次屏幕 的切换动会重启Activity，所以应该在Activity销毁前保存当前活动的状态，在Activity再次Create的时候载入配置，那样，进行中的游戏 就不会自动重启了！

有的程序适合从竖屏切换到横屏，或者反过来，这个时候怎么办呢？可以在配置Activity的地方进行如下的配置android:screenOrientation="portrait"。这样就可以保证是竖屏总是竖屏了，或者landscape横向。

而有的程序是适合横竖屏切换的。如何处理呢？首先要在配置Activity的时候进行如下的配置：android:configChanges="keyboardHidden|orientation"，另外需要重写Activity的 onConfigurationChanged方法。实现方式如下，不需要做太多的内容：

view plaincopy to clipboardprint?
@Override 
        public void onConfigurationChanged(Configuration newConfig) {  
                super.onConfigurationChanged(newConfig);  
                if (this.getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {  
                        // land do nothing is ok  
                } else if (this.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT) {  
                        // port do nothing is ok  
                }  
        } 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/JavaTiger427/archive/2010/11/29/6043097.aspx

     最终我们测试的如下:

view plaincopy to clipboardprint?
public class TouchLayout extends RelativeLayout {  
    public Handler doubleTapHandler = null;  
    protected long lastDown = -1;  
    public final static long DOUBLE_TIME = 500;  
   
 public TouchLayout(Context context) {  
       super(context);  
       
    }  
    public TouchLayout(Context context, AttributeSet attrs) {  
       super(context, attrs);  
       
    }  
    public TouchLayout(Context context, AttributeSet attrs, int defStyle) {  
       super(context, attrs, defStyle);  
        
    }  
     
    public boolean onTouchEvent(MotionEvent event) {  
         this.handleEvent(event);  
         if (event.getAction() == MotionEvent.ACTION_DOWN) {  
            long nowDown = System.currentTimeMillis();  
            if (nowDown - lastDown < DOUBLE_TIME)  
            {  
                  if (doubleTapHandler != null)  
                     doubleTapHandler.sendEmptyMessage(-1);  
            } else {  
               lastDown = nowDown;  
            }  
         }  
         return true;  
      }  
     
     
    protected void handleEvent(MotionEvent event) {  
        switch (event.getAction()) {  
        case MotionEvent.ACTION_DOWN:  
         //Do sth 这里处理即可  
           break;  
        case MotionEvent.ACTION_UP:  
           //Do sth  
           break;  
        }  
     }  
} 
public class TouchLayout extends RelativeLayout {
    public Handler doubleTapHandler = null;
    protected long lastDown = -1;
    public final static long DOUBLE_TIME = 500;
 
 public TouchLayout(Context context) {
       super(context);
    
    }
    public TouchLayout(Context context, AttributeSet attrs) {
       super(context, attrs);
    
    }
    public TouchLayout(Context context, AttributeSet attrs, int defStyle) {
       super(context, attrs, defStyle);
     
    }
  
    public boolean onTouchEvent(MotionEvent event) {
         this.handleEvent(event);
         if (event.getAction() == MotionEvent.ACTION_DOWN) {
            long nowDown = System.currentTimeMillis();
            if (nowDown - lastDown < DOUBLE_TIME)
            {
                  if (doubleTapHandler != null)
                     doubleTapHandler.sendEmptyMessage(-1);
            } else {
               lastDown = nowDown;
            }
         }
         return true;
      }
  
  
    protected void handleEvent(MotionEvent event) {
        switch (event.getAction()) {
        case MotionEvent.ACTION_DOWN:
         //Do sth 这里处理即可
           break;
        case MotionEvent.ACTION_UP:
           //Do sth
           break;
        }
     }
}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/JavaTiger427/archive/2010/11/25/6034698.aspx

  1. SoundPool载入音乐文件使用了独立的线程，不会阻塞UI主线程的操作。但是这里Android开发网提醒大家如果音效文件过大没有载入完成，我们调用play方法时可能产生严重的后果，这里Android SDK提供了一个SoundPool.OnLoadCompleteListener类来帮助我们了解媒体文件是否载入完成，我们重载 onLoadComplete(SoundPool soundPool, int sampleId, int status) 方法即可获得。

  2. 从上面的onLoadComplete方法可以看出该类有很多参数，比如类似id，是的SoundPool在load时可以处理多个媒体一次初始化并放入内存中，这里效率比MediaPlayer高了很多。

  3. SoundPool类支持同时播放多个音效，这对于游戏来说是十分必要的，而MediaPlayer类是同步执行的只能一个文件一个文件的播放。

  SoundPool类使用示例代码:

view plaincopy to clipboardprint?
SoundPool sp=new SoundPool(8, /*maxStreams*/, AudioManager.STREAM_MUSIC /*streamType*/, 100 /*srcQuality*/) ; 
SoundPool sp=new SoundPool(8, /*maxStreams*/, AudioManager.STREAM_MUSIC /*streamType*/, 100 /*srcQuality*/) ;

 有关载入音效的方法，有以下几种方法

view plaincopy to clipboardprint?
int  load(Context context, int resId, int priority)  //从APK资源载入  
   int  load(FileDescriptor fd, long offset, long length, int priority)  //从FileDescriptor对象载入  
   int  load(AssetFileDescriptor afd, int priority)  //从Asset对象载入  
   int  load(String path, int priority)  //从完整文件路径名载入 
int  load(Context context, int resId, int priority)  //从APK资源载入
   int  load(FileDescriptor fd, long offset, long length, int priority)  //从FileDescriptor对象载入
   int  load(AssetFileDescriptor afd, int priority)  //从Asset对象载入
   int  load(String path, int priority)  //从完整文件路径名载入

我们看到了每个load的重载版本的最后一个参数为优先级，这里用于播放多个文件时，系统会优先处理不过目前Android123提示大家SDK提到了目前并没有实现，所以没有实际的效果。

   对于播放，可以使用 play(int soundID, float leftVolume, float rightVolume, int priority, int loop, float rate)   而停止则可以使用 pause(int streamID) 方法，这里的streamID和soundID均在构造SoundPool类的第一个参数中指明了总数量，而id从0开始。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/JavaTiger427/archive/2010/11/25/6034679.aspx

  常规的我们可能只考虑QVGA，HVGA，WVGA，FWVGA和DVGA，但是抛去了手机不谈，可能平板使用类似 WSVGA的1024x576以及WXGA的1280x768等等。

QVGA = 320 * 240;
WQVGA = 320 * 480;
WQVGA2 = 400 * 240;
WQVGA3 = 432 * 240;
HVGA = 480 * 320;
VGA = 640 * 480;
WVGA = 800 * 480;
WVGA2 = 768 * 480;
FWVGA = 854 * 480;
DVGA = 960 * 640;
PAL = 576 * 520;
NTSC = 486 * 440;
SVGA = 800 * 600;
WSVGA = 1024 * 576;
XGA = 1024 * 768;
XGAPLUS = 1152 * 864;
HD720 = 1280 * 720;
WXGA = 1280 * 768;
WXGA2 = 1280 * 800;
WXGA3 = 1280 * 854;
SXGA = 1280 * 1024;
WXGA4 = 1366 * 768;
SXGAMINUS = 1280 * 960;
SXGAPLUS = 1400 * 1050;
WXGAPLUS = 1440 * 900;
HD900 = 1600 * 900;
WSXGA = 1600 * 1024;
WSXGAPLUS = 1680 * 1050;
UXGA = 1600 * 1200;
HD1080 = 1920 * 1080;
QWXGA = 2048 * 1152;
WUXGA = 1920 * 1200;
TXGA = 1920 * 1400;
QXGA = 2048 * 1536;
WQHD = 2560 * 1440;
WQXGA = 2560 * 1600;
QSXGA = 2560 * 2048;
QSXGAPLUS = 2800 * 2100;
WQSXGA = 3200 * 2048;
QUXGA = 3200 * 2400;
QFHD = 3840 * 2160;
WQUXGA = 3840 * 2400;
HD4K = 4096 * 2304;
HXGA = 4096 * 3072;
WHXGA = 5120 * 3200;
HSXGA = 5120 * 4096;
WHSXGA = 6400 * 4096;
HUXGA = 6400 * 4800;
SHV = 7680 * 4320;
WHUXGA = 7680 * 4800;

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/JavaTiger427/archive/2010/11/25/6034693.aspx

  一、LinearGradient线性渐变

  在android平台中提供了两种重载方式来实例化该类分别为，他们的不同之处为参数中第一种方法可以用颜色数组，和位置来实现更细腻的过渡效果，比如颜色采样int[] colors数组中存放20种颜色，则渐变将会逐一处理。而第二种方法参数仅为起初颜色color0和最终颜色color1。

view plaincopy to clipboardprint?
LinearGradient(float x0, float y0, float x1, float y1, int[] colors, float[] positions, Shader.TileMode tile)   
LinearGradient(float x0, float y0, float x1, float y1, int color0, int color1, Shader.TileMode tile)  
LinearGradient(float x0, float y0, float x1, float y1, int[] colors, float[] positions, Shader.TileMode tile)
LinearGradient(float x0, float y0, float x1, float y1, int color0, int color1, Shader.TileMode tile) 

使用实例如下

view plaincopy to clipboardprint?
Paint p=new Paint();  
  LinearGradient lg=new LinearGradient(0,0,100,100,Color.RED,Color.BLUE,Shader.TileMode.MIRROR);  //参数一为渐变起初点坐标x位置，参数二为y轴位置，参数三和四分辨对应渐变终点，最后参数为平铺方式，这里设置为镜像 
Paint p=new Paint();
  LinearGradient lg=new LinearGradient(0,0,100,100,Color.RED,Color.BLUE,Shader.TileMode.MIRROR);  //参数一为渐变起初点坐标x位置，参数二为y轴位置，参数三和四分辨对应渐变终点，最后参数为平铺方式，这里设置为镜像

刚才Android开发网已经讲到Gradient是基于Shader类，所以我们通过Paint的setShader方法来设置这个渐变，代码如下:

view plaincopy to clipboardprint?
p.setShader(lg);  
  canvas.drawCicle(0,0,200,p); //参数3为画圆的半径，类型为float型。 
p.setShader(lg);
  canvas.drawCicle(0,0,200,p); //参数3为画圆的半径，类型为float型。

二、 RadialGradient镜像渐变

  有了上面的基础，我们一起来了解下径向渐变。和上面参数唯一不同的是，径向渐变第三个参数是半径，其他的和线性渐变相同。

view plaincopy to clipboardprint?
RadialGradient(float x, float y, float radius, int[] colors, float[] positions, Shader.TileMode tile)   
  RadialGradient(float x, float y, float radius, int color0, int color1, Shader.TileMode tile)  
RadialGradient(float x, float y, float radius, int[] colors, float[] positions, Shader.TileMode tile)
  RadialGradient(float x, float y, float radius, int color0, int color1, Shader.TileMode tile) 

三、 SweepGradient角度渐变

  对于一些3D立体效果的渐变可以尝试用角度渐变来完成一个圆锥形，相对来说比上面更简单，前两个参数为中心点，然后通过载入的颜色来平均的渐变渲染。

view plaincopy to clipboardprint?
SweepGradient(float cx, float cy, int[] colors, float[] positions)  //对于最后一个参数SDK上的描述为May be NULL. The relative position of each corresponding color in the colors array, beginning with 0 and ending with 1.0. If the values are not monotonic, the drawing may produce unexpected results. If positions is NULL, then the colors are automatically spaced evenly.，所以Android123建议使用下面的重载方法，本方法一般为NULL即可。  
SweepGradient(float cx, float cy, int color0, int color1) 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/JavaTiger427/archive/2010/11/25/6034673.aspx

view plaincopy to clipboardprint?
import android.content.Context;  
import android.net.Uri;  
import android.os.PowerManager;  
import android.os.SystemClock;  
import android.util.Log;  
import java.io.IOException;  
import java.lang.IllegalStateException;  
import java.util.LinkedList;  
   
public class AsyncPlayer {  
    private static final int PLAY = 1;  
    private static final int STOP = 2;  
    private static final boolean mDebug = false;  
    private static final class Command {  
        int code;  
        Context context;  
        Uri uri;  
        boolean looping;  
        int stream;  
        long requestTime;  
        public String toString() {  
            return "{ code=" + code + " looping=" + looping + " stream=" + stream  
                    + " uri=" + uri + " }";  
        }  
    }  
    private LinkedList<Command> mCmdQueue = new LinkedList();  //用一个链表保存播放参数队列  
    private void startSound(Command cmd) {  
   
        try {  
            MediaPlayer player = new MediaPlayer();  
            player.setAudioStreamType(cmd.stream);  
            player.setDataSource(cmd.context, cmd.uri);  //设置媒体源，这里Android123提示大家本类的public void play (Context context, Uri uri, boolean looping, int stream) 类第二个参数Uri为媒体位置。  
            player.setLooping(cmd.looping);  
            player.prepare();  
            player.start();  
            if (mPlayer != null) {  
                mPlayer.release();  
            }  
            mPlayer = player;  
          }  
        catch (IOException e) {  
            Log.w(mTag, "error loading sound for " + cmd.uri, e);  
        } catch (IllegalStateException e) {  
            Log.w(mTag, "IllegalStateException (content provider died?) " + cmd.uri, e);  
        }  
    }  
    private final class Thread extends java.lang.Thread {   //通过多线程方式不阻塞调用者  
        Thread() {  
            super("AsyncPlayer-" + mTag);  
        }  
        public void run() {  
            while (true) {  
                Command cmd = null;  
                synchronized (mCmdQueue) {   //同步方式执行  
                        cmd = mCmdQueue.removeFirst();  
                }  
                switch (cmd.code) {  
                case PLAY:  
                                 startSound(cmd);  
                    break;  
                case STOP:  
   
                    if (mPlayer != null) {  
                                         mPlayer.stop();  
                        mPlayer.release();  
                        mPlayer = null;  
                    } else {  
                        Log.w(mTag, "STOP command without a player");  
                    }  
                    break;  
                }  
                synchronized (mCmdQueue) {  
                    if (mCmdQueue.size() == 0) {  
             
                        mThread = null;  
                        releaseWakeLock();  
                        return;  
                    }  
                }  
            }  
        }  
    }  
    private String mTag;  
    private Thread mThread;  
    private MediaPlayer mPlayer;  
    private PowerManager.WakeLock mWakeLock;  
   
    private int mState = STOP;  
   
    public AsyncPlayer(String tag) {  
        if (tag != null) {  
            mTag = tag;  
        } else {  
            mTag = "AsyncPlayer";  
        }  
    }  
   
    public void play(Context context, Uri uri, boolean looping, int stream) {  
        Command cmd = new Command();  
        cmd.requestTime = SystemClock.uptimeMillis(); //这里为了测试性能，传递了开始执行前的系统tickcount计时器值  
        cmd.code = PLAY;  
        cmd.context = context;  
        cmd.uri = uri;  
        cmd.looping = looping;  
        cmd.stream = stream;  
        synchronized (mCmdQueue) {  
            enqueueLocked(cmd);  
            mState = PLAY;  
        }  
    }  
     
   
    public void stop() {  
        synchronized (mCmdQueue) {  
                 if (mState != STOP) {  
                Command cmd = new Command();  
                cmd.requestTime = SystemClock.uptimeMillis();  
                cmd.code = STOP;  
                enqueueLocked(cmd);  
                mState = STOP;  
            }  
        }  
    }  
    private void enqueueLocked(Command cmd) {  
        mCmdQueue.add(cmd);  
        if (mThread == null) {  
            acquireWakeLock();  
            mThread = new Thread();  
            mThread.start();  
        }  
    } 
import android.content.Context;
import android.net.Uri;
import android.os.PowerManager;
import android.os.SystemClock;
import android.util.Log;
import java.io.IOException;
import java.lang.IllegalStateException;
import java.util.LinkedList;
 
public class AsyncPlayer {
    private static final int PLAY = 1;
    private static final int STOP = 2;
    private static final boolean mDebug = false;
    private static final class Command {
        int code;
        Context context;
        Uri uri;
        boolean looping;
        int stream;
        long requestTime;
        public String toString() {
            return "{ code=" + code + " looping=" + looping + " stream=" + stream
                    + " uri=" + uri + " }";
        }
    }
    private LinkedList<Command> mCmdQueue = new LinkedList();  //用一个链表保存播放参数队列
    private void startSound(Command cmd) {
 
        try {
            MediaPlayer player = new MediaPlayer();
            player.setAudioStreamType(cmd.stream);
            player.setDataSource(cmd.context, cmd.uri);  //设置媒体源，这里Android123提示大家本类的public void play (Context context, Uri uri, boolean looping, int stream) 类第二个参数Uri为媒体位置。
            player.setLooping(cmd.looping);
            player.prepare();
            player.start();
            if (mPlayer != null) {
                mPlayer.release();
            }
            mPlayer = player;
          }
        catch (IOException e) {
            Log.w(mTag, "error loading sound for " + cmd.uri, e);
        } catch (IllegalStateException e) {
            Log.w(mTag, "IllegalStateException (content provider died?) " + cmd.uri, e);
        }
    }
    private final class Thread extends java.lang.Thread {   //通过多线程方式不阻塞调用者
        Thread() {
            super("AsyncPlayer-" + mTag);
        }
        public void run() {
            while (true) {
                Command cmd = null;
                synchronized (mCmdQueue) {   //同步方式执行
                        cmd = mCmdQueue.removeFirst();
                }
                switch (cmd.code) {
                case PLAY:
                                 startSound(cmd);
                    break;
                case STOP:
 
                    if (mPlayer != null) {
                                         mPlayer.stop();
                        mPlayer.release();
                        mPlayer = null;
                    } else {
                        Log.w(mTag, "STOP command without a player");
                    }
                    break;
                }
                synchronized (mCmdQueue) {
                    if (mCmdQueue.size() == 0) {
          
                        mThread = null;
                        releaseWakeLock();
                        return;
                    }
                }
            }
        }
    }
    private String mTag;
    private Thread mThread;
    private MediaPlayer mPlayer;
    private PowerManager.WakeLock mWakeLock;
 
    private int mState = STOP;
 
    public AsyncPlayer(String tag) {
        if (tag != null) {
            mTag = tag;
        } else {
            mTag = "AsyncPlayer";
        }
    }
 
    public void play(Context context, Uri uri, boolean looping, int stream) {
        Command cmd = new Command();
        cmd.requestTime = SystemClock.uptimeMillis(); //这里为了测试性能，传递了开始执行前的系统tickcount计时器值
        cmd.code = PLAY;
        cmd.context = context;
        cmd.uri = uri;
        cmd.looping = looping;
        cmd.stream = stream;
        synchronized (mCmdQueue) {
            enqueueLocked(cmd);
            mState = PLAY;
        }
    }
  
 
    public void stop() {
        synchronized (mCmdQueue) {
                 if (mState != STOP) {
                Command cmd = new Command();
                cmd.requestTime = SystemClock.uptimeMillis();
                cmd.code = STOP;
                enqueueLocked(cmd);
                mState = STOP;
            }
        }
    }
    private void enqueueLocked(Command cmd) {
        mCmdQueue.add(cmd);
        if (mThread == null) {
            acquireWakeLock();
            mThread = new Thread();
            mThread.start();
        }
    }

一般对于Android游戏而言下面的代码不用考虑，一般用户都在交互操作，不会出现屏幕锁问题

view plaincopy to clipboardprint?
public void setUsesWakeLock(Context context) {  //电源管理wakelock处理  
        if (mWakeLock != null || mThread != null) {  
                      throw new RuntimeException("assertion failed mWakeLock=" + mWakeLock  
                    + " mThread=" + mThread);  
        }  
        PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE);  
        mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, mTag);  
    }  
    private void acquireWakeLock() {   //加锁  
        if (mWakeLock != null) {  
            mWakeLock.acquire();  
        }  
    }  
    private void releaseWakeLock() { //解锁  
        if (mWakeLock != null) {  
            mWakeLock.release();  
        }  
    }  
} 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/JavaTiger427/archive/2010/11/25/6034662.aspx

  一、游戏地图编辑器，在J2ME时代我们可能都是用GIF分割多帧或BMP上放置多个图片通过减少文件头来压缩体积，但是在Android平台上开发游戏我们不需要那么节省，不过资源的释放仍然很重要，否则会出现OutOfMemoryError这样的悲剧发生。一般简单的2D平面游戏地图都是使用二维数组来标记的。我们可以想象矩阵中的每个元素对应每个图片资源。详细的存储方法我们将在下次具体讲到。

  二、控制方式，由于横版过关类游戏不适合重力感应操作，我们这里选择屏幕下方加设一个区域，放置上、下、左、右按键，同时右侧给出常用的攻击、跳跃按钮，而游戏的暂停可以通过触控实现继续或暂停。

  三、音效处理，常规的一般在攻击比如出拳、发射子弹的过程中有音效，或对手自己中弹（当然对于Android图形开发来说就是碰撞检测）时发出音效，跳跃、过关均会需要一些声音素材文件，一般的游戏还需要背景音乐配合烘托游戏气氛。

  四、游戏逻辑，这是主要的地方，我们将通过实例代码让大家了解游戏开发中是如何的卷轴、人物的跳跃、攻击有效判断即碰撞检测，电脑智能等算法问题。

  五、细节处理，比如计分，等级，游戏计时，关卡档案的存档，读取以及开场设计，关卡过渡的过场动画处理。

  这里Android开发网提示大家，目前很多J2ME的游戏可以轻松的移植到Android平台，主要的细节只要了解Google Android平台的图形相关问题即可，主要是Bitmap、Drawable和View线程处理问题。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/JavaTiger427/archive/2010/11/25/6034645.aspx

view plaincopy to clipboardprint?
@Override 
    public boolean dispatchKeyEvent(KeyEvent event)  
    {  
           switch (event.getKeyCode())  
           {  
             case KeyEvent.KEYCODE_VOLUME_UP:   //音量键+  
             case KeyEvent.KEYCODE_VOLUME_DOWN:   //音量键-  
             case KeyEvent.KEYCODE_CAMERA:  //拍照键  
             case KeyEvent.KEYCODE_FOCUS:   //拍照键半按的对焦状态  
          //   event.getAction() == KeyEvent.ACTION_UP   //Android123提示如果按键按下后弹起时触发  
                 
            }  
                return true; //这些标记为处理过，则不在往内部传递  
         default:  
                break;  
        }  
        return super.dispatchKeyEvent(event);  
    } 
@Override
    public boolean dispatchKeyEvent(KeyEvent event)
    {
           switch (event.getKeyCode())
           {
             case KeyEvent.KEYCODE_VOLUME_UP:   //音量键+
             case KeyEvent.KEYCODE_VOLUME_DOWN:   //音量键-
             case KeyEvent.KEYCODE_CAMERA:  //拍照键
             case KeyEvent.KEYCODE_FOCUS:   //拍照键半按的对焦状态
          //   event.getAction() == KeyEvent.ACTION_UP   //Android123提示如果按键按下后弹起时触发
              
            }
                return true; //这些标记为处理过，则不在往内部传递
         default:
                break;
        }
        return super.dispatchKeyEvent(event);
    }

对于游戏突然来电话我们一般采取通过PhoneStateListener类提供的public void onCallStateChanged (int state, String incomingNumber) 回调方法可以获取电话的状态，比如常规空闲时CALL_STATE_IDLE、来电时
CALL_STATE_RINGING和 CALL_STATE_OFFHOOK 摘机通话中，有关处理的细节网友可以查看Android Git项目中的Music，在Android开源项目中系统自带的音乐播放器可以很好的处理，比如在通话结束后恢复音乐播放，而我们游戏需要做的就是记住当前的游戏状态尽量数据持久化处理，不能因为长时间的通话，游戏的Activity被清理了，这里我们一般通过onSaveInstanceState来保存当前窗口的一些记录，通过Intent标记来让系统管理好我们游戏的生命周期。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/JavaTiger427/archive/2010/11/25/6034653.aspx

view plaincopy to clipboardprint?
public static final int CWJ_UP = 0;  
public static final int CWJ_DOWN = 1;  
public static final int CWJ_LEFT = 2;  
public static final int CWJ_RIGHT = 4;  
public static final int CWJ_FORWARD = 8; //向前  
public static final int CWJ_BACKWARD = 16; //向后 
public static final int CWJ_UP = 0;
public static final int CWJ_DOWN = 1;
public static final int CWJ_LEFT = 2;
public static final int CWJ_RIGHT = 4;
public static final int CWJ_FORWARD = 8; //向前
public static final int CWJ_BACKWARD = 16; //向后

下面我们做精确的角度旋转修正值定义，我们用到yaw、pitch和roll，相信学过3D开发的网友不会对这些陌生的，我们就把他们对应为绕y、x、z 轴的角度好了，如果你们没有学过3D相关的知识这里Android开发网推荐大家可以通过Cube例子 自定义Render来观察这三个值对应立方体的旋转角度。
Yaw在(0,0,0)中， 以xOz的坐标平面中围绕y轴旋转，如果是负角则我们定义为CWJ_YAW_LEFT 即往左边倾斜，同理我们定义如下:

view plaincopy to clipboardprint?
public static final int CWJ_YAW_LEFT = 0;  
public static final int CWJ_YAW_RIGHT = 1;  
public static final int CWJ_PITCH_UP = 2;  
public static final int CWJ_PITCH_DOWN = 4;  
public static final int CWJ_ROLL_LEFT = 8;  
public static final int CWJ_ROLL_RIGHT = 16; 
public static final int CWJ_YAW_LEFT = 0;
public static final int CWJ_YAW_RIGHT = 1;
public static final int CWJ_PITCH_UP = 2;
public static final int CWJ_PITCH_DOWN = 4;
public static final int CWJ_ROLL_LEFT = 8;
public static final int CWJ_ROLL_RIGHT = 16;

我们通过加速感应器可以获得SensorEvent的四个值，今天Android123给大家一个简单示例，不考虑其他因素，在public int accuracy 、public Sensor sensor 、public long timestamp  和  public final float[] values 中，我们获取values的浮点数组来判断方向。

view plaincopy to clipboardprint?
int nAndroid123=CWJ_UP //向上  
float ax = values[0];  
float ay = values[1];  
float az = values[2];  
 
float absx = Math.abs(ax);  
float absy = Math.abs(ay);  
float absz = Math.abs(az);  
    
if (absx > absy && absx > absz) {  
if (ax > 0) {  
  nAndroid123 = CWJ_RIGHT;  
} else {  
  nAndroid123 = CWJ_LEFT;  
}  
} else if (absy > absx && absy > absz) {  
 
if (ay > 0) {  
nAndroid123= CWJ_FORWARD;  
} else {  
nAndroid123= CWJ_BACKWARD;  
}  
} else if (absz > absx && absz > absy) {  
if (az > 0) {  
  nAndroid123 = CWJ_UP;  
} else {  
  nAndroid123 = CWJ_DOWN;  
}  
} else {  
nAndroid123 = CWJ_UNKNOWN;  
} 
      int nAndroid123=CWJ_UP //向上
      float ax = values[0];
      float ay = values[1];
      float az = values[2];
     
      float absx = Math.abs(ax);
      float absy = Math.abs(ay);
      float absz = Math.abs(az);
       
      if (absx > absy && absx > absz) {
      if (ax > 0) {
        nAndroid123 = CWJ_RIGHT;
      } else {
        nAndroid123 = CWJ_LEFT;
      }
      } else if (absy > absx && absy > absz) {
   
      if (ay > 0) {
      nAndroid123= CWJ_FORWARD;
      } else {
      nAndroid123= CWJ_BACKWARD;
      }
      } else if (absz > absx && absz > absy) {
      if (az > 0) {
        nAndroid123 = CWJ_UP;
      } else {
        nAndroid123 = CWJ_DOWN;
      }
      } else {
      nAndroid123 = CWJ_UNKNOWN;
      }

有关偏向角度问题，我们将在下一次详细讲述，对于一般的2D游戏，我们可以参考本文来实现重力控制，所以总体来说Android游戏开发比较简单易懂，Android平台使用的Java 语言还是很适合做游戏的。在逻辑表达上更清晰。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/JavaTiger427/archive/2010/11/25/6034640.aspx