创建与删除数据库

封装一个类去继承SQLiteOpenHelper  在构造函数中传入数据库名称与数据库版本号，数据库被创建的时候会调用onCreate(SQLiteDatabase db) 方法，数据库版本号发生改变的时候会调用onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)方法，可以方便的对软件游戏升级后做出相应处理避免覆盖安装数据库发生改变产生的错误。调用SQLiteOpenHelper  的getReadableDatabase()方法去创建数据库，如果数据库不存在则创建 并且返回SQLiteDatabase对象，如果数据库存在则不创建只返回SQLiteDatabase对象。调用deleteDatabase(DATABASE_NAME)方法 传入数据库名称则可删除数据库。

封装了一个DatabaseHelper类继承SQLiteOpenHelper 我使用了设计模式中的单例模式来处理这个类，这里说一下单例模式 单例模式是常见的代码设计模式之一 它的好处是在于避免在内存中频繁的实例化所以将它的对象写成static 静态 这样它的对象就只有一份存在静态内存区使用的时候只须要通过getInstance()就可以直接拿到这个静态对象。
 
public class DatabaseHelper extends SQLiteOpenHelper {  
    private static DatabaseHelper mInstance = null;  
  
    /** 数据库名称 **/  
    public static final String DATABASE_NAME = "xys.db";  
  
    /** 数据库版本号 **/  
    private static final int DATABASE_VERSION = 1;  
  
    /**数据库SQL语句 添加一个表**/  
    private static final String NAME_TABLE_CREATE = "create table test("  
        + "_id INTEGER PRIMARY KEY AUTOINCREMENT," + "name TEXT,"+"hp INTEGER DEFAULT 100,"+ "mp INTEGER DEFAULT 100,"  
        + "number INTEGER);";  
  
    DatabaseHelper(Context context) {  
    super(context, DATABASE_NAME, null, DATABASE_VERSION);  
    }  
      
     /**单例模式**/  
    static synchronized DatabaseHelper getInstance(Context context) {  
    if (mInstance == null) {  
        mInstance = new DatabaseHelper(context);  
    }  
    return mInstance;  
    }  
  
    @Override  
    public void onCreate(SQLiteDatabase db) {  
    /**向数据中添加表**/  
    db.execSQL(NAME_TABLE_CREATE);  
    }  
  
    @Override  
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {  
    /**可以拿到当前数据库的版本信息 与之前数据库的版本信息   用来更新数据库**/   
    }  
  
      
    /** 
     * 删除数据库 
     * @param context 
     * @return 
     */  
    public boolean deleteDatabase(Context context) {  
    return context.deleteDatabase(DATABASE_NAME);  
    }  

在这个类中使用DatabaseHelper对象 实现创建与删除数据库、
 
public class NewSQLite extends Activity {  
    DatabaseHelper mDbHelper = null;  
    SQLiteDatabase mDb = null;  
    Context mContext = null;  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
    setContentView(R.layout.create_sql);  
    mContext = this;  
    //创建DatabaseHelper对象         
    mDbHelper = DatabaseHelper.getInstance(mContext);  
    //调用getReadableDatabase方法如果数据库不存在 则创建  如果存在则打开   
    mDb= mDbHelper.getReadableDatabase();    
  
    Button button0 = (Button)findViewById(R.id.createDateBase);  
    button0.setOnClickListener(new OnClickListener() {  
          
        @Override  
        public void onClick(View arg0) {  
  
        Toast.makeText(NewSQLite.this, "成功创建数据库", Toast.LENGTH_LONG).show();    
        }  
    });  
    Button button1 = (Button)findViewById(R.id.deleteDateBase);  
    button1.setOnClickListener(new OnClickListener() {  
          
        @Override  
        public void onClick(View arg0) {  
        mDbHelper = DatabaseHelper.getInstance(mContext);  
        // 调用getReadableDatabase方法如果数据库不存在 则创建 如果存在则打开   
        mDb = mDbHelper.getReadableDatabase();  
        // 关闭数据库   
        mDbHelper.close();  
        // 删除数据库   
        mDbHelper.deleteDatabase(mContext);  
        Toast.makeText(NewSQLite.this, "成功删除数据库", Toast.LENGTH_LONG).show();    
        }  
    });  
      
      
      
    super.onCreate(savedInstanceState);  
    }  
  
} 
创建的数据库会被保存在当前项目中 databases 路径下 具体如图所示

添加与删除数据库中的表

        数据库是可以由多张数据表组成的 如果添加一张数据库的表的话 可以使用 数据库语句 create table 名称(内容) 来进行添加 。这里给出一条创建数据库的语句 。 意思是创建一张表 名称为gameInfo 表中包含的字段 为     _id  为INTEGER 类型 并且递增  name 为Text类型   hp mp 为INTEGER 默认数值为100 number 为INTEGER 类型。

 
/**创建一张表的SQL语句**/  
private static final String NAME_TABLE_CREATE = "create table gameInfo("  
 + "_id INTEGER PRIMARY KEY AUTOINCREMENT," + "name TEXT,"+ "hp INTEGER DEFAULT 100,"+ "mp INTEGER DEFAULT 100,"  
 + "number INTEGER);"; 
数据库中删除一张表 直接使用DROP TABLE  表名称 就可以删除
 
/**删除一张表的SQL语句**/  
private static final String NAME_TABLE_DELETE = "DROP TABLE gameInfo"; 
在代码中去执行一条SQL语句 使用SQLiteDatabase对象去调用execSQL() 传入SQL语句就OK了。

 
mDb.execSQL(NAME_TABLE_CREATE); 

以创建一张名称为gameInfo的表为例 给出代码实现
 
public class NewTable extends Activity {  
    DatabaseHelper mDbHelper = null;  
    SQLiteDatabase mDb = null;  
    Context mContext = null;  
    
    /**创建一张表的SQL语句**/  
    private static final String NAME_TABLE_CREATE = "create table gameInfo("  
        + "_id INTEGER PRIMARY KEY AUTOINCREMENT," + "name TEXT,"+ "hp INTEGER DEFAULT 100,"+ "mp INTEGER DEFAULT 100,"  
        + "number INTEGER);";  
      
      
    /**删除一张表的SQL语句**/  
    private static final String NAME_TABLE_DELETE = "DROP TABLE gameInfo";  
      
      
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
    setContentView(R.layout.create_table);  
    mContext = this;  
    mDbHelper = DatabaseHelper.getInstance(mContext);  
    mDb= mDbHelper.getReadableDatabase();    
      
    Button button0 = (Button)findViewById(R.id.createTable);  
    button0.setOnClickListener(new OnClickListener() {  
          
        @Override  
        public void onClick(View arg0) {  
        try {  
            mDb.execSQL(NAME_TABLE_CREATE);  
            Toast.makeText(NewTable.this, "成功添加数据表", Toast.LENGTH_LONG).show();    
        }catch(SQLiteException e) {  
            Toast.makeText(NewTable.this, "数据库中已存此表", Toast.LENGTH_LONG).show();      
        }  
        }  
    });  
    Button button1 = (Button)findViewById(R.id.deleteTable);  
    button1.setOnClickListener(new OnClickListener() {  
          
        @Override  
        public void onClick(View arg0) {  
        try {  
            mDb.execSQL(NAME_TABLE_DELETE);  
            Toast.makeText(NewTable.this, "成功删除数据表", Toast.LENGTH_LONG).show();   
        }catch(SQLiteException e) {  
            Toast.makeText(NewTable.this, "数据库中已无此表", Toast.LENGTH_LONG).show();      
        }  
  
        }  
    });  
      
      
      
    super.onCreate(savedInstanceState);  
    }  
  
} 

增加 删除 修改 查询 数据库中的数据

使用SQLiteDatabase对象调用 insert()方法 传入标的名称与ContentValues 添加的内容 则可以向数据库表中写入一条数据 delete ()为删除一条数据 update()为更新一条数据。

我详细说一下查找一条数据使用的方法 query 中 跟了8个参数

public Cursor query(String table,String[] columns,String selection,String[] selectionArgs,String groupBy,String having,String orderBy,String limit);

参数说明：

table:数据库表的名称

columns:数据库列名称数组 写入后最后返回的Cursor中只能查到这里的列的内容

selection:查询条件

selectionArgs:查询结果

groupBy:分组列

having:分组条件

orderBy:排序列

limit:分页查询限制

Cursor:返回值，将查询到的结果都存在Cursor

Cursor是一个游标接口，每次查询的结果都会保存在Cursor中 可以通过遍历Cursor的方法拿到当前查询到的所有信息。

Cursor的方法

moveToFirst() //将Curor的游标移动到第一条
moveToLast()///将Curor的游标移动到最后一条
move(int offset)//将Curor的游标移动到指定ID
moveToNext()//将Curor的游标移动到下一条
moveToPrevious()//将Curor的游标移动到上一条
getCount() //得到Cursor 总记录条数
isFirst() //判断当前游标是否为第一条记录
isLast()//判断当前游标是否为最后一条数据
getInt(int columnIndex)    //根据列名称获得列索引ID
getString(int columnIndex)//根据索引ID 拿到表中存的字段

这里给出一个例子遍历Cursor的例子
 
   private void query(SQLiteDatabase db) {  
// 把整张表的所有数据query到cursor中   
Cursor cursor = db.query(TABLE_NAME, null, null, null, null, null, null);  
//判断cursor不为空 这个很重要   
if (cursor != null) {  
    // 循环遍历cursor   
    while (cursor.moveToNext()) {  
    // 拿到每一行name 与hp的数值   
    String name = cursor.getString(cursor.getColumnIndex("name"));  
    String hp = cursor.getString(cursor.getColumnIndex("hp"));  
    Log.v("info", "姓名是 " + name + "hp为 " + hp);  
    }  
    // 关闭   
    cursor.close();  
}  
   } 

向大家推荐一个查看数据库的软件非常好用, 名称是SQLiteSpy.exe  如图所示 打开xys.db 文件 可以清晰的看见数据库表中储存的内容并且该软件支持执行SQL语句 可以直接在软件中操作，我给出这款软件的下载地址。看本文最后的下载地址

 
public class Newdate extends Activity {  
    DatabaseHelper mDbHelper = null;  
    SQLiteDatabase mDb = null;  
    Context mContext = null;  
  
    /** 数据库字段 **/  
  
    public final static String TABLE_NAME = "test";  
    public final static String ID = "_id";  
    public final static String NAME = "name";  
    public final static String HP = "hp";  
    public final static String MP = "mp";  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
    setContentView(R.layout.create_date);  
    mContext = this;  
    // 创建DatabaseHelper对象   
    mDbHelper = DatabaseHelper.getInstance(mContext);  
    // 调用getReadableDatabase方法如果数据库不存在 则创建 如果存在则打开   
    mDb = mDbHelper.getReadableDatabase();  
    // 初始化 给数据库表写入一些信息   
    for (int i = 0; i < 10; i++) {  
        insert(NAME, "雨松MOMO" + i);  
    }  
  
    // 增加   
    Button button0 = (Button) findViewById(R.id.add);  
    button0.setOnClickListener(new OnClickListener() {  
  
        @Override  
        public void onClick(View arg0) {  
        insert(NAME, "新添加小可爱");  
        Toast.makeText(Newdate.this, "添加一条数据名称为小可爱", Toast.LENGTH_LONG)  
            .show();  
        }  
    });  
    // 删除   
    Button button1 = (Button) findViewById(R.id.delete);  
    button1.setOnClickListener(new OnClickListener() {  
  
        @Override  
        public void onClick(View arg0) {  
        delete(ID, "1");  
        Toast.makeText(Newdate.this, "删除一条_id=1的数据", Toast.LENGTH_LONG)  
            .show();  
        }  
    });  
    // 修改   
    Button button2 = (Button) findViewById(R.id.modify);  
    button2.setOnClickListener(new OnClickListener() {  
  
        @Override  
        public void onClick(View arg0) {  
        update(NAME, "雨松MOMO3", "小可爱3");  
        Toast.makeText(Newdate.this, "更新名称雨松MOMO3 为小可爱3",  
            Toast.LENGTH_LONG).show();  
        }  
    });  
    // 查找   
    Button button3 = (Button) findViewById(R.id.find);  
    button3.setOnClickListener(new OnClickListener() {  
  
        @Override  
        public void onClick(View arg0) {  
        Cursor cursor = find(ID, "5");  
        String name = cursor.getString(cursor.getColumnIndex(NAME));  
        Toast.makeText(Newdate.this, "查找ID为5数据的名称是 " + name,  
            Toast.LENGTH_LONG).show();  
        }  
    });  
    super.onCreate(savedInstanceState);  
    }  
  
    /** 
     * 插入一条数据 
     *  
     * @param key 
     * @param date 
     */  
    public void insert(String key, String date) {  
    ContentValues values = new ContentValues();  
    values.put(key, date);  
    mDb.insert(TABLE_NAME, null, values);  
    }  
  
    /** 
     * 删除一掉数据 
     *  
     * @param key 
     * @param date 
     */  
    public void delete(String key, String date) {  
    mDb.delete(TABLE_NAME, key + "=?", new String[] { date });  
    }  
  
    /** 
     * 更新一条数据 
     *  
     * @param key 
     * @param oldDate 
     * @param newDate 
     */  
    public void update(String key, String oldDate, String newDate) {  
    ContentValues values = new ContentValues();  
    values.put(key, newDate);  
    mDb.update(TABLE_NAME, values, key + "=?", new String[] { oldDate });  
    }  
  
    /** 
     * 查找一条数据 
     *  
     * @param key 
     * @param date 
     * @return 
     */  
    public Cursor find(String key, String date) {  
  
    Cursor cursor = mDb.query(TABLE_NAME, null, key + "=?",  
        new String[] { date }, null, null, null);  
    if (cursor != null) {  
        cursor.moveToFirst();  
    }  
    return cursor;  
    }  
  
} 
 

最后如果你还是觉得我写的不够详细 看的不够爽 不要紧我把源代码的下载地址贴出来

免费下载地址在 http://linux.linuxidc.com/

用户名与密码都是www.linuxidc.com

具体下载目录在 /2011年资料/Android入门教程/Android游戏开发之数据库SQLite 详细介绍/

本篇文章来源于 Linux公社网站(www.linuxidc.com)  原文链接：http://www.linuxidc.com/Linux/2011-08/40540p3.htm

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

未来Android123将完成主要是一个基于OpenGL 3D的雷电游戏，最终加入联网对战效果 可以团队打怪实现手机3D网游充分发挥Android手机的娱乐能力。对于大多数新款Android手机可能没有配备轨迹球或导航键的方向控制，所以重力感应器是这类实时性较强游戏的首选控制方式。主要有以下几点问题对于Sensor

1. 降噪处理，如果做过LBS软件 的大家可能明白偏移修正，在GPS无法正常获取数据较间断时地图不能乱飘，这里Sensor也不例外，除了使用采样数据平均值获取外，可以间隔采样的方法来处理。细节的算法我们将在下节给出示例代码 。

2. 感应器的敏感度，在Android中提供了四种延迟级别分别为

SENSOR_DELAY_FASTEST 最低延迟，一般不是特别敏感的处理不推荐 使用，该种模式可能造成手机电力大量消耗，由于传递的为原始数据，算法不处理好将会影响游戏逻辑和UI的性能，所以Android开发网不推荐大家使用。

SENSOR_DELAY_GAME 游戏延迟，一般绝大多数的实时性较高的游戏都使用该级别。
int SENSOR_DELAY_NORMAL 标准延迟，对于一般的益智类或EASY级别的游戏可以使用，但过低的采样率可能对一些赛车类游戏有跳帧现象。
int SENSOR_DELAY_UI 用户界面 延迟，一般对于屏幕 方向自动 旋转使用，相对节省电能和逻辑处理，一般游戏开发中我们不使用。

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

很多网友发现Android中手势识别提供了两个类，由于Android 1.6以下的版本比如cupcake中无法使用android .view.GestureDetector，而 android.gesture.Gesture是Android 1.6才开始支持的，我们考虑到仍然有很多Android 1.5固件的网友，就来看下兼容性更强的android.view.GestureDetector。在 android.view.GestureDetector类中有很多种重载版本，下面我们仅提到能够自定义 在View 中的两种方法，分别为 GestureDetector(Context context, GestureDetector.OnGestureListener listener) 和 GestureDetector(Context context, GestureDetector.OnGestureListener listener, Handler handler) 和。我们可以看到第一个参数为Context，所以我们想附着到某View时，最简单的方法就是直接从超类派生传递Context，实现 GestureDetector里中提供一些接口。

下面我们就以实现手势识别的onFling动作，在CwjView中我们从View类继承，当然大家可以从TextView 等更高层的界面 中实现触控。

view plaincopy to clipboardprint?
class CwjView extends View {  
    private GestureDetector mGD;  
    public CwjView(Context context, AttributeSet attrs) {  
        super(context, attrs);  
      
        mGD = new GestureDetector(context, new GestureDetector.SimpleOnGestureListener() {  
                public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {  
                    int dx = (int) (e2.getX() - e1.getX()); //计算滑动的距离  
                    if (Math.abs(dx) > MAJOR_MOVE && Math.abs(velocityX) > Math.abs(velocityY)) { //降噪处理，必须有较大的动作才识别  
                        if (velocityX > 0) {  
                          //向右边  
                        } else {  
                            //向左边  
                        }  
                        return true;  
                    } else {  
                        return false;  //当然可以处理velocityY处理向上和向下的动作  
                    }  
                }  
            });  
    } 
class CwjView extends View {
    private GestureDetector mGD;
    public CwjView(Context context, AttributeSet attrs) {
        super(context, attrs);
   
        mGD = new GestureDetector(context, new GestureDetector.SimpleOnGestureListener() {
                public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
                    int dx = (int) (e2.getX() - e1.getX()); //计算滑动的距离
                    if (Math.abs(dx) > MAJOR_MOVE && Math.abs(velocityX) > Math.abs(velocityY)) { //降噪处理，必须有较大的动作才识别
                        if (velocityX > 0) {
                          //向右边
                        } else {
                            //向左边
                        }
                        return true;
                    } else {
                        return false;  //当然可以处理velocityY处理向上和向下的动作
                    }
                }
            });
    }

在上面Android123提示大家仅仅探测了Fling动作仅仅实现了onFling方法，这里相关的还有以下几种方法来实现具体的可以参考我们以前的文章有详细的解释:

view plaincopy to clipboardprint?
   
boolean  onDoubleTap(MotionEvent e)  
boolean  onDoubleTapEvent(MotionEvent e)   
boolean  onDown(MotionEvent e)   
void  onLongPress(MotionEvent e)   
boolean  onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)   
void  onShowPress(MotionEvent e)   
boolean  onSingleTapConfirmed(MotionEvent e)   
boolean  onSingleTapUp(MotionEvent e)  
 
boolean  onDoubleTap(MotionEvent e)
boolean  onDoubleTapEvent(MotionEvent e)
boolean  onDown(MotionEvent e)
void  onLongPress(MotionEvent e)
boolean  onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)
void  onShowPress(MotionEvent e)
boolean  onSingleTapConfirmed(MotionEvent e)
boolean  onSingleTapUp(MotionEvent e) 

接下来是重点，让我们的View接受触控，需要使用下面两个方法让GestureDetector类去处理onTouchEvent和 onInterceptTouchEvent方法。

view plaincopy to clipboardprint?
@Override 
public boolean onTouchEvent(MotionEvent event) {   
    mGD.onTouchEvent(event);  
    return true;  
}  
@Override 
public boolean onInterceptTouchEvent(MotionEvent event) {  
    return mGD.onTouchEvent(event);  
}  

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

view plaincopy to clipboardprint?
public class VideoView extends SurfaceView implements MediaPlayerControl {  
  private String TAG = "VideoView";  
  // settable by the client  
  private Uri        mUri;  
  private int        mDuration;  
  // all possible internal states  
  private static final int STATE_ERROR              = -1;  
  private static final int STATE_IDLE              = 0;  
  private static final int STATE_PREPARING          = 1;  
  private static final int STATE_PREPARED          = 2;  
  private static final int STATE_PLAYING            = 3;  
  private static final int STATE_PAUSED            = 4;  
  private static final int STATE_PLAYBACK_COMPLETED = 5;  
  // mCurrentState is a VideoView object's current state.  
  // mTargetState is the state that a method caller intends to reach.  
  // For instance, regardless the VideoView object's current state,  
  // calling pause() intends to bring the object to a target state  
  // of STATE_PAUSED.  
  private int mCurrentState = STATE_IDLE;  
  private int mTargetState  = STATE_IDLE;  
  // All the stuff we need for playing and showing a video  
  private SurfaceHolder mSurfaceHolder = null;  
  private MediaPlayer mMediaPlayer = null;  
  private int        mVideoWidth;  
  private int        mVideoHeight;  
  private int        mSurfaceWidth;  
  private int        mSurfaceHeight;  
  private MediaController mMediaController;  
  private OnCompletionListener mOnCompletionListener;  
  private MediaPlayer.OnPreparedListener mOnPreparedListener;  
  private int        mCurrentBufferPercentage;  
  private OnErrorListener mOnErrorListener;  
  private int        mSeekWhenPrepared;  // recording the seek position while preparing  
  private boolean    mCanPause;  
  private boolean    mCanSeekBack;  
  private boolean    mCanSeekForward;  
  public VideoView(Context context) {  
      super(context);  
      initVideoView();  
  }  
 
  public VideoView(Context context, AttributeSet attrs) {  
      this(context, attrs, 0);  
      initVideoView();  
  }  
 
  public VideoView(Context context, AttributeSet attrs, int defStyle) {  
      super(context, attrs, defStyle);  
      initVideoView();  
  }  
  @Override 
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
      //Log.i("@@@@", "onMeasure");  
      int width = getDefaultSize(mVideoWidth, widthMeasureSpec);  
      int height = getDefaultSize(mVideoHeight, heightMeasureSpec);  
      if (mVideoWidth > 0 && mVideoHeight > 0) {  
          if ( mVideoWidth * height  > width * mVideoHeight ) {  
              //Log.i("@@@", "image too tall, correcting");  
              height = width * mVideoHeight / mVideoWidth;  
          } else if ( mVideoWidth * height  < width * mVideoHeight ) {  
              //Log.i("@@@", "image too wide, correcting");  
              width = height * mVideoWidth / mVideoHeight;  
          } else {  
              //Log.i("@@@", "aspect ratio is correct: " +  
                      //width+"/"+height+"="+  
                      //mVideoWidth+"/"+mVideoHeight);  
          }  
      }  
      //Log.i("@@@@@@@@@@", "setting size: " + width + 'x' + height);  
      setMeasuredDimension(width, height);  
  }  
 
  public int resolveAdjustedSize(int desiredSize, int measureSpec) {  
      int result = desiredSize;  
      int specMode = MeasureSpec.getMode(measureSpec);  
      int specSize =  MeasureSpec.getSize(measureSpec);  
      switch (specMode) {  
          case MeasureSpec.UNSPECIFIED:  
              /* Parent says we can be as big as we want. Just don't be larger 
              * than max size imposed on ourselves. 
              */ 
              result = desiredSize;  
              break;  
          case MeasureSpec.AT_MOST:  
              /* Parent says we can be as big as we want, up to specSize. 
              * Don't be larger than specSize, and don't be larger than 
              * the max size imposed on ourselves. 
              */ 
              result = Math.min(desiredSize, specSize);  
              break;  
              
          case MeasureSpec.EXACTLY:  
              // No choice. Do what we are told.  
              result = specSize;  
              break;  
      }  
      return result;  

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

view plaincopy to clipboardprint?
public static Bitmap createBitmap (Bitmap source, int x, int y, int width, int height, Matrix m, boolean filter) 
public static Bitmap createBitmap (Bitmap source, int x, int y, int width, int height, Matrix m, boolean filter)

参数的具体意思
source 源 bitmap对象
x  源坐标x位置
y 源坐标y位置
width  宽度
height  高度
m  接受的maxtrix对象，如果没有可以设置 为null
filter 该参数仅对maxtrix包含了超过一个翻转才有效。

下面Android123给大家一个比较经典的例子 ，rotate方法是静态方法可以直接调用，参数为源Bitmap对象，参数二为旋转的角度，从 0~360，返回值为新的Bitmap对象。其中具体的宽高可以调整。

view plaincopy to clipboardprint?
public static Bitmap rotate(Bitmap b, int degrees) {  
        if (degrees != 0 && b != null) {  
            Matrix m = new Matrix();  
            m.setRotate(degrees,  
                    (float) b.getWidth() / 2, (float) b.getHeight() / 2);  
            try {  
                Bitmap b2 = Bitmap.createBitmap(  
                        b, 0, 0, b.getWidth(), b.getHeight(), m, true);  
                if (b != b2) {  
                    b.recycle();  //Android开发网再次提示Bitmap操作完应该显示的释放  
                    b = b2;  
                }  
            } catch (OutOfMemoryError ex) {  
                // Android123建议大家如何出现了内存不足异常，最好return 原始的bitmap对象。.  
            }  
        }  
        return b;  
    } 
public static Bitmap rotate(Bitmap b, int degrees) {
        if (degrees != 0 && b != null) {
            Matrix m = new Matrix();
            m.setRotate(degrees,
                    (float) b.getWidth() / 2, (float) b.getHeight() / 2);
            try {
                Bitmap b2 = Bitmap.createBitmap(
                        b, 0, 0, b.getWidth(), b.getHeight(), m, true);
                if (b != b2) {
                    b.recycle();  //Android开发网再次提示Bitmap操作完应该显示的释放
                    b = b2;
                }
            } catch (OutOfMemoryError ex) {
                // Android123建议大家如何出现了内存不足异常，最好return 原始的bitmap对象。.
            }
        }
        return b;
    }

补充一点吧：水平翻转
view plaincopy to clipboardprint?
public static Bitmap rotate(Bitmap b, int degrees) {  
        if (degrees != 0 && b != null) {  
            Matrix m = new Matrix();  
            m.postScale(1, -1);  
            m.setRotate(degrees,  
                    (float) b.getWidth() / 2, (float) b.getHeight() / 2);  
            try {  
                Bitmap b2 = Bitmap.createBitmap(  
                        b, 0, 0, b.getWidth(), b.getHeight(), m, true);  
                if (b != b2) {  
                    b.recycle();  //Android开发网再次提示Bitmap操作完应该显示的释放  
                    b = b2;  
                }  
            } catch (OutOfMemoryError ex) {  
                // Android123建议大家如何出现了内存不足异常，最好return 原始的bitmap对象。.  
            }  
        }  
        return b;  
    } 

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

view plaincopy to clipboardprint?
class LunarView extends SurfaceView implements SurfaceHolder.Callback {  
    class LunarThread extends Thread {  
        /* 
        * Difficulty setting constants 
        */ 
        public static final int DIFFICULTY_EASY = 0;  
        public static final int DIFFICULTY_HARD = 1;  
        public static final int DIFFICULTY_MEDIUM = 2;  
        /* 
        * Physics constants 
        */ 
        public static final int PHYS_DOWN_ACCEL_SEC = 35;  
        public static final int PHYS_FIRE_ACCEL_SEC = 80;  
        public static final int PHYS_FUEL_INIT = 60;  
        public static final int PHYS_FUEL_MAX = 100;  
        public static final int PHYS_FUEL_SEC = 10;  
        public static final int PHYS_SLEW_SEC = 120; // degrees/second rotate  
        public static final int PHYS_SPEED_HYPERSPACE = 180;  
        public static final int PHYS_SPEED_INIT = 30;  
        public static final int PHYS_SPEED_MAX = 120;  
        /* 
        * State-tracking constants 
        */ 
        public static final int STATE_LOSE = 1;  
        public static final int STATE_PAUSE = 2;  
        public static final int STATE_READY = 3;  
        public static final int STATE_RUNNING = 4;  
        public static final int STATE_WIN = 5;  
        /* 
        * Goal condition constants 
        */ 
        public static final int TARGET_ANGLE = 18; // > this angle means crash  
        public static final int TARGET_BOTTOM_PADDING = 17; // px below gear  
        public static final int TARGET_PAD_HEIGHT = 8; // how high above ground  
        public static final int TARGET_SPEED = 28; // > this speed means crash  
        public static final double TARGET_WIDTH = 1.6; // width of target  
        /* 
        * UI constants (i.e. the speed & fuel bars) 
        */ 
        public static final int UI_BAR = 100; // width of the bar(s)  
        public static final int UI_BAR_HEIGHT = 10; // height of the bar(s)  
        private static final String KEY_DIFFICULTY = "mDifficulty";  
        private static final String KEY_DX = "mDX";  
        private static final String KEY_DY = "mDY";  
        private static final String KEY_FUEL = "mFuel";  
        private static final String KEY_GOAL_ANGLE = "mGoalAngle";  
        private static final String KEY_GOAL_SPEED = "mGoalSpeed";  
        private static final String KEY_GOAL_WIDTH = "mGoalWidth";  
        private static final String KEY_GOAL_X = "mGoalX";  
        private static final String KEY_HEADING = "mHeading";  
        private static final String KEY_LANDER_HEIGHT = "mLanderHeight";  
        private static final String KEY_LANDER_WIDTH = "mLanderWidth";  
        private static final String KEY_WINS = "mWinsInARow";  
        private static final String KEY_X = "mX";  
        private static final String KEY_Y = "mY";  
        /* 
        * Member (state) fields 
        */ 
        /** The drawable to use as the background of the animation canvas */ 
        private Bitmap mBackgroundImage;  
        /** 
        * Current height of the surface/canvas. 
        * 
        * @see #setSurfaceSize 
        */ 
        private int mCanvasHeight = 1;  
        /** 
        * Current width of the surface/canvas. 
        * 
        * @see #setSurfaceSize 
        */ 
        private int mCanvasWidth = 1;  
        /** What to draw for the Lander when it has crashed */ 
        private Drawable mCrashedImage;  
        /** 
        * Current difficulty -- amount of fuel, allowed angle, etc. Default is 
        * MEDIUM. 
        */ 
        private int mDifficulty;  
        /** Velocity dx. */ 
        private double mDX;  
        /** Velocity dy. */ 
        private double mDY;  
        /** Is the engine burning? */ 
        private boolean mEngineFiring;  
        /** What to draw for the Lander when the engine is firing */ 
        private Drawable mFiringImage;  
        /** Fuel remaining */ 
        private double mFuel;  
        /** Allowed angle. */ 
        private int mGoalAngle;  
        /** Allowed speed. */ 
        private int mGoalSpeed;  
        /** Width of the landing pad. */ 
        private int mGoalWidth;  
        /** X of the landing pad. */ 
        private int mGoalX;  
        /** Message handler used by thread to interact with TextView */ 
        private Handler mHandler;  
        /** 
        * Lander heading in degrees, with 0 up, 90 right. Kept in the range 
        * 0..360. 
        */ 
        private double mHeading;  
        /** Pixel height of lander image. */ 
        private int mLanderHeight;  
        /** What to draw for the Lander in its normal state */ 
        private Drawable mLanderImage;  
        /** Pixel width of lander image. */ 
        private int mLanderWidth;  
        /** Used to figure out elapsed time between frames */ 
        private long mLastTime;  
        /** Paint to draw the lines on screen. */ 
        private Paint mLinePaint;  
        /** "Bad" speed-too-high variant of the line color. */ 
        private Paint mLinePaintBad;  
        /** The state of the game. One of READY, RUNNING, PAUSE, LOSE, or WIN */ 
        private int mMode;  
        /** Currently rotating, -1 left, 0 none, 1 right. */ 
        private int mRotating;  
        /** Indicate whether the surface has been created & is ready to draw */ 
        private boolean mRun = false;  
        /** Scratch rect object. */ 
        private RectF mScratchRect;  
        /** Handle to the surface manager object we interact with */ 
        private SurfaceHolder mSurfaceHolder;  
        /** Number of wins in a row. */ 
        private int mWinsInARow;  
        /** X of lander center. */ 
        private double mX;  
        /** Y of lander center. */ 
        private double mY;  
        public LunarThread(SurfaceHolder surfaceHolder, Context context,  
                Handler handler) {  
            // get handles to some important objects  
            mSurfaceHolder = surfaceHolder;  
            mHandler = handler;  
            mContext = context;  
            Resources res = context.getResources();  
            // cache handles to our key sprites & other drawables  
            mLanderImage = context.getResources().getDrawable(  
                    R.drawable.lander_plain);  
            mFiringImage = context.getResources().getDrawable(  
                    R.drawable.lander_firing);  
            mCrashedImage = context.getResources().getDrawable(  
                    R.drawable.lander_crashed);  
            // load background image as a Bitmap instead of a Drawable b/c  
            // we don't need to transform it and it's faster to draw this way  
            mBackgroundImage = BitmapFactory.decodeResource(res,  
                    R.drawable.earthrise);  
            // Use the regular lander image as the model size for all sprites  
            mLanderWidth = mLanderImage.getIntrinsicWidth();  
            mLanderHeight = mLanderImage.getIntrinsicHeight();  
            // Initialize paints for speedometer  
            mLinePaint = new Paint();  
            mLinePaint.setAntiAlias(true);  
            mLinePaint.setARGB(255, 0, 255, 0);  
            mLinePaintBad = new Paint();  
            mLinePaintBad.setAntiAlias(true);  
            mLinePaintBad.setARGB(255, 120, 180, 0);  
            mScratchRect = new RectF(0, 0, 0, 0);  
            mWinsInARow = 0;  
            mDifficulty = DIFFICULTY_MEDIUM;  
            // initial show-up of lander (not yet playing)  
            mX = mLanderWidth;  
            mY = mLanderHeight * 2;  
            mFuel = PHYS_FUEL_INIT;  
            mDX = 0;  
            mDY = 0;  
            mHeading = 0;  
            mEngineFiring = true;  
        }  
        /** 
        * Starts the game, setting parameters for the current difficulty. 
        */ 
        public void doStart() {  
            synchronized (mSurfaceHolder) {  
                // First set the game for Medium difficulty  
                mFuel = PHYS_FUEL_INIT;  
                mEngineFiring = false;  
                mGoalWidth = (int) (mLanderWidth * TARGET_WIDTH);  
                mGoalSpeed = TARGET_SPEED;  
                mGoalAngle = TARGET_ANGLE;  
                int speedInit = PHYS_SPEED_INIT;  
                // Adjust difficulty params for EASY/HARD  
                if (mDifficulty == DIFFICULTY_EASY) {  
                    mFuel = mFuel * 3 / 2;  
                    mGoalWidth = mGoalWidth * 4 / 3;  
                    mGoalSpeed = mGoalSpeed * 3 / 2;  
                    mGoalAngle = mGoalAngle * 4 / 3;  
                    speedInit = speedInit * 3 / 4;  
                } else if (mDifficulty == DIFFICULTY_HARD) {  
                    mFuel = mFuel * 7 / 8;  
                    mGoalWidth = mGoalWidth * 3 / 4;  
                    mGoalSpeed = mGoalSpeed * 7 / 8;  
                    speedInit = speedInit * 4 / 3;  
                }  
                // pick a convenient initial location for the lander sprite  
                mX = mCanvasWidth / 2;  
                mY = mCanvasHeight - mLanderHeight / 2;  
                // start with a little random motion  
                mDY = Math.random() * -speedInit;  
                mDX = Math.random() * 2 * speedInit - speedInit;  
                mHeading = 0;  
                // Figure initial spot for landing, not too near center  
                while (true) {  
                    mGoalX = (int) (Math.random() * (mCanvasWidth - mGoalWidth));  
                    if (Math.abs(mGoalX - (mX - mLanderWidth / 2)) > mCanvasHeight / 6)  
                        break;  
                }  
                mLastTime = System.currentTimeMillis() + 100;  
                setState(STATE_RUNNING);  
            }  
        }  
        /** 
        * Pauses the physics update & animation. 
        */ 
        public void pause() {  
            synchronized (mSurfaceHolder) {  
                if (mMode == STATE_RUNNING) setState(STATE_PAUSE);  
            }  
        }  
        /** 
        * Restores game state from the indicated Bundle. Typically called when 
        * the Activity is being restored after having been previously 
        * destroyed. 
        * 
        * @param savedState Bundle containing the game state 
        */ 
        public synchronized void restoreState(Bundle savedState) {  
            synchronized (mSurfaceHolder) {  
                setState(STATE_PAUSE);  
                mRotating = 0;  
                mEngineFiring = false;  
                mDifficulty = savedState.getInt(KEY_DIFFICULTY);  
                mX = savedState.getDouble(KEY_X);  
                mY = savedState.getDouble(KEY_Y);  
                mDX = savedState.getDouble(KEY_DX);  
                mDY = savedState.getDouble(KEY_DY);  
                mHeading = savedState.getDouble(KEY_HEADING);  
                mLanderWidth = savedState.getInt(KEY_LANDER_WIDTH);  
                mLanderHeight = savedState.getInt(KEY_LANDER_HEIGHT);  
                mGoalX = savedState.getInt(KEY_GOAL_X);  
                mGoalSpeed = savedState.getInt(KEY_GOAL_SPEED);  
                mGoalAngle = savedState.getInt(KEY_GOAL_ANGLE);  
                mGoalWidth = savedState.getInt(KEY_GOAL_WIDTH);  
                mWinsInARow = savedState.getInt(KEY_WINS);  
                mFuel = savedState.getDouble(KEY_FUEL);  
            }  
        }  
        @Override 
        public void run() {  
            while (mRun) {  
                Canvas c = null;  
                try {  
                    c = mSurfaceHolder.lockCanvas(null);  
                    synchronized (mSurfaceHolder) {  
                        if (mMode == STATE_RUNNING) updatePhysics();  
                        doDraw(c);  
                    }  
                } finally {  
                    // do this in a finally so that if an exception is thrown  
                    // during the above, we don't leave the Surface in an  
                    // inconsistent state  
                    if (c != null) {  
                        mSurfaceHolder.unlockCanvasAndPost(c);  
                    }  
                }  
            }  
        }  
        /** 
        * Dump game state to the provided Bundle. Typically called when the 
        * Activity is being suspended. 
        * 
        * @return Bundle with this view's state 
        */ 
        public Bundle saveState(Bundle map) {  
            synchronized (mSurfaceHolder) {  
                if (map != null) {  
                    map.putInt(KEY_DIFFICULTY, Integer.valueOf(mDifficulty));  
                    map.putDouble(KEY_X, Double.valueOf(mX));  
                    map.putDouble(KEY_Y, Double.valueOf(mY));  
                    map.putDouble(KEY_DX, Double.valueOf(mDX));  
                    map.putDouble(KEY_DY, Double.valueOf(mDY));  
                    map.putDouble(KEY_HEADING, Double.valueOf(mHeading));  
                    map.putInt(KEY_LANDER_WIDTH, Integer.valueOf(mLanderWidth));  
                    map.putInt(KEY_LANDER_HEIGHT, Integer  
                            .valueOf(mLanderHeight));  
                    map.putInt(KEY_GOAL_X, Integer.valueOf(mGoalX));  
                    map.putInt(KEY_GOAL_SPEED, Integer.valueOf(mGoalSpeed));  
                    map.putInt(KEY_GOAL_ANGLE, Integer.valueOf(mGoalAngle));  
                    map.putInt(KEY_GOAL_WIDTH, Integer.valueOf(mGoalWidth));  
                    map.putInt(KEY_WINS, Integer.valueOf(mWinsInARow));  
                    map.putDouble(KEY_FUEL, Double.valueOf(mFuel));  
                }  
            }  
            return map;  
        }  
        /** 
        * Sets the current difficulty. 
        * 
        * @param difficulty 
        */ 
        public void setDifficulty(int difficulty) {  
            synchronized (mSurfaceHolder) {  
                mDifficulty = difficulty;  
            }  
        }  
        /** 
        * Sets if the engine is currently firing. 
        */ 
        public void setFiring(boolean firing) {  
            synchronized (mSurfaceHolder) {  
                mEngineFiring = firing;  
            }  
        }  
        /** 
        * Used to signal the thread whether it should be running or not. 
        * Passing true allows the thread to run; passing false will shut it 
        * down if it's already running. Calling start() after this was most 
        * recently called with false will result in an immediate shutdown. 
        * 
        * @param b true to run, false to shut down 
        */ 
        public void setRunning(boolean b) {  
            mRun = b;  
        }  
        /** 
        * Sets the game mode. That is, whether we are running, paused, in the 
        * failure state, in the victory state, etc. 
        * 
        * @see #setState(int, CharSequence) 
        * @param mode one of the STATE_* constants 
        */ 
        public void setState(int mode) {  
            synchronized (mSurfaceHolder) {  
                setState(mode, null);  
            }  
        }  
        /** 
        * Sets the game mode. That is, whether we are running, paused, in the 
        * failure state, in the victory state, etc. 
        * 
        * @param mode one of the STATE_* constants 
        * @param message string to add to screen or null 
        */ 
        public void setState(int mode, CharSequence message) {  
            /* 
            * This method optionally can cause a text message to be displayed 
            * to the user when the mode changes. Since the View that actually 
            * renders that text is part of the main View hierarchy and not 
            * owned by this thread, we can't touch the state of that View. 
            * Instead we use a Message + Handler to relay commands to the main 
            * thread, which updates the user-text View. 
            */ 
            synchronized (mSurfaceHolder) {  
                mMode = mode;  
                if (mMode == STATE_RUNNING) {  
                    Message msg = mHandler.obtainMessage();  
                    Bundle b = new Bundle();  
                    b.putString("text", "");  
                    b.putInt("viz", View.INVISIBLE);  
                    msg.setData(b);  
                    mHandler.sendMessage(msg);  
                } else {  
                    mRotating = 0;  
                    mEngineFiring = false;  
                    Resources res = mContext.getResources();  
                    CharSequence str = "";  
                    if (mMode == STATE_READY)  
                        str = res.getText(R.string.mode_ready);  
                    else if (mMode == STATE_PAUSE)  
                        str = res.getText(R.string.mode_pause);  
                    else if (mMode == STATE_LOSE)  
                        str = res.getText(R.string.mode_lose);  
                    else if (mMode == STATE_WIN)  
                        str = res.getString(R.string.mode_win_prefix)  
                                + mWinsInARow + " " 
                                + res.getString(R.string.mode_win_suffix);  
                    if (message != null) {  
                        str = message + "\n" + str;  
                    }  
                    if (mMode == STATE_LOSE) mWinsInARow = 0;  
                    Message msg = mHandler.obtainMessage();  
                    Bundle b = new Bundle();  
                    b.putString("text", str.toString());  
                    b.putInt("viz", View.VISIBLE);  
                    msg.setData(b);  
                    mHandler.sendMessage(msg);  
                }  
            }  
        }  
        /* Callback invoked when the surface dimensions change. */ 
        public void setSurfaceSize(int width, int height) {  
            // synchronized to make sure these all change atomically  
            synchronized (mSurfaceHolder) {  
                mCanvasWidth = width;  
                mCanvasHeight = height;  
                // don't forget to resize the background image  
                mBackgroundImage = mBackgroundImage.createScaledBitmap(  
                        mBackgroundImage, width, height, true);  
            }  
        } 

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

  1. 对于控制事件今天我们只处理按键事件onKeyDown，以后的文章中将会讲到屏幕 触控的具体处理onTouchEvent以及Sensor重力感应等方法。

  2. 刷新view的方法这里主要有invalidate(int l, int t, int r, int b) 刷新局部，四个参数分别为左、上、右、下。整个view刷新 invalidate()，刷新一个矩形区域 invalidate(Rect dirty) ，刷新一个特性Drawable， invalidateDrawable(Drawable drawable) ，执行invalidate类的方法将会设置 view为无效，最终导致onDraw方法被重新调用。由于今天的view比较简单，Android123提示大家如果在线程中刷新，除了使用handler方式外，可以在Thread中直接使用postInvalidate方法来实现。

  3. 绘制View主要是onDraw()中通过形参canvas来处理，相关的绘制主要有drawRect、drawLine、drawPath等等。 view方法内部还重写了很多接口，其回调方法可以帮助我们判断出view的位置和大小，比如onMeasure(int, int) Called to determine the size requirements for this view and all of its children.  、onLayout(boolean, int, int, int, int) Called when this view should assign a size and position to all of its children 和onSizeChanged(int, int, int, int) Called when the size of this view has changed. 具体的作用，大家可以用Logcat获取 当view变化时每个形参的变动。

  下面cwjView是我们为今后游戏设计的一个简单自定义View框架，我们可以看到在Android平台 自定义view还是很简单的，同时Java 支持多继承可以帮助我们不断的完善复杂的问题。

view plaincopy to clipboardprint?
public class cwjView extends View {  
    public cwjView(Context context) {  
      
      super(context);  
      
      setFocusable(true); //允许获得焦点  
      setFocusableInTouchMode(true); //获取焦点时允许触控  
        
  }  
  @Override 
  protected Parcelable onSaveInstanceState() {  //处理窗口保存事件  
      Parcelable pSaved = super.onSaveInstanceState();  
      
      Bundle bundle = new Bundle();  
    //dosomething  
      return bundle;  
  }  
  @Override 
  protected void onRestoreInstanceState(Parcelable state) {  //处理窗口还原事件  
      
      Bundle bundle = (Bundle) state;  
    //dosomething  
    super.onRestoreInstanceState(bundle.getParcelable("cwj"));  
      return;  
  }  
      @Override 
  protected void onSizeChanged(int w, int h, int oldw, int oldh) //处理窗口大小变化事件  
  {  
      super.onSizeChanged(w, h, oldw, oldh);  
  }  
  @Override 
  protected void onMeasure (int widthMeasureSpec, int heightMeasureSpec)    
  {  
      super.onMeasure(widthMeasureSpec, heightMeasureSpec); //如果不让父类处理记住调用setMeasuredDimension  
  }  
  @Override 
  protected void onLayout (boolean changed, int left, int top, int right, int bottom)  
  {  
    super.onLayout (changed,left,top, ight,bottom) ;  
  }  
  @Override 
  protected void onDraw(Canvas canvas) {  
      
      Paint bg = new Paint();  
      bg.setColor(Color.Red);  
      canvas.drawRect(0, 0, getWidth()/2, getHeight()/2, bg); //将view的左上角四分之一填充为红色    
      
  }  
  @Override 
  public boolean onTouchEvent(MotionEvent event) {  
        return super.onTouchEvent(event); //让父类处理屏幕触控事件  
  }  
  @Override 
  public boolean onKeyDown(int keyCode, KeyEvent event) { //处理按键事件，响应的轨迹球事件为 public boolean onTrackballEvent (MotionEvent event)   
        
      switch (keyCode) {  
      case KeyEvent.KEYCODE_DPAD_UP:  
        
        break;  
      case KeyEvent.KEYCODE_DPAD_DOWN:  
          
        break;  
      case KeyEvent.KEYCODE_DPAD_LEFT:  
          
        break;  
      case KeyEvent.KEYCODE_DPAD_RIGHT:  
        
        break;  
        
      case KeyEvent.KEYCODE_DPAD_CENTER: //处理中键按下  
        
        break;  
      default:  
        return super.onKeyDown(keyCode, event);  
      }  
      return true;  
  }  
} 
public class cwjView extends View {
    public cwjView(Context context) {
   
      super(context);
   
      setFocusable(true); //允许获得焦点
      setFocusableInTouchMode(true); //获取焦点时允许触控
     
  }
  @Override
  protected Parcelable onSaveInstanceState() {  //处理窗口保存事件
      Parcelable pSaved = super.onSaveInstanceState();
   
      Bundle bundle = new Bundle();
    //dosomething
      return bundle;
  }
  @Override
  protected void onRestoreInstanceState(Parcelable state) {  //处理窗口还原事件
   
      Bundle bundle = (Bundle) state;
    //dosomething
    super.onRestoreInstanceState(bundle.getParcelable("cwj"));
      return;
  }
      @Override
  protected void onSizeChanged(int w, int h, int oldw, int oldh) //处理窗口大小变化事件
  {
      super.onSizeChanged(w, h, oldw, oldh);
  }
  @Override
  protected void onMeasure (int widthMeasureSpec, int heightMeasureSpec) 
  {
      super.onMeasure(widthMeasureSpec, heightMeasureSpec); //如果不让父类处理记住调用setMeasuredDimension
  }
  @Override
  protected void onLayout (boolean changed, int left, int top, int right, int bottom)
  {
    super.onLayout (changed,left,top, ight,bottom) ;
  }
  @Override
  protected void onDraw(Canvas canvas) {
   
      Paint bg = new Paint();
      bg.setColor(Color.Red);
      canvas.drawRect(0, 0, getWidth()/2, getHeight()/2, bg); //将view的左上角四分之一填充为红色 
   
  }
  @Override
  public boolean onTouchEvent(MotionEvent event) {
        return super.onTouchEvent(event); //让父类处理屏幕触控事件
  }
  @Override
  public boolean onKeyDown(int keyCode, KeyEvent event) { //处理按键事件，响应的轨迹球事件为 public boolean onTrackballEvent (MotionEvent event)
     
      switch (keyCode) {
      case KeyEvent.KEYCODE_DPAD_UP:
     
        break;
      case KeyEvent.KEYCODE_DPAD_DOWN:
       
        break;
      case KeyEvent.KEYCODE_DPAD_LEFT:
       
        break;
      case KeyEvent.KEYCODE_DPAD_RIGHT:
     
        break;
     
      case KeyEvent.KEYCODE_DPAD_CENTER: //处理中键按下
     
        break;
      default:
        return super.onKeyDown(keyCode, event);
      }
      return true;
  }
}

上面我们可以看到onMeasure使用的是父类的处理方法，如果我们需要解决 自定义View的大小，可以尝试下面的方法

view plaincopy to clipboardprint?
@Override 
protected void onMeasure (int widthMeasureSpec, int heightMeasureSpec)    
{  
    height = View.MeasureSpec.getSize(heightMeasureSpec);   
    width = View.MeasureSpec.getSize(widthMeasureSpec);   
    setMeasuredDimension(width,height);  //这里面是原始的大小，需要重新计算可以修改本行  
  //dosomething  
} 

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

view plaincopy to clipboardprint?
public class cwjView extends SurfaceView implements SurfaceHolder.Callback {  
public cwjView(Context context, AttributeSet attrs) {  
  super(context, attrs);  
  SurfaceHolder holder=getHolder();  
  holder.addCallback(this);    
    
  setFocusable(true);  
}  
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {  
}  
public void surfaceCreated(SurfaceHolder holder) {  
    
}  
public void surfaceDestroyed(SurfaceHolder holder) {  
}  
@Override 
public void onWindowFocusChanged(boolean hasWindowFocus) {  
    
}  
    
} 

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

view plaincopy to clipboardprint?
Path cwj=new Path();  //构造方法 
Path cwj=new Path();  //构造方法

下面我们画一个封闭的原型路径，我们使用Path类的addCircle方法

view plaincopy to clipboardprint?
cwj.addCircle(10,10,50,Direction.CW); //参数一为x轴水平位置，参数二为y轴垂直位置，第三个参数为圆形的半径，最后是绘制的方向，CW为顺时针方向，而CCW是逆时针方向 
cwj.addCircle(10,10,50,Direction.CW); //参数一为x轴水平位置，参数二为y轴垂直位置，第三个参数为圆形的半径，最后是绘制的方向，CW为顺时针方向，而CCW是逆时针方向

结合Android上次提到的Canvas类中的绘制方法drawPath和drawTextOnPath，我们继续可以在onDraw中加入。

view plaincopy to clipboardprint?
canvas.drawPath(cwj,paintPath); //Android123提示大家这里paintPath为路径的画刷颜色，可以见下文完整的源代码。  
canvas.drawTextOnPath("Android123 - CWJ",cwj,0,15,paintText); //将文字绘制到路径中去， 
canvas.drawPath(cwj,paintPath); //Android123提示大家这里paintPath为路径的画刷颜色，可以见下文完整的源代码。
canvas.drawTextOnPath("Android123 - CWJ",cwj,0,15,paintText); //将文字绘制到路径中去，

有关drawTextOnPath的参数如下:

方法原型

view plaincopy to clipboardprint?
public void drawTextOnPath (String text, Path path, float hOffset, float vOffset, Paint paint) 
public void drawTextOnPath (String text, Path path, float hOffset, float vOffset, Paint paint)

参数列表

text  为需要在路径上绘制的文字内容。
path 将文字绘制到哪个路径。
hOffset  距离路径开始的距离
vOffset  离路径的上下高度，这里Android开发网提示大家，该参数类型为float浮点型，除了精度为8位小数外，可以为正或负，当为正时文字在路径的圈里面，为负时在路径的圈外面。
paint  最后仍然是一个Paint对象用于制定Text本文的颜色、字体、大小等属性。

下面是我们的onDraw方法中如何绘制路径的演示代码为:

view plaincopy to clipboardprint?
@Override 
protected void onDraw(Canvas canvas) {  
  Paint paintPath=new Paint();  
  Paint paintText=new Paint();  
  paintPath.setColor(Color.Red); //路径的画刷为红色  
  paintText.setColor(Color.Blue); //路径上的文字为蓝色  
  Path pathCWJ=new Path();  
  pathCWJ.addCircle(10,10,50,Direction.CW); // 半径为50px，绘制的方向CW为顺时针  
  canvas.drawPath(pathCWJ,paintPath);  
canvas.drawTextOnPath("Android123 - CWJ",pathCWJ,0,15,paintText); //在路径上绘制文字  
} 
  @Override
  protected void onDraw(Canvas canvas) {
    Paint paintPath=new Paint();
    Paint paintText=new Paint();
    paintPath.setColor(Color.Red); //路径的画刷为红色
    paintText.setColor(Color.Blue); //路径上的文字为蓝色
    Path pathCWJ=new Path();
    pathCWJ.addCircle(10,10,50,Direction.CW); // 半径为50px，绘制的方向CW为顺时针
    canvas.drawPath(pathCWJ,paintPath);
  canvas.drawTextOnPath("Android123 - CWJ",pathCWJ,0,15,paintText); //在路径上绘制文字
  }

有关路径类常用的方法如下:

view plaincopy to clipboardprint?
void  addArc(RectF oval, float startAngle, float sweepAngle)  //为路径添加一个多边形  
void  addCircle(float x, float y, float radius, Path.Direction dir)  //给path添加圆圈  
void  addOval(RectF oval, Path.Direction dir)  //添加椭圆形  
void  addRect(RectF rect, Path.Direction dir)  //添加一个区域  
void  addRoundRect(RectF rect, float[] radii, Path.Direction dir)  //添加一个圆角区域  
boolean  isEmpty()  //判断路径是否为空  
void  transform(Matrix matrix)  //应用矩阵变换  
void  transform(Matrix matrix, Path dst)  //应用矩阵变换并将结果放到新的路径中，即第二个参数。 
void  addArc(RectF oval, float startAngle, float sweepAngle)  //为路径添加一个多边形
void  addCircle(float x, float y, float radius, Path.Direction dir)  //给path添加圆圈
void  addOval(RectF oval, Path.Direction dir)  //添加椭圆形
void  addRect(RectF rect, Path.Direction dir)  //添加一个区域
void  addRoundRect(RectF rect, float[] radii, Path.Direction dir)  //添加一个圆角区域
boolean  isEmpty()  //判断路径是否为空
void  transform(Matrix matrix)  //应用矩阵变换
void  transform(Matrix matrix, Path dst)  //应用矩阵变换并将结果放到新的路径中，即第二个参数。

有关路径的高级效果 大家可以使用PathEffect类，有关路径的更多实例Android123将在今后的游戏开发实战中讲解道。

Typeface字体类

平时我们在TextView 中需要设置 显示的字体可以通过TextView 中的setTypeface方法来指定一个Typeface对象，因为 Android的字体类比较简单，我们列出所有成员方法

view plaincopy to clipboardprint?
static Typeface  create(Typeface family, int style)  //静态方法，参数一为字体类型这里是Typeface的静态定义，如宋体，参数二风格，如粗体，斜体  
static Typeface  create(String familyName, int style)  //静态方法，参数一为字体名的字符串，参数二为风格同上，这里我们推荐使用上面的方法。  
static Typeface  createFromAsset(AssetManager mgr, String path)  //静态方法，参数一为AssetManager对象，主要用于从APK的assets文件夹中取出字体，参数二为相对于Android工程下的 assets文件夹中的外挂字体文件的路径。  
static Typeface  createFromFile(File path)  //静态方法，从文件系统构造一个字体，这里参数可以是sdcard中的某个字体文件  
static Typeface  createFromFile(String path)  //静态方法，从指定路径中构造字体  
static Typeface  defaultFromStyle(int style) //静态方法，返回默认的字体风格  
int  getStyle()  //获取当前字体风格  
final boolean  isBold()  //判断当前是否为粗体  
final boolean  isItalic()  //判断当前风格是否为斜体 
static Typeface  create(Typeface family, int style)  //静态方法，参数一为字体类型这里是Typeface的静态定义，如宋体，参数二风格，如粗体，斜体
static Typeface  create(String familyName, int style)  //静态方法，参数一为字体名的字符串，参数二为风格同上，这里我们推荐使用上面的方法。
static Typeface  createFromAsset(AssetManager mgr, String path)  //静态方法，参数一为AssetManager对象，主要用于从APK的assets文件夹中取出字体，参数二为相对于Android工程下的 assets文件夹中的外挂字体文件的路径。
static Typeface  createFromFile(File path)  //静态方法，从文件系统构造一个字体，这里参数可以是sdcard中的某个字体文件
static Typeface  createFromFile(String path)  //静态方法，从指定路径中构造字体
static Typeface  defaultFromStyle(int style) //静态方法，返回默认的字体风格
int  getStyle()  //获取当前字体风格
final boolean  isBold()  //判断当前是否为粗体
final boolean  isItalic()  //判断当前风格是否为斜体

本类的常量静态定义，首先为字体类型名称

Typeface DEFAULT
Typeface DEFAULT_BOLD
Typeface MONOSPACE
Typeface SANS_SERIF
Typeface SERIF

字体风格名称

int BOLD
int BOLD_ITALIC
int ITALIC
int NORMAL

明天我们将在 Android游戏开发之旅 六 自定义View 一文中具体讲解onDraw以及什么时候会触发绘制方法，来实现我们自定义或子类化控件 。

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

Canvas类主要实现了屏幕 的绘制过程，其中包含了很多实用的方法，比如绘制一条路径、区域、贴图、画点、画线、渲染文本，下面是Canvas类常用的方法，当然Android开发网提示大家很多方法有不同的重载版本，参数更灵活。

void drawRect(RectF rect, Paint paint) //绘制区域，参数一为RectF一个区域

void drawPath(Path path, Paint paint) //绘制一个路径，参数一为Path路径对象

void  drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint)  //贴图，参数一就是我们常规的Bitmap对象，参数二是源区域(Android123提示这里是bitmap)，参数三是目标区域 (应该在 canvas的位置和大小)，参数四是Paint画刷对象，因为用到了缩放和拉伸的可能，当原始Rect不等于目标Rect时性能将会有大幅损失。

void  drawLine(float startX, float startY, float stopX, float stopY, Paint paint)  //画线，参数一起始点的x轴位置，参数二起始点的y轴位置，参数三终点的x轴水平位置，参数四y轴垂直位置，最后一个参数为Paint 画刷对象。

void  drawPoint(float x, float y, Paint paint) //画点，参数一水平x轴，参数二垂直y轴，第三个参数为Paint对象。

void drawText(String text, float x, float y, Paint paint)  //渲染文本，Canvas类除了上面的还可以描绘文字，参数一是String类型的文本，参数二x轴，参数三y轴，参数四是Paint对象。

void  drawTextOnPath(String text, Path path, float hOffset, float vOffset, Paint paint) //在路径上绘制文本，相对于上面第二个参数是Path路径对象

从上面来看我们可以看出Canvas绘制类比较简单同时很灵活，实现一般的方法通常没有问题，同时可以叠加的处理设计出一些效果 ，不过细心的网友可能发现最后一个参数均为Paint对象。如果我们把Canvas当做绘画师来看，那么Paint就是我们绘画的工具，比如画笔、画刷、颜料等等。

Paint类常用方法:

void  setARGB(int a, int r, int g, int b)  设置 Paint对象颜色，参数一为alpha透明通道

void  setAlpha(int a)  设置alpha不透明度，范围为0~255

void  setAntiAlias(boolean aa)  //是否抗锯齿

void  setColor(int color)  //设置颜色，这里Android内部定义 的有Color类包含了一些常见颜色定义

void  setFakeBoldText(boolean fakeBoldText)  //设置伪粗体文本
 
void  setLinearText(boolean linearText)  //设置线性文本

PathEffect  setPathEffect(PathEffect effect)  //设置路径效果

Rasterizer  setRasterizer(Rasterizer rasterizer) //设置光栅化

Shader  setShader(Shader shader)  //设置阴影

void  setTextAlign(Paint.Align align)  //设置文本对齐

void  setTextScaleX(float scaleX)  //设置文本缩放倍数，1.0f为原始

void  setTextSize(float textSize)  //设置字体大小

Typeface  setTypeface(Typeface typeface)  //设置字体，Typeface包含了字体的类型，粗细，还有倾斜、颜色等。

void  setUnderlineText(boolean underlineText)  //设置下划线

最终 Canvas和Paint在onDraw中直接使用

view plaincopy to clipboardprint?
@Override 
  protected void onDraw(Canvas canvas) {  
    Paint paintRed=new Paint();  
    paintRed.setColor(Color.Red);  
    canvas.drawPoint(11,3,paintRed); //在坐标11,3上画一个红点  
  } 

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

自定义 View的常用方法:

onFinishInflate() 当View中所有的子控件 均被映射成xml后触发

onMeasure(int, int) 确定所有子元素的大小

onLayout(boolean, int, int, int, int) 当View分配所有的子元素的大小和位置时触发

onSizeChanged(int, int, int, int) 当view的大小发生变化时触发

onDraw(Canvas) view渲染内容的细节

onKeyDown(int, KeyEvent) 有按键按下后触发

onKeyUp(int, KeyEvent) 有按键按下后弹起时触发

onTrackballEvent(MotionEvent) 轨迹球事件

onTouchEvent(MotionEvent) 触屏事件

onFocusChanged(boolean, int, Rect) 当View获取 或失去焦点时触发

onWindowFocusChanged(boolean) 当窗口包含的view获取或失去焦点时触发

onAttachedToWindow() 当view被附着到一个窗口时触发

onDetachedFromWindow() 当view离开附着的窗口时触发，Android123提示该方法和  onAttachedToWindow() 是相反的。

onWindowVisibilityChanged(int) 当窗口中包含的可见的view发生变化时触发

  以上是View实现的一些基本接口的回调方法，一般我们需要处理画布的显示时，重写onDraw(Canvas)用的的是最多的：

view plaincopy to clipboardprint?
  @Override 
  protected void onDraw(Canvas canvas) {  
    //这里我们直接使用canvas对象处理当前的画布，比如说使用Paint来选择要填充的颜色  
  Paint paintBackground = new Paint();  
  paintBackground.setColor(getResources().getColor(R.color.xxx));  //从Res中找到名为xxx的color颜色定义  
  canvas.drawRect(0, 0, getWidth(), getHeight(), paintBackground); //设置当前画布的背景颜色为paintBackground中定义的颜色，以0,0作为为起点，以当前画布的宽度和高度为重点即整块画布来填充，具体的请查看Android123未来讲到的Canvas和Paint，在Canvas中我们可以实现画路径，图形，区域，线。而Paint作为绘画方式的对象可以设置颜色，大小，甚至字体的类型等等。  
} 
  @Override
  protected void onDraw(Canvas canvas) {
    //这里我们直接使用canvas对象处理当前的画布，比如说使用Paint来选择要填充的颜色
  Paint paintBackground = new Paint();
  paintBackground.setColor(getResources().getColor(R.color.xxx));  //从Res中找到名为xxx的color颜色定义
  canvas.drawRect(0, 0, getWidth(), getHeight(), paintBackground); //设置当前画布的背景颜色为paintBackground中定义的颜色，以0,0作为为起点，以当前画布的宽度和高度为重点即整块画布来填充，具体的请查看Android123未来讲到的Canvas和Paint，在Canvas中我们可以实现画路径，图形，区域，线。而Paint作为绘画方式的对象可以设置颜色，大小，甚至字体的类型等等。
}

当然还有就是处理窗口还原状态问题(一般用于横竖屏切换)，除了在Activity中可以调用外，开发游戏时我们尽量在View中使用类似

view plaincopy to clipboardprint?
@Override 
  protected Parcelable onSaveInstanceState() {  
      Parcelable p = super.onSaveInstanceState();  
      Bundle bundle = new Bundle();  
      bundle.putInt("x", pX);  
      bundle.putInt("y", pY);  
      bundle.putParcelable("android123_state", p);  
      return bundle;  
  }  
  @Override 
  protected void onRestoreInstanceState(Parcelable state) {   
      Bundle bundle = (Bundle) state;  
      dosomething(bundle.getInt("x"), bundle.getInt("y")); //获取刚才存储的x和y信息  
      super.onRestoreInstanceState(bundle.getParcelable("android123_state"));  
      return;  
  } 
@Override
  protected Parcelable onSaveInstanceState() {
      Parcelable p = super.onSaveInstanceState();
      Bundle bundle = new Bundle();
      bundle.putInt("x", pX);
      bundle.putInt("y", pY);
      bundle.putParcelable("android123_state", p);
      return bundle;
  }
  @Override
  protected void onRestoreInstanceState(Parcelable state) {
      Bundle bundle = (Bundle) state;
      dosomething(bundle.getInt("x"), bundle.getInt("y")); //获取刚才存储的x和y信息
      super.onRestoreInstanceState(bundle.getParcelable("android123_state"));
      return;
  }

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

view plaincopy to clipboardprint?
abstract void  surfaceChanged(SurfaceHolder holder, int format, int width, int height)  
abstract void  surfaceCreated(SurfaceHolder holder)  
abstract void  surfaceDestroyed(SurfaceHolder holder) 
abstract void  surfaceChanged(SurfaceHolder holder, int format, int width, int height)
abstract void  surfaceCreated(SurfaceHolder holder)
abstract void  surfaceDestroyed(SurfaceHolder holder)

对于Surface相关的，Android底层还提供了GPU加速功能 ，所以一般实时性很强的应用 中主要使用SurfaceView而不是直接从View 构建，同时Android123未来后面说到的OpenGL中的GLSurfaceView也是从该类实现。

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

      对于很多游戏使用屏幕 控制一般需要考虑长按事件，比如在动作类的游戏中需要长按发射武器，结合Android Button模型，我们实现一个带图片的Button的长按，为了更清晰的显示原理，Android开发网这里使用ImageButton作为基类

view plaincopy to clipboardprint?
public class RepeatingImageButton extends ImageButton {  
  private long mStartTime; //记录长按开始  
  private int mRepeatCount; //重复次数计数  
  private RepeatListener mListener;  
  private long mInterval = 500; //Timer触发间隔，即每0.5秒算一次按下  
    
  public RepeatingImageButton(Context context) {  
      this(context, null);  
  }  
  public RepeatingImageButton(Context context, AttributeSet attrs) {  
      this(context, attrs, android.R.attr.imageButtonStyle);  
  }  
  public RepeatingImageButton(Context context, AttributeSet attrs, int defStyle) {  
      super(context, attrs, defStyle);  
      setFocusable(true); //允许获得焦点  
      setLongClickable(true); //启用长按事件  
  }  
    
  public void setRepeatListener(RepeatListener l, long interval) { //实现重复按下事件listener  
      mListener = l;  
      mInterval = interval;  
  }  
 
  @Override 
  public boolean performLongClick() {  
      mStartTime = SystemClock.elapsedRealtime();  
      mRepeatCount = 0;  
      post(mRepeater);  
      return true;  
  }  
 
  @Override 
  public boolean onTouchEvent(MotionEvent event) {  
      if (event.getAction() == MotionEvent.ACTION_UP) {  //  本方法原理同onKeyUp的一样，这里处理屏幕事件，下面的onKeyUp处理Android手机上的物理按键事件  
            removeCallbacks(mRepeater);   
          if (mStartTime != 0) {  
              doRepeat(true);  
              mStartTime = 0;  
          }  
      }  
      return super.onTouchEvent(event);  
  }  
//处理导航键事件的中键或轨迹球按下事件  
  @Override 
  public boolean onKeyDown(int keyCode, KeyEvent event) {  
      switch (keyCode) {  
          case KeyEvent.KEYCODE_DPAD_CENTER:   
          case KeyEvent.KEYCODE_ENTER:  
              super.onKeyDown(keyCode, event);  
              return true;  
      }  
      return super.onKeyDown(keyCode, event);  
  }  
//当按键弹起通知长按结束  
  @Override 
  public boolean onKeyUp(int keyCode, KeyEvent event) {  
      switch (keyCode) {  
      case KeyEvent.KEYCODE_DPAD_CENTER:  
      case KeyEvent.KEYCODE_ENTER:  
          
          removeCallbacks(mRepeater); //取消重复listener捕获  
          if (mStartTime != 0) {  
              doRepeat(true); //如果长按事件累计时间不为0则说明长按了  
              mStartTime = 0; //重置长按计时器  
          }  
      }  
      return super.onKeyUp(keyCode, event);  
  }  
 
  private Runnable mRepeater = new Runnable() {  //在线程中判断重复  
      public void run() {  
          doRepeat(false);  
          if (isPressed()) {  
              postDelayed(this, mInterval); //计算长按后延迟下一次累加  
          }  
      }  
  };  
  private  void doRepeat(boolean last) {  
      long now = SystemClock.elapsedRealtime();  
      if (mListener != null) {  
          mListener.onRepeat(this, now - mStartTime, last ? -1 : mRepeatCount++);  
      }  
  } 
  public class RepeatingImageButton extends ImageButton {
    private long mStartTime; //记录长按开始
    private int mRepeatCount; //重复次数计数
    private RepeatListener mListener;
    private long mInterval = 500; //Timer触发间隔，即每0.5秒算一次按下
   
    public RepeatingImageButton(Context context) {
        this(context, null);
    }
    public RepeatingImageButton(Context context, AttributeSet attrs) {
        this(context, attrs, android.R.attr.imageButtonStyle);
    }
    public RepeatingImageButton(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        setFocusable(true); //允许获得焦点
        setLongClickable(true); //启用长按事件
    }
   
    public void setRepeatListener(RepeatListener l, long interval) { //实现重复按下事件listener
        mListener = l;
        mInterval = interval;
    }
 
    @Override
    public boolean performLongClick() {
        mStartTime = SystemClock.elapsedRealtime();
        mRepeatCount = 0;
        post(mRepeater);
        return true;
    }
 
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_UP) {  //  本方法原理同onKeyUp的一样，这里处理屏幕事件，下面的onKeyUp处理Android手机上的物理按键事件
              removeCallbacks(mRepeater);
            if (mStartTime != 0) {
                doRepeat(true);
                mStartTime = 0;
            }
        }
        return super.onTouchEvent(event);
    }
  //处理导航键事件的中键或轨迹球按下事件
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        switch (keyCode) {
            case KeyEvent.KEYCODE_DPAD_CENTER:
            case KeyEvent.KEYCODE_ENTER:
                super.onKeyDown(keyCode, event);
                return true;
        }
        return super.onKeyDown(keyCode, event);
    }
  //当按键弹起通知长按结束
    @Override
    public boolean onKeyUp(int keyCode, KeyEvent event) {
        switch (keyCode) {
        case KeyEvent.KEYCODE_DPAD_CENTER:
        case KeyEvent.KEYCODE_ENTER:
         
            removeCallbacks(mRepeater); //取消重复listener捕获
            if (mStartTime != 0) {
                doRepeat(true); //如果长按事件累计时间不为0则说明长按了
                mStartTime = 0; //重置长按计时器
            }
        }
        return super.onKeyUp(keyCode, event);
    }
 
    private Runnable mRepeater = new Runnable() {  //在线程中判断重复
        public void run() {
            doRepeat(false);
            if (isPressed()) {
                postDelayed(this, mInterval); //计算长按后延迟下一次累加
            }
        }
    };
    private  void doRepeat(boolean last) {
        long now = SystemClock.elapsedRealtime();
        if (mListener != null) {
            mListener.onRepeat(this, now - mStartTime, last ? -1 : mRepeatCount++);
        }
    }

下面是重复Button Listener接口的定义 ，调用时在Button中先使用setRepeatListener()方法实现RepeatListener接口

view plaincopy to clipboardprint?
public interface RepeatListener {  
        void onRepeat(View v, long duration, int repeatcount); //参数一为用户传入的Button对象，参数二为延迟的毫秒数，第三位重复次数回调。  
}  
    public interface RepeatListener {
            void onRepeat(View v, long duration, int repeatcount); //参数一为用户传入的Button对象，参数二为延迟的毫秒数，第三位重复次数回调。
    }
}

本类大家可以直接在自己的View中implements实现RepeatListener接口即可。

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

今天翻了一个上午的网络，在android 模拟器下配置google maps遇到了问题，查阅了一堆资料，多数讲解的不是很清晰，呵呵，经过多次试验终于OK了，现把每一步详细列出来，提供给像我这样的初学者。大家共同进步

1)首先你要确定你安装的JDK位置，Windows->Preferences->Java->Installed JREs,你可以看到是Jre的location,再在dos cmd模式下查看你当前系统的path是否已经包含了。如果没有包含添加到当前环境参数中。因为我们要用到的keytool命令在这个目录下呀。
2)接下来就要找到你不前AVD的debug.keystore的位置，windows->perferences->android->build,
default debug keystore文本框中，列出C:\Documents and Settings\XXXXuser\.android\debug.keystore,这就是默认的debug.keystore,你可以先把这个文件改一下名。我们需要创建一个新的debug.keystore
3)紧接着我们来创建一个新的debug.keystore,在cmd下，进入C:\Documents and Settings\XXXXuser\.android目录
执行命令如下：
keytool -genkey -v -keystore debug.keystore -alias androiddebugkey -keyalg RSA -validity 10000
输入密码，用户等信息确认后生成一个debug.keystore
4)好了，接下来我们就需要获取MD5,去google申请一个apikey,很简单
在当前目录下执行：
keytool -list -alias androiddebugkey -keystore debug.keystore
根据提示输入你在第三步所设的密码，ok,就会得到下面信息，
Certificate fingerprint (MD5): FC:ED:DE:BS:16:1A:E8:05:F0:44:AD:4E:45:42:4B:D4
这就是我们申请apikey时需要的FC:ED:DE:BS:16:1A:E8:05:F0:44:AD:4E:45:42:4B:D4
通过浏览器访问http://code.google.com/android/maps-api-signup.html
在My certificate's MD5 fingerprint文本框中输入您刚刚获取到的MD5码
点击Generate API Key，
Thank you for signing up for an Android Maps API key!
Your key is:
0yRkOg8325bNSbeuYXZMsj-CMG2rXXXqFBoa11A
这就是apikey了，记得保存下呀

5)新建一个android项目
修改main.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<view class = "com.google.android.maps.MapView" 
 android:id = "@+id/my_map"
 android:enabled = "true"
 android:apiKey="0yRkOg8325bNSbeuYXZMsj-CMG2rXXXqFBoa11A"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    />
</LinearLayout>
在layout中定义mapview时需要加入apikey, 如：android:apiKey="0yRkOg8325bNSbeuYXZMsj-CMG2rXXXqFBoa11A"
6)修改androidmanifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.testmap"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <uses-library  android:name="com.google.android.maps" />
        <activity android:name=".testmap"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

    </application>
    <uses-sdk android:minSdkVersion="5" />
<uses-permission android:name="android.permission.INTERNET"></uses-permission>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"></uses-permission>
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"></uses-permission>
</manifest>

我们需要加入用户库引用<uses-library  android:name="com.google.android.maps" />
当然了还要加入权限的定义
<uses-permission android:name="android.permission.INTERNET"></uses-permission>
这两步必不可少

7）最后就是主class了