【读书笔记《Android游戏编程之从零开始》】20.游戏开发基础（游戏数据存储）

import android.content.Context;
import android.content.SharedPreferences;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.SurfaceHolder.Callback;


public class MySurfaceView extends SurfaceView implements Callback, Runnable {
    private SurfaceHolder sfh;
    private Paint paint;
    private Thread th;
    private boolean flag;
    private Canvas canvas;
    private int screenW, screenH;
    //记录当前圆形所在九宫格的位置下标
    private int creentTileIndex;
    //声明一个SharedPreferences对象
    private SharedPreferences sp;

    /**
     * SurfaceView初始化函数
     */
    public MySurfaceView(Context context) {
        super(context);
        sfh = this.getHolder();
        sfh.addCallback(this);
        paint = new Paint();
        paint.setColor(Color.BLACK);
        paint.setAntiAlias(true);
        setFocusable(true);
        //通过Context获取SharedPreference实例
        sp = context.getSharedPreferences("SaveName", Context.MODE_PRIVATE);
        //每次程序运行时获取圆形的下标
        int tempIndex = sp.getInt("CirCleIndex", -1);
        //判定如果返回-1 说明没有找到，就不对当前记录圆形的变量进行赋值
        if (tempIndex != -1) {
            creentTileIndex = tempIndex;
        }
    }

    /**
     * SurfaceView视图创建，响应此函数
     */
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        screenW = this.getWidth();
        screenH = this.getHeight();
        flag = true;
        //实例线程
        th = new Thread(this);
        //启动线程
        th.start();
    }

    /**
     * 游戏绘图
     */
    public void myDraw() {
        try {
            canvas = sfh.lockCanvas();
            if (canvas != null) {
                canvas.drawColor(Color.WHITE);
                paint.setColor(Color.BLACK);
                paint.setStyle(Style.STROKE);
                //绘制九宫格(将屏幕九等份)
                //得到每个方格的宽高
                int tileW = screenW / 3;
                int tileH = screenH / 3;
                for (int i = 0; i < 3; i++) {
                    for (int j = 0; j < 3; j++) {
                        canvas.drawRect(i * tileW, j * tileH, (i + 1) * tileW, (j + 1) * tileH, paint);
                    }
                }
                //根据得到的圆形下标位置进行绘制相应的方格中
                paint.setStyle(Style.FILL);
                canvas.drawCircle(creentTileIndex % 3 * tileW + tileW / 2, creentTileIndex / 3 * tileH + tileH / 2, 30, paint);
                //操作说明
                canvas.drawText("上键：保存游戏", 0, 20, paint);
                canvas.drawText("下键：读取游戏", 110, 20, paint);
                canvas.drawText("左右键：移动圆形", 215, 20, paint);
            }
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            if (canvas != null)
                sfh.unlockCanvasAndPost(canvas);
        }
    }

    /**
     * 触屏事件监听
     */
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        return true;
    }

    /**
     * 按键事件监听
     */
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        //上键保存游戏状态
        if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
            sp.edit().putInt("CirCleIndex", creentTileIndex).commit();
            //下键读取游戏状态
        } else if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
            int tempIndex = sp.getInt("CirCleIndex", -1);
            if (tempIndex != -1) {
                creentTileIndex = tempIndex;
            }
            //圆形的移动
        } else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
            if (creentTileIndex > 0) {
                creentTileIndex -= 1;
            }
        } else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
            if (creentTileIndex < 8) {
                creentTileIndex += 1;
            }
        }
        return super.onKeyDown(keyCode, event);
    }

    /**
     * 游戏逻辑
     */
    private void logic() {
    }

    @Override
    public void run() {
        while (flag) {
            long start = System.currentTimeMillis();
            myDraw();
            logic();
            long end = System.currentTimeMillis();
            try {
                if (end - start < 50) {
                    Thread.sleep(50 - (end - start));
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * SurfaceView视图状态发生改变，响应此函数
     */
    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
    }

    /**
     * SurfaceView视图消亡时，响应此函数
     */
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        flag = false;
    }
}

    /**
     * 按键事件监听
     */
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        //用到的读出、写入流
        FileOutputStream fos = null;
        FileInputStream fis = null;
        DataOutputStream dos = null;
        DataInputStream dis = null;
        //上键保存游戏状态
        if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
            try {
                // 从SDcard中写入数据
                // 试探终端是否有sdcard! 并且探测SDCard是否处于被移除的状态
                if (Environment.getExternalStorageState() != null && !Environment.getExternalStorageState().equals("removed")) {
                    Log.v("yc", "写入，有SD卡");
                    File path = new File("/sdcard/yc");// 创建目录  
                    File f = new File("/sdcard/yc/save.yc");// 创建文件  
                    if (!path.exists()) {// 目录存在返回true  
                        path.mkdirs();// 创建一个目录  
                    }
                    if (!f.exists()) {// 文件存在返回true  
                        f.createNewFile();// 创建一个文件  
                    }
                    fos = new FileOutputStream(f);// 将数据存入sd卡中  
                } else {
                    //默认系统路径
                    //利用Activity实例打开流文件得到一个写入流
                    fos = MainActivity.instance.openFileOutput("save.yc", Context.MODE_PRIVATE);
                }
                //将写入流封装在数据写入流中
                dos = new DataOutputStream(fos);
                //写入一个int类型(将圆形所在格子的下标写入流文件中)
                dos.writeInt(creentTileIndex);
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                //即使保存时发生异常，也要关闭流
                try {
                    if (fos != null)
                        fos.close();
                    if (dos != null)
                        dos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            //下键读取游戏状态
        } else if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
            boolean isHaveSDCard = false;
            // 从SDcard中读取数据
            // 试探终端是否有sdcard! 并且探测SDCard是否处于被移除的状态
            if (Environment.getExternalStorageState() != null && !Environment.getExternalStorageState().equals("removed")) { 
                Log.v("yc", "读取，有SD卡");
                isHaveSDCard = true;
            }
            try {
                if (isHaveSDCard) {
                    File path = new File("/sdcard/yc");// 创建目录  
                    File f = new File("/sdcard/yc/save.yc");// 创建文件  
                    if (!path.exists()) {// 目录存在返回true
                        return false;
                    } else {
                        if (!f.exists()) {// 文件存在返回true  
                            return false;
                        }
                    }
                    fis = new FileInputStream(f);// 将数据存入sd卡中  
                } else {
                    if (MainActivity.instance.openFileInput("save.yc") != null) {
                        //利用Activity实例打开流文件得到一个读入流
                        fis = MainActivity.instance.openFileInput("save.yc");
                    }
                }
                //将读入流封装在数据读入流中
                dis = new DataInputStream(fis);
                //读出一个Int类型赋值与圆形所在格子的下标
                creentTileIndex = dis.readInt();
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                //即使读取时发生异常，也要关闭流
                try {
                    if (fis != null)
                        fis.close();
                    if (dis != null)
                        dis.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        } else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
            if (creentTileIndex > 0) {
                creentTileIndex -= 1;
            }
        } else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
            if (creentTileIndex < 8) {
                creentTileIndex += 1;
            }
        }
        return super.onKeyDown(keyCode, event);
    }

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;

public class MySQLiteOpenHelper extends SQLiteOpenHelper {
    public final static int VERSION = 1;// 版本号
    public final static String TABLE_NAME = "INDEXINFO";// 表名
    public final static String Param1 = "ID";// 后面ContentProvider使用
    public final static String Param2 = "TITLEINDEX";
    public final static String DATABASE_NAME = "yc.db";

    public MySQLiteOpenHelper(Context context) {
        // 在Android 中创建和打开一个数据库都可以使用openOrCreateDatabase 方法来实现，
        // 因为它会自动去检测是否存在这个数据库，如果存在则打开，不过不存在则创建一个数据库；
        // 创建成功则返回一个 SQLiteDatabase对象，否则抛出异常FileNotFoundException。
        // 下面是来创建一个名为"DATABASE_NAME"的数据库，并返回一个SQLiteDatabase对象
        super(context, DATABASE_NAME, null, VERSION);
    }

    /**
     * 在数据库第一次生成的时候会调用这个方法，一般我们在这个方法里边生成数据库表;
     */
    @Override
    public void onCreate(SQLiteDatabase db) {
        // SQL语句,这里是创建一个表明为yc的表，有2个参数ID和TITLEINDEX，其中ID为主键，自增。具体说明如下：
        // CREATE TABLE 创建一张表 然后后面是表名
        // 然后表的列，第一个是id 方便操作数据,int类型
        // PRIMARY KEY 是指主键 这是一个int型,用于唯一的标识一行;
        // AUTOINCREMENT 表示数据库会为每条记录的key加一，确保记录的唯一性;
        // 最后加入一列文本 int类型参数TITLEINDEX

        String str_sql = "CREATE TABLE " + TABLE_NAME + "(" + Param1
                + " INTEGER PRIMARY KEY AUTOINCREMENT," + Param2
                + "  INTEGER );";
        // execSQL()方法是执行一句sql语句
        db.execSQL(str_sql);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // 一般默认情况下，当我们插入 数据库就立即更新
        // 当数据库需要升级的时候，Android 系统会主动的调用这个方法。
        // 一般我们在这个方法里边删除数据表，并建立新的数据表，
        // 当然是否还需要做其他的操作，完全取决于游戏需求。
        Log.v("y_Hint", "onUpgrade");
    }

}