百度——地图API——Android—应用集成离线地图

有离线地图，真的挺方便的。具体可以看看我的应用。

http://as.baidu.com/a/item?docid=4120392&pre=web_am_se

最近有网友不知道如何将离线的百度地图，打包在应用中发布。所以整理了这篇博客与大家分享。

 

1.使用离线地图。经过测试，首次必须在线验证百度的APIKey。

2.离线地图文件，放到res/raw目录下。参见下图。

3.编写代码拷贝函数。

[java] view plain copy print ?

1. package com.kkstudio.db;  
2.   
3. import java.io.File;  
4. import java.io.FileNotFoundException;  
5. import java.io.FileOutputStream;  
6. import java.io.IOException;  
7. import java.io.InputStream;  
8.   
9. import com.kkstudio.parkcar.R;  
10.   
11. import android.content.Context;  
12. import android.database.sqlite.SQLiteDatabase;  
13. import android.os.Environment;  
14. import android.util.Log;  
15.   
16. public class DBReleasFromAPK {  
17.     /** Called when the activity is first created. */     
18.     private static String APK_PATHNAME = "parkcar";  
19.       
20.     // SD卡下的目录  
21.     private final String DATABASE_PATH = Environment.getExternalStorageDirectory().getPath() + "/" + APK_PATHNAME;  
22.       
23.     private final String MAP_FILENAME = "beijing_131.dat";  
24.     private final String MAP_FILEPATH = Environment.getExternalStorageDirectory().getPath() + "/BaiduMapSdk/vmp/h/";  
25.       
26.     // 数据库名  
27.     private final String DATABASE_FILENAME = "data.db";  
28.     private final String IMAGE_FILENAME = "defaultimg.jpg";  
29.     private final String DEFAULT_IMAGE_FILENAME = "default.jpg";  
30.       
31.     private final String DEFAULT_IMAGE_06FILENAME = "06.jpg";  
32.       
33.     // 这个context是必需的，没有context，怎么都不能实现数据库的拷贝操作；  
34.     private Context context;  
35.   
36.     // 构造函数必需传入Context，数据库的操作都带有这个参数的传入  
37.     public DBReleasFromAPK(Context ctx) {  
38.         this.context = ctx;  
39. //      APK_PATHNAME = this.context.getString(R.string.app_name);  
40.     }  
41.   
42.     public SQLiteDatabase OpenDataBase() {  
43.         try {  
44.             String imageFilename = DATABASE_PATH + "/" + IMAGE_FILENAME;  
45.             String defaultimageFilename = DATABASE_PATH + "/" + DEFAULT_IMAGE_FILENAME;  
46.             String default06imageFilename = DATABASE_PATH + "/" + DEFAULT_IMAGE_06FILENAME;  
47.               
48.             String mapFilename =  MAP_FILEPATH + MAP_FILENAME;  
49.               
50.             String databaseFilename = DATABASE_PATH + "/" + DATABASE_FILENAME;  
51.             File dir = new File(DATABASE_PATH);  
52.             // 判断SD卡下是否存在存放数据库的目录，如果不存在，新建目录  
53.             if (!dir.exists()) {  
54.                 dir.mkdir();  
55.                 Log.i("ReleaseDataBaseActivity", "dir made:" + DATABASE_PATH);  
56.             } else {  
57.                 Log.i("ReleaseDataBaseActivity", "dir exist:" + DATABASE_PATH);  
58.             }  
59.             try {  
60.                 // 如果数据库已经在SD卡的目录下存在，那么不需要重新创建，否则创建文件，并拷贝/res/raw下面的数据库文件  
61.                 if (!(new File(databaseFilename)).exists()) {  
62.                     Log.i("ReleaseDataBaseActivity", "file not exist:"  
63.                             + databaseFilename);  
64.                     // /res/raw数据库作为输出流  
65.                     InputStream is = this.context.getResources()  
66.                             .openRawResource(R.raw.data);  
67.                     // 测试用  
68.                     int size = is.available();  
69.                     Log.i("ReleaseDataBaseActivity", "DATABASE_SIZE:" + 1);  
70.                     Log.i("ReleaseDataBaseActivity", "count:" + 0);  
71.                     // 用于存放数据库信息的数据流  
72.                     FileOutputStream fos = new FileOutputStream(  
73.                             databaseFilename);  
74.                     byte[] buffer = new byte[8192];  
75.                     int count = 0;  
76.                     Log.i("ReleaseDataBaseActivity", "count:" + count);  
77.                     // 把数据写入SD卡目录下  
78.                     while ((count = is.read(buffer)) > 0) {  
79.                         fos.write(buffer, 0, count);  
80.                     }  
81.                     fos.flush();  
82.                     fos.close();  
83.                     is.close();  
84.                 }  
85.                   
86.                 // patch image file  
87.                 if (!(new File(defaultimageFilename)).exists()) {  
88.                     // /res/raw数据库作为输出流  
89.                     InputStream is = this.context.getResources()  
90.                             .openRawResource(R.raw.defaultimg);  
91.                     // 测试用  
92.                     int size = is.available();  
93.                     // 用于存放数据库信息的数据流  
94.                     FileOutputStream fos = new FileOutputStream(  
95.                             defaultimageFilename);  
96.                     byte[] buffer = new byte[8192];  
97.                     int count = 0;                    
98.                     // 把数据写入SD卡目录下  
99.                     while ((count = is.read(buffer)) > 0) {  
100.                         fos.write(buffer, 0, count);  
101.                     }  
102.                     fos.flush();  
103.                     fos.close();  
104.                     is.close();  
105.                 }  
106.                   
107.                 // patch 06.jpg  
108.                 if (!(new File(default06imageFilename)).exists()) {  
109.                     // /res/raw数据库作为输出流  
110.                     InputStream is = this.context.getResources()  
111.                             .openRawResource(R.raw.defaultimg);  
112.                     // 测试用  
113.                     int size = is.available();  
114.                     // 用于存放数据库信息的数据流  
115.                     FileOutputStream fos = new FileOutputStream(  
116.                             default06imageFilename);  
117.                     byte[] buffer = new byte[8192];  
118.                     int count = 0;                    
119.                     // 把数据写入SD卡目录下  
120.                     while ((count = is.read(buffer)) > 0) {  
121.                         fos.write(buffer, 0, count);  
122.                     }  
123.                     fos.flush();  
124.                     fos.close();  
125.                     is.close();  
126.                 }  
127.   
128.                 // patch download beijing map  
129.                 if (!(new File(mapFilename)).exists()) {  
130.                     // /res/raw数据库作为输出流  
131.                     InputStream is = this.context.getResources()  
132.                             .openRawResource(R.raw.beijing_131);  
133.                     // 测试用  
134.                     int size = is.available();  
135.                     // 用于存放数据库信息的数据流  
136.                     FileOutputStream fos = new FileOutputStream(  
137.                             mapFilename);  
138.                     byte[] buffer = new byte[8192];  
139.                     int count = 0;                    
140.                     // 把数据写入SD卡目录下  
141.                     while ((count = is.read(buffer)) > 0) {  
142.                         fos.write(buffer, 0, count);  
143.                     }  
144.                     fos.flush();  
145.                     fos.close();  
146.                     is.close();  
147.                 }  
148.   
149.                   
150.             } catch (FileNotFoundException e) {  
151.                 Log.e("Database", "File not found");  
152.                 e.printStackTrace();  
153.             } catch (IOException e) {  
154.                 Log.e("Database", "IO exception");  
155.                 e.printStackTrace();  
156.             }  
157.               
158.             // 实例化sd卡上得数据库，database作为返回值，是后面所有插入，删除，查询操作的借口。  
159.             SQLiteDatabase database = SQLiteDatabase.openOrCreateDatabase(  
160.                     databaseFilename, null);  
161.             return database;  
162.   
163.         } catch (Exception e) {  
164.         }  
165.           
166.         return null;  
167.     }  
168.   
169. }  

package com.kkstudio.db;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

import com.kkstudio.parkcar.R;

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

public class DBReleasFromAPK {
	/** Called when the activity is first created. */	
	private static String APK_PATHNAME = "parkcar";
	
	// SD卡下的目录
	private final String DATABASE_PATH = Environment.getExternalStorageDirectory().getPath() + "/" + APK_PATHNAME;
	
	private final String MAP_FILENAME = "beijing_131.dat";
	private final String MAP_FILEPATH = Environment.getExternalStorageDirectory().getPath() + "/BaiduMapSdk/vmp/h/";
	
	// 数据库名
	private final String DATABASE_FILENAME = "data.db";
	private final String IMAGE_FILENAME = "defaultimg.jpg";
	private final String DEFAULT_IMAGE_FILENAME = "default.jpg";
	
	private final String DEFAULT_IMAGE_06FILENAME = "06.jpg";
	
	// 这个context是必需的，没有context，怎么都不能实现数据库的拷贝操作；
	private Context context;

	// 构造函数必需传入Context，数据库的操作都带有这个参数的传入
	public DBReleasFromAPK(Context ctx) {
		this.context = ctx;
//		APK_PATHNAME = this.context.getString(R.string.app_name);
	}

	public SQLiteDatabase OpenDataBase() {
		try {
			String imageFilename = DATABASE_PATH + "/" + IMAGE_FILENAME;
			String defaultimageFilename = DATABASE_PATH + "/" + DEFAULT_IMAGE_FILENAME;
			String default06imageFilename = DATABASE_PATH + "/" + DEFAULT_IMAGE_06FILENAME;
			
			String mapFilename =  MAP_FILEPATH + MAP_FILENAME;
			
			String databaseFilename = DATABASE_PATH + "/" + DATABASE_FILENAME;
			File dir = new File(DATABASE_PATH);
			// 判断SD卡下是否存在存放数据库的目录，如果不存在，新建目录
			if (!dir.exists()) {
				dir.mkdir();
				Log.i("ReleaseDataBaseActivity", "dir made:" + DATABASE_PATH);
			} else {
				Log.i("ReleaseDataBaseActivity", "dir exist:" + DATABASE_PATH);
			}
			try {
				// 如果数据库已经在SD卡的目录下存在，那么不需要重新创建，否则创建文件，并拷贝/res/raw下面的数据库文件
				if (!(new File(databaseFilename)).exists()) {
					Log.i("ReleaseDataBaseActivity", "file not exist:"
							+ databaseFilename);
					// /res/raw数据库作为输出流
					InputStream is = this.context.getResources()
							.openRawResource(R.raw.data);
					// 测试用
					int size = is.available();
					Log.i("ReleaseDataBaseActivity", "DATABASE_SIZE:" + 1);
					Log.i("ReleaseDataBaseActivity", "count:" + 0);
					// 用于存放数据库信息的数据流
					FileOutputStream fos = new FileOutputStream(
							databaseFilename);
					byte[] buffer = new byte[8192];
					int count = 0;
					Log.i("ReleaseDataBaseActivity", "count:" + count);
					// 把数据写入SD卡目录下
					while ((count = is.read(buffer)) > 0) {
						fos.write(buffer, 0, count);
					}
					fos.flush();
					fos.close();
					is.close();
				}
				
				// patch image file
				if (!(new File(defaultimageFilename)).exists()) {
					// /res/raw数据库作为输出流
					InputStream is = this.context.getResources()
							.openRawResource(R.raw.defaultimg);
					// 测试用
					int size = is.available();
					// 用于存放数据库信息的数据流
					FileOutputStream fos = new FileOutputStream(
							defaultimageFilename);
					byte[] buffer = new byte[8192];
					int count = 0;					
					// 把数据写入SD卡目录下
					while ((count = is.read(buffer)) > 0) {
						fos.write(buffer, 0, count);
					}
					fos.flush();
					fos.close();
					is.close();
				}
				
				// patch 06.jpg
				if (!(new File(default06imageFilename)).exists()) {
					// /res/raw数据库作为输出流
					InputStream is = this.context.getResources()
							.openRawResource(R.raw.defaultimg);
					// 测试用
					int size = is.available();
					// 用于存放数据库信息的数据流
					FileOutputStream fos = new FileOutputStream(
							default06imageFilename);
					byte[] buffer = new byte[8192];
					int count = 0;					
					// 把数据写入SD卡目录下
					while ((count = is.read(buffer)) > 0) {
						fos.write(buffer, 0, count);
					}
					fos.flush();
					fos.close();
					is.close();
				}

				// patch download beijing map
				if (!(new File(mapFilename)).exists()) {
					// /res/raw数据库作为输出流
					InputStream is = this.context.getResources()
							.openRawResource(R.raw.beijing_131);
					// 测试用
					int size = is.available();
					// 用于存放数据库信息的数据流
					FileOutputStream fos = new FileOutputStream(
							mapFilename);
					byte[] buffer = new byte[8192];
					int count = 0;					
					// 把数据写入SD卡目录下
					while ((count = is.read(buffer)) > 0) {
						fos.write(buffer, 0, count);
					}
					fos.flush();
					fos.close();
					is.close();
				}

				
			} catch (FileNotFoundException e) {
				Log.e("Database", "File not found");
				e.printStackTrace();
			} catch (IOException e) {
				Log.e("Database", "IO exception");
				e.printStackTrace();
			}
			
			// 实例化sd卡上得数据库，database作为返回值，是后面所有插入，删除，查询操作的借口。
			SQLiteDatabase database = SQLiteDatabase.openOrCreateDatabase(
					databaseFilename, null);
			return database;

		} catch (Exception e) {
		}
		
		return null;
	}

}

4.启动类的onCreate中，调用即可。

[java] view plain copy print ?

1. DBReleasFromAPK dbapk = new DBReleasFromAPK(this);  
2. SQLiteDatabase dbsqlite = dbapk.OpenDataBase();  

	    DBReleasFromAPK dbapk = new DBReleasFromAPK(this);
	    SQLiteDatabase dbsqlite = dbapk.OpenDataBase();

5.剩下的就是别忘记了。修改AndroidManifest.xml，添加存储功能。

6.祝你好运。