android打包sqlite

1. 如何将android的数据库打包到APK里

sdk不能直接打开res\raw目录中的数据库文件，不过我们可以通过将这个文件复制到手机内存或sd卡上来访问。复制的方法也很简单，就是在程序第一次启动时判断要复制的目标路径是否存在该数据库文件，如果不存在该数据库文件，那先复制这个文件，然后再打开数据库文件。
复制数据库文件可以通过getresources().openrawresource方法获得res\raw目录中资源的inputstream对象，然后将该inputstream对象中的数据写入其他的目录中相应文件中。打开数据库可以使用sqlitedatabase.openorcreatedatabase方法来打开sqlite数据库文件。openorcreatedatabase方法可以打开任意目录下的数据库文件。

2. Android 如何打包sqlite数据库问题。。！！

第一个问题简单，你直接写一个文件下载界面，让用户自己选择自己所在城市，然后去下载相应的数据库。把数据库保存到你说的那个位置就好了。

3. 如何sqllite数据库复制到android手机上

你是说直接打包到apk包中么？

1.把你的.sqlite文件打包成zip文件放在Assert目录下。

2.在程序第一次运行时，Activity.getAssert()函数读助assert目录下的sqlite文件，复制到你想要的目录下（一般是sd卡目录下，不过要注意的就是 要检查sd卡是否存在）

3.用SqliteDataBase.openDataBase()函数打开数据库，进行各种操作。

--------------------------
但你的需求，如果只是配置信息，用SharedPreferences 来做不是更方便么？

4. android怎样把SQLite打包到APk中

你在eclipse中编译工程的时候，db数据库文件会自动打包到apk文件中，也就是说你安装这个apk的时候，数据库就已经存在了，无需在手工导入

5. android上如何使用sqlite数据库

SQLite 一个非常流行的嵌入式数据库，它支持 SQL 语言，并且只利用很少的内存就有很好的性能。此外它还是开源的，任何人都可以使用它。许多开源项目（(Mozilla, PHP, Python）都使用了 SQLite.

Android 开发中使用 SQLite 数据库
Activites 可以通过 Content Provider 或者 Service 访问一个数据库。下面会详细讲解如果创建数据库，添加数据和查询数据库。
创建数据库
Android 不自动提供数据库。在 Android 应用程序中使用 SQLite，必须自己创建数据库，然后创建表、索引，填充数据。Android 提供了 SQLiteOpenHelper 帮助你创建一个数据库，你只要继承 SQLiteOpenHelper 类，就可以轻松的创建数据库。SQLiteOpenHelper 类根据开发应用程序的需要，封装了创建和更新数据库使用的逻辑。SQLiteOpenHelper 的子类，至少需要实现三个方法：
构造函数，调用父类 SQLiteOpenHelper 的构造函数。这个方法需要四个参数：上下文环境（例如，一个 Activity），数据库名字，一个可选的游标工厂（通常是 Null），一个代表你正在使用的数据库模型版本的整数。
onCreate（）方法，它需要一个 SQLiteDatabase 对象作为参数，根据需要对这个对象填充表和初始化数据。
onUpgrage() 方法，它需要三个参数，一个 SQLiteDatabase 对象，一个旧的版本号和一个新的版本号，这样你就可以清楚如何把一个数据库从旧的模型转变到新的模型。

6. 关于android数据库打包的问题，高分悬赏

我来赚分了 呵呵
其实很简单的 我给你一个数据库的基础类吧 你继承一下，然后就可以在sd卡上建立自己的数据库了。 呵呵

你给的分好多哇
额 没法上传附件。。。直接代码吧。。

package sean.data;

import java.io.File;

import sean.configs.Const;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.os.Environment;
import android.util.Log;

public abstract class SDSQLiteOpenHelper {
private static final String TAG = SDSQLiteOpenHelper.class.getSimpleName();

// @SuppressWarnings("unused")
// private final Context context;
private final String dbName;
private final CursorFactory factory;
private final int newVersion;
private String dbPath = Const.DBPath;

private SQLiteDatabase sdDatabase = null;
private boolean isInitializing = false;

/**
* Create a helper object to create, open, and/or manage a database. The
* database is not actually created or opened until one of
* {@link #getWritableDatabase} or {@link #getReadableDatabase} is called.
*
* @param context
* to use to open or create the database
* @param name
* of the database file, or null for an in-memory database
* @param factory
* to use for creating cursor objects, or null for the default
* @param version
* number of the database (starting at 1); if the database is
* older, {@link #onUpgrade} will be used to upgrade the database
*/
//Context context0,
public SDSQLiteOpenHelper(String name0,
CursorFactory factory0, int version0) {
if (version0 < 1)
throw new IllegalArgumentException("Version must be >= 1, was "
+ version0);

// context = context0;
if (name0.indexOf('/') != -1) {// 如果name0包含路径的话，更改dbPath为name0中的指定路径
while (name0.charAt(0) == '/') {// 将name0中最前面的'/'去除
name0 = name0.substring(1);
}
dbPath += name0.substring(0, name0.lastIndexOf('/'));
name0 = name0.substring(name0.lastIndexOf('/') + 1, name0.length());
}
dbName = name0;
factory = factory0;
newVersion = version0;
}

/**
* Create and/or open a database that will be used for reading and writing.
* Once opened successfully, the database is cached, so you can call this
* method every time you need to write to the database. Make sure to call
* {@link #close} when you no longer need it.
*
* <p>
* Errors such as bad permissions or a full disk may cause this operation to
* fail, but future attempts may succeed if the problem is fixed.
* </p>
*
* @throws SQLiteException
* if the database cannot be opened for writing
* @return a read/write database object valid until {@link #close} is called
*/
public synchronized SQLiteDatabase getWritableDatabase() {
if (sdDatabase != null && sdDatabase.isOpen()
&& !sdDatabase.isReadOnly()) {
return sdDatabase; // The database is already open for business

}

if (isInitializing) {
throw new IllegalStateException(
"getWritableDatabase called recursively");
}

// If we have a read-only database open, someone could be using it
// (though they shouldn't), which would cause a lock to be held on
// the file, and our attempts to open the database read-write would
// fail waiting for the file lock. To prevent that, we acquire the
// lock on the read-only database, which shuts out other users.

boolean success = false;
SQLiteDatabase db = null;
try {
isInitializing = true;
if (dbName == null) {
db = SQLiteDatabase.create(null);
} else {
String path = getDatabaseFile(dbName).getPath();
db = SQLiteDatabase.openOrCreateDatabase(path, factory);
}

int version = db.getVersion();
if (version != newVersion) {
db.beginTransaction();
try {
if (version == 0) {
onCreate(db);
} else {
onUpgrade(db, version, newVersion);
}
db.setVersion(newVersion);
db.setTransactionSuccessful();
} finally {
db.endTransaction();
}
}

onOpen(db);
success = true;
return db;
} finally {
isInitializing = false;
if (success) {
if (sdDatabase != null) {
try {
sdDatabase.close();
} catch (Exception e) {
}
}
sdDatabase = db;
} else {
if (db != null)
db.close();
}
}
}

/**
* Create and/or open a database. This will be the same object returned by
* {@link #getWritableDatabase} unless some problem, such as a full disk,
* requires the database to be opened read-only. In that case, a read-only
* database object will be returned. If the problem is fixed, a future call
* to {@link #getWritableDatabase} may succeed, in which case the read-only
* database object will be closed and the read/write object will be returned
* in the future.
*
* @throws SQLiteException
* if the database cannot be opened
* @return a database object valid until {@link #getWritableDatabase} or
* {@link #close} is called.
*/
public synchronized SQLiteDatabase getReadableDatabase() {
if (sdDatabase != null && sdDatabase.isOpen()) {
return sdDatabase; // The database is already open for business

}

if (isInitializing) {
throw new IllegalStateException(
"getReadableDatabase called recursively");
}

try {
return getWritableDatabase();
} catch (SQLiteException e) {
if (dbName == null)
throw e; // Can't open a temp database read-only!

Log.e(TAG, "Couldn't open " + dbName
+ " for writing (will try read-only):", e);
}

SQLiteDatabase db = null;
try {
isInitializing = true;
String path = getDatabaseFile(dbName).getPath();
db = SQLiteDatabase.openDatabase(path, factory,
SQLiteDatabase.OPEN_READWRITE);
if (db.getVersion() != newVersion) {
throw new SQLiteException(
"Can't upgrade read-only database from version "
+ db.getVersion() + " to " + newVersion + ": "
+ path);
}

onOpen(db);
Log.w(TAG, "Opened " + dbName + " in read-only mode");
sdDatabase = db;
return sdDatabase;
} finally {
isInitializing = false;
if (db != null && db != sdDatabase)
db.close();
}
}

/**
* Close any open database object.
*/
public synchronized void close() {
if (isInitializing)
throw new IllegalStateException("Closed ring initialization");

if (sdDatabase != null && sdDatabase.isOpen()) {
sdDatabase.close();
sdDatabase = null;
}
}

public File getDatabaseFile(String name) {
String EXTERN_PATH = null;
if (Environment.getExternalStorageState().equals(
Environment.MEDIA_MOUNTED) == true) {
EXTERN_PATH = dbPath;
File f = new File(EXTERN_PATH);
if (!f.exists()) {
f.mkdirs();
}
}
return new File(EXTERN_PATH + name);
}

/**
* Called when the database is created for the first time. This is where the
* creation of tables and the initial population of the tables should
* happen.
*
* @param db
* The database.
*/
public abstract void onCreate(SQLiteDatabase db);

/**
* Called when the database needs to be upgraded. The implementation should
* use this method to drop tables, add tables, or do anything else it needs
* to upgrade to the new schema version.
*
* <p>
* The SQLite ALTER TABLE documentation can be found <a
* href="http://sqlite.org/lang_altertable.html">here</a>. If you add new
* columns you can use ALTER TABLE to insert them into a live table. If you
* rename or remove columns you can use ALTER TABLE to rename the old table,
* then create the new table and then populate the new table with the
* contents of the old table.
*
* @param db
* The database.
* @param oldVersion
* The old database version.
* @param newVersion
* The new database version.
*/
public abstract void onUpgrade(SQLiteDatabase db, int oldVersion,
int newVersion);

/**
* Called when the database has been opened. Override method should check
* {@link SQLiteDatabase#isReadOnly} before updating the database.
*
* @param db
* The database.
*/
public void onOpen(SQLiteDatabase db) {
}

public String getDBFilePath() {
return dbPath + dbName;
}

}

7. 新手，cocos2dx移植到android平台不知道怎么导入sqlite3库

创建windows平台项目 一、 搭建windows开发环境 官网上显示cocos2d-x支持win7、winxp、vista系统但我只在win7上用过以下说明均是在win7系统上的编译器使用vs2010。 1、 安装vs2010 2、 安装Visual Assist X可选 3、 执行build-win32.bat编译cocos2d-x 4、 运行cocos2d-x根目录下的install-templates-msvc.bat将cocos2d-x模板加入vs模板库。 5、将.\Debug.win32目录下的所有dll文件拷贝至Windows\system32\ （iconv.dll libcocos2d.dll libcocosDenshion.dll libcuri.dll libEGL.dll libgles_cm.dll libxml.dll pthreadVCE2.dll zlib1.dll ）6、 双击cocos2d-win32.vc2010.sln进入vs编译环境 二、 新建win32项目 1、在“解决方案”上单击右键选择“添加”-〉“新建项目”。 2、选择“左侧Cocos2d-x模板”在右侧列表中选择“Cocos2d-win32 Application”输入项目名称“Cocos2dDemo”点“确定”。3、在弹出的对话框中点击“下一步”。 4、如果需要使用Box2D引擎则选中否则不要选。点击“finish”创建成功。 三、 编译运行 1、右键Cocos2dDemo项目选择“生成”进行编译。 2、右键Cocos2dDemo项目选择“设为启动项目”。然后F5或者点击菜单栏的运行键 运行。四、 创建新的解决方案 新建项目有两种方式一是直接在cocos2d-x解决方案中添加新项目上面已经介绍过了。当你刚开始接触cocos2d-x还在尝试写demo时用这种方式可以快捷的创建demo而且方便查看例子中的代码。另一种方式是创建一个新的解决方案方法如下 1、“文件”-〉“新建”-〉“项目” 2、进入新建项目的窗口选择“左侧Cocos2d-x模板”在右侧列表中选择“Cocos2d-win32 Application”输入项目名称“Cocos2dDemo”点“确定”。然后执行“下一步”。 3、使用Box2D引擎则选中否则不要选。点击“finish”创建成功。 4、单击左下角的属性标签或者选择“视图”-〉“属性管理器”打开属性管理器5、在属性管理器中双击“Microsoft.Cpp.Win32.user”弹出属性页在里面设置VC++目录即可。这样该设置对所有VC项目都有效见下图。 6、在“包含目录”中, 加入下列项目 (D:\android\cocos2d-2.0-x-2.0.3\cocos2dx\platform\third_party\win32) 7、在“库目录”中, 加入下列项目(D:\adroid\cocos2d-2.0x-2.0.3\Debug.win32)(发布时用release目录下的!!) 8、上面的第4、5、6、7条也可以通过如下方法解决: 定位到%USERPROFILE%\appdata\local\microsoft\msbuild\v4.0可以通过运行或直接在windows资源管理器的地址栏中输入使用其他文本编辑工具修改Microsoft.Cpp.Win32.user.props或Microsoft.Cpp.X64.user.props文件中的相关字段。以下是我的文件内容 <IncludePath>D:\android\cocos2d-2.0-x-2.0.3;D:\android\cocos2d-2.0-x-2.0.3\cocos2dx;D:\android\cocos2d-2.0-x-2.0.3\cocos2dx\include;D:\android\cocos2d-2.0-x-2.0.3\cocos2dx\platform;D:\android\cocos2d-2.0-x-2.0.3\cocos2dx\platform\win32;D:\android\cocos2d-2.0-x-2.0.3\cocos2dx\platform\third_party\win32\OGLES;D:\android\cocos2d-2.0-x-2.0.3\external\Box2D;D:\android\cocos2d-2.0-x-2.0.3\CocosDenshion\include;D:\android\cocos2d-2.0-x-2.0.3\cocos2dx\platform\third_party\win32;D:\android\cocos2d-2.0-x-2.0.3\cocos2dx\kazmath\include;$(IncludePath)</IncludePath><LibraryPath>D:\android\cocos2d-2.0-x-2.0.3\Debug.win32;$(LibraryPath)</LibraryPath> 第4至8条的作用是加入解决方案所依赖的头文件和库文件以保证项目的正常编译运行。 五、 如何删除vs里的cocos2d-x模板 1、 打开如下目录 (Example as default install) 1VS2008: C:\Program Files\Microsoft Visual Studio 9.0\VC\vcprojects\ 2VC2008Express: C:\Program Files\Microsoft Visual Studio 9.0\VC\Express\VCProjects 3VS2010: C:\Program Files\Microsoft Visual Studio 10.0\VC\vcprojects\ 4VC2010Express: C:\Program Files\Microsoft Visual Studio 10.0\VC\Express\VCProjects 2、 删除此目录下的 Cocos2d-x文件夹 3、 删除前缀为 CCAppWiz (0.8.0 or later) 或 CCXAppWiz (0.7.2 or earlier)的文件
将项目由win32移植到android平台 一、 快速搭建android开发环境 1、将服务器上的eclipse、java、android sdk、android ndk、cygwin、cocos2d-x文件夹拷贝到本地请注意保存的路径为英文、不包含空格、且不要过长。 2、 运行eclipse添加android-sdk的路径。(preferences->Android:SDK Location) 3、 添加ADT(Help->Install New Software:Work with) 4、添加java环境变量。 新建变量JAVA_HOME变量值为java目录的绝对路径。 在path中添加 %JAVA_HOME%\D:\android\Java\jdk1.6.0_20\bin; %JAVA_HOME%\D:\android\Java\jdk1.6.0_20\jre\bin; D:\android\Java\jre6\bin; 5、运行一次Cygwin.bat 6、修改\cygwin\home\用户名\.bash_profile文件添加NDK_ROOT=/cygdrive/d/android/android-ndk-r8b export NDK_ROOT 7、 修改\cocos2d-2.0-x-2.0.3\create-android-project.bat中的如下路径 set _CYGBIN=e:\cygwin\bin set _ANDROIDTOOLS=e:\android\android-sdk\tools set _NDKROOT=e:\android\android-ndk-r8 二、 新建android项目 1、 运行create-android-project.bat创建新的android项目例如项目名称为Cocos2dDemo。 2、 将win32下完成的.cpp和.h文件拷贝到\Cocos2dDemo\Classes 3、将win32下使用的资源拷贝到\Cocos2dDemo\proj.android\assets 4、将cpp文件的路径、使用的头文件的目录加入到Android.mk文件。 5、打开Cygwincd 到/Cocos2dDemo/proj.android目录下 6、执行./build_native.sh进行编译 7、在eclipse中编译打包。 三、 补充 1、2.0以上版本的引擎基本无法在android模拟器上运行建议在xcode和vs上调试好直接在真机上运行。 2、2.0以上版本的引擎要求android的开发和运行环境都要2.2以上的sdk。
将项目由win32移植到ios 一、 创建ios项目 1、 安装XCode 2、执行install-templates-msvc.bat将模板添加到XCode 3、打开xcode选择Create a new Xcode project选择cocos2d-x模版 4、点击next填入项目名称Man 5、找到Man的主项目在这里新建一个iOS文件夹。点击create创建完成 6、删除Resource和Classes下的多余文件Helloworld的代码和资源 7、右键点击Resource 选择Add Files to "Man"... 7、将Man主项目文件夹下的Resource文件夹中的资源添加到当前工程。注意选择create folder references for any added folders只是添加一个引用 8、同样的方法添加源文件和头文件到Classes下 9、点击Run编译运行 二、 补充 1、Mac 平台的OS X需要10.6及以上版本 2、IOS平台需要4.0及以上版本 3、IOS真机支持iPad 1、iPad 2、iPad 3、 iPhone 3GS、iPhone 4、iPhone 4S、iPhone 5、iphone6、iPod Touch 3 and iPod Touch 4 不支持iPhone and iPhone 3G。

8. android sqlite如何进行封装

一、[代码]DatabaseUtil.java

packagecom.dbexample;
importandroid.content.ContentValues;
importandroid.content.Context;
importandroid.database.Cursor;
importandroid.database.SQLException;
importandroid.database.sqlite.SQLiteDatabase;
importandroid.database.sqlite.SQLiteOpenHelper;
importandroid.util.Log;
publicclassDatabaseUtil{
privatestaticfinalStringTAG="DatabaseUtil";
/**
*DatabaseName
*/
_NAME="student_database";
/**
*DatabaseVersion
*/
privatestaticfinalintDATABASE_VERSION=1;
/**
*TableName
*/
_TABLE="tb_student";
/**
*Tablecolumns
*/
publicstaticfinalStringKEY_NAME="name";
publicstaticfinalStringKEY_GRADE="grade";
publicstaticfinalStringKEY_ROWID="_id";
/**
*Databasecreationsqlstatement
*/
_STUDENT_TABLE=
"createtable"+DATABASE_TABLE+"("+KEY_ROWID+","
+KEY_NAME+"textnotnull,"+KEY_GRADE+"textnotnull);";
/**
*Context
*/
privatefinalContextmCtx;
;
privateSQLiteDatabasemDb;
/**
*Innerprivateclass..
*/
{
DatabaseHelper(Contextcontext){
super(context,DATABASE_NAME,null,DATABASE_VERSION);
}
/**
*'texists.
*/
@Override
publicvoidonCreate(SQLiteDatabasedb){
Log.i(TAG,"CreatingDataBase:"+CREATE_STUDENT_TABLE);
db.execSQL(CREATE_STUDENT_TABLE);
}
/**
*.
*/
@Override
publicvoidonUpgrade(SQLiteDatabasedb,intoldVersion,intnewVersion){
Log.w(TAG,"Upgradingdatabasefromversion"+oldVersion+"to"
+newVersion);
}
}
/**
*Constructor-
*opened/created
*
*@
*/
publicDatabaseUtil(Contextctx){
this.mCtx=ctx;
}
/**
*Thismethodisusedforcreating/openingconnection
*@returninstanceofDatabaseUtil
*@throwsSQLException
*/
publicDatabaseUtilopen()throwsSQLException{
mDbHelper=newDatabaseHelper(mCtx);
mDb=mDbHelper.getWritableDatabase();
returnthis;
}
/**
*.
*/
publicvoidclose(){
mDbHelper.close();
}
/**
*Thismethodisusedtocreate/insertnewrecordStudentrecord.
*@paramname
*@paramgrade
*@returnlong
*/
publiclongcreateStudent(Stringname,Stringgrade){
ContentValuesinitialValues=newContentValues();
initialValues.put(KEY_NAME,name);
initialValues.put(KEY_GRADE,grade);
returnmDb.insert(DATABASE_TABLE,null,initialValues);
}
/**
*.
*@paramrowId
*@returnboolean
*/
publicbooleandeleteStudent(longrowId){
returnmDb.delete(DATABASE_TABLE,KEY_ROWID+"="+rowId,null)>0;
}
/**
*.
*@returnCursor
*/
publicCursorfetchAllStudents(){
returnmDb.query(DATABASE_TABLE,newString[]{KEY_ROWID,KEY_NAME,
KEY_GRADE},null,null,null,null,null);
}
/**
*.
*@paramid
*@returnCursor
*@throwsSQLException
*/
publicCursorfetchStudent(longid)throwsSQLException{
CursormCursor=
mDb.query(true,DATABASE_TABLE,newString[]{KEY_ROWID,
KEY_NAME,KEY_GRADE},KEY_ROWID+"="+id,null,
null,null,null,null);
if(mCursor!=null){
mCursor.moveToFirst();
}
returnmCursor;
}
/**
*.
*@paramid
*@paramname
*@paramstandard
*@returnboolean
*/
publicbooleanupdateStudent(intid,Stringname,Stringstandard){
ContentValuesargs=newContentValues();
args.put(KEY_NAME,name);
args.put(KEY_GRADE,standard);
returnmDb.update(DATABASE_TABLE,args,KEY_ROWID+"="+id,null)>0;
}
}

二、[代码]使用方法

//插入
DatabaseUtildbUtil=newDatabaseUtil(this);
dbUtil.open();
dbUtil.createStudent("PrashantThakkar","10th");
dbUtil.close();
//查询
DatabaseUtildbUtil=newDatabaseUtil(this);
dbUtil.open();
Cursorcursor=dbUtil.fetchAllStudents();
if(cursor!=null){
while(cursor.moveToNext()){
Log.i("Student","StudentName:"+cursor.getString(1)+
"Grade"+cursor.getString(2));
}
}
dbUtil.close();