前段时间因为项目需求，通过百度定位adk写了一个实时更新距离的程序（类似大家坐的士时，车上的里程表），遇到很多技术点，总结了一下发表出来和大家相互学习。直接要求定位具体的位置应该是不难的，只需要引入百度定位adk，并配置相关参数就可以完成，显示百度地图也类似，但是如果需要不断的实时显示移动距离，GPS定位从一个点，到第二个点，从第二个点，到第三个点，从第三个点......，移动距离是多少呢？不得不说，要实现这种需求的确存在一定的难度。

目标：使用百度定位sdk开发实时移动距离计算功能，根据经纬度的定位，计算行驶公里数并实时刷新界面显示。
大家都知道定位有三种方式：GPS 、Wifi 、 基站 .
误差方面的话，使用GPS误差在10左右，Wifi则在20 - 300左右 ，而使用基站则误差在100 - 300左右的样子，因为在室内GPS是定位不到的，必须在室外，
而我们项目的需求正好需要使用GPS定位，所以我们这里设置GPS优先。车，不可能在室内跑吧。


使用技术点：
1.百度定位sdk
2.sqlite数据库(用于保存经纬度和实时更新的距离)
3.通过经纬度计算距离的算法方式
4.TimerTask 、Handler


大概思路：
1）创建项目，上传应用到百度定位sdk获得应用对应key，并配置定位服务成功。
2）将配置的定位代码块放入service中，使程序在后台不断更新经纬度
3）为应用创建数据库和相应的数据表，编写 增删改查 业务逻辑方法
4）编写界面，通过点击按钮控制是否开始计算距离，并引用数据库，初始化表数据，实时刷新界面
5）在service的定位代码块中计算距离，并将距离和经纬度实时的保存在数据库(注：只要经纬度发生改变，计算出来的距离就要进行保存)

6）界面的刷新显示

文章后附源码下载链接

以下是MainActivity中的代码，通过注释可以理解思路流程.

 

[java]  

1. package app.ui.activity;
2. import java.util.Timer;
3. import java.util.TimerTask;
4. import android.content.Intent;
5. import android.os.Bundle;
6. import android.os.Handler;
7. import android.os.Message;
8. import android.view.View;
9. import android.view.WindowManager;
10. import android.widget.Button;
11. import android.widget.TextView;
12. import android.widget.Toast;
13. import app.db.DistanceInfoDao;
14. import app.model.DistanceInfo;
15. import app.service.LocationService;
16. import app.ui.ConfirmDialog;
17. import app.ui.MyApplication;
18. import app.ui.R;
19. import app.utils.ConstantValues;
20. import app.utils.LogUtil;
21. import app.utils.Utils;
22.  
23. public class MainActivity extends Activity {
24.  
25. private TextView mTvDistance; //控件
26. private Button mButton;
27. private TextView mLng_lat;
28. private boolean isStart = true; //是否开始计算移动距离
29.  
30. private DistanceInfoDao mDistanceInfoDao; //数据库
31. private volatile boolean isRefreshUI = true; //是否暂停刷新UI的标识
32. private static final int REFRESH_TIME = 5000; //5秒刷新一次
33.  
34. private Handler refreshHandler = new Handler(){ //刷新界面的Handler
35. public void handleMessage(Message msg) {
36. switch (msg.what) {
37. case ConstantValues.REFRESH_UI:
38. if (isRefreshUI) {
39. LogUtil.info(DistanceComputeActivity.class, refresh ui);
40. DistanceInfo mDistanceInfo = mDistanceInfoDao.getById(MyApplication.orderDealInfoId);
41. LogUtil.info(DistanceComputeActivity.class, 界面刷新---> +mDistanceInfo);
42. if (mDistanceInfo != null) {
43. mTvDistance.setText(String.valueOf(Utils.getValueWith2Suffix(mDistanceInfo.getDistance())));
44. mLng_lat.setText(经:+mDistanceInfo.getLongitude()+ 纬:+mDistanceInfo.getLatitude());
45. mTvDistance.invalidate();
46. mLng_lat.invalidate();
47. }
48. }
49. break;
50. }
51. super.handleMessage(msg);
52. }
53. };
54.  
55. //定时器，每5秒刷新一次UI
56. private Timer refreshTimer = new Timer(true);
57. private TimerTask refreshTask = new TimerTask() {
58. @Override
59. public void run() {
60. if (isRefreshUI) {
61. Message msg = refreshHandler.obtainMessage();
62. msg.what = ConstantValues.REFRESH_UI;
63. refreshHandler.sendMessage(msg);
64. }
65. }
66. };
67.  
68. @Override
69. protected void onCreate(Bundle savedInstanceState) {
70. super.onCreate(savedInstanceState);
71. getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
72. WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); //保持屏幕常亮
73. setContentView(R.layout.activity_expensecompute);
74.  
75. startService(new Intent(this,LocationService.class)); //启动定位服务
76. Toast.makeText(this,已启动定位服务..., 1).show();
77. init(); //初始化相应控件
78. }
79.  
80. private void init(){
81. mTvDistance = (TextView) findViewById(R.id.tv_drive_distance);
82. mDistanceInfoDao = new DistanceInfoDao(this);
83. refreshTimer.schedule(refreshTask, 0, REFRESH_TIME);
84. mButton = (Button)findViewById(R.id.btn_start_drive);
85. mLng_lat = (TextView)findViewById(R.id.longitude_Latitude);
86. }
87.  
88.  
89. @Override
90. public void onClick(View v) {
91. super.onClick(v);
92. switch (v.getId()) {
93. case R.id.btn_start_drive: //计算距离按钮
94. if(isStart)
95. {
96. mButton.setBackgroundResource(R.drawable.btn_selected);
97. mButton.setText(结束计算);
98. isStart = false;
99. DistanceInfo mDistanceInfo = new DistanceInfo();
100. mDistanceInfo.setDistance(0f); //距离初始值
101. mDistanceInfo.setLongitude(MyApplication.lng); //经度初始值
102. mDistanceInfo.setLatitude(MyApplication.lat); //纬度初始值
103. int id = mDistanceInfoDao.insertAndGet(mDistanceInfo); //将值插入数据库，并获得数据库中最大的id
104. if (id != -1) {
105. MyApplication.orderDealInfoId = id; //将id赋值到程序全局变量中(注：该id来决定是否计算移动距离)
106. Toast.makeText(this,已开始计算..., 0).show();
107. }else{
108. Toast.makeText(this,id is -1,无法执行距离计算代码块, 0).show();
109. }
110. }else{
111. //自定义提示框
112. ConfirmDialog dialog = new ConfirmDialog(this, R.style.dialogNoFrame){
113. @Override
114. public void setDialogContent(TextView content) {
115. content.setVisibility(View.GONE);
116. }
117. @Override
118. public void setDialogTitle(TextView title) {
119. title.setText(确认结束计算距离 ？);
120. }
121. @Override
122. public void startMission() {
123. mButton.setBackgroundResource(R.drawable.btn_noselect);
124. mButton.setText(开始计算);
125. isStart = true;
126. isRefreshUI = false; //停止界面刷新
127. if (refreshTimer != null) {
128. refreshTimer.cancel();
129. refreshTimer = null;
130. }
131. mDistanceInfoDao.delete(MyApplication.orderDealInfoId); //删除id对应记录
132. MyApplication.orderDealInfoId = -1; //停止定位计算
133. Toast.makeText(DistanceComputeActivity.this,已停止计算..., 0).show();
134. }
135. };
136. dialog.show();
137. }
138. break;
139. }
140. }
141. }

      

     以下是LocationService中的代码，即配置的百度定位sdk代码块，放在继承了service的类中 LocationService.java (方便程序在后台实时更新经纬度)

      

     [java] 
     1. package app.service;
     2. import java.util.concurrent.Callable;
     3. import java.util.concurrent.ExecutorService;
     4. import java.util.concurrent.Executors;
     5. import android.app.Service;
     6. import android.content.Intent;
     7. import android.os.IBinder;
     8. import app.db.DistanceInfoDao;
     9. import app.model.GpsLocation;
     10. import app.model.DistanceInfo;
     11. import app.ui.MyApplication;
     12. import app.utils.BDLocation2GpsUtil;
     13. import app.utils.FileUtils;
     14. import app.utils.LogUtil;
     15. import com.baidu.location.BDLocation;
     16. import com.baidu.location.BDLocationListener;
     17. import com.baidu.location.LocationClient;
     18. import com.baidu.location.LocationClientOption;
     19. import com.computedistance.DistanceComputeInterface;
     20. import com.computedistance.impl.DistanceComputeImpl;
     21.  
     22. public class LocationService extends Service {
     23.  
     24. public static final String FILE_NAME = log.txt; //日志
     25. LocationClient mLocClient;
     26. private Object lock = new Object();
     27. private volatile GpsLocation prevGpsLocation = new GpsLocation(); //定位数据
     28. private volatile GpsLocation currentGpsLocation = new GpsLocation();
     29. private MyLocationListenner myListener = new MyLocationListenner();
     30. private volatile int discard = 1; //Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。
     31. private DistanceInfoDao mDistanceInfoDao;
     32. private ExecutorService executor = Executors.newSingleThreadExecutor();
     33.  
     34. @Override
     35. public IBinder onBind(Intent intent) {
     36. return null;
     37. }
     38.  
     39. @Override
     40. public void onCreate() {
     41. super.onCreate();
     42. mDistanceInfoDao = new DistanceInfoDao(this); //初始化数据库
     43. //LogUtil.info(LocationService.class, Thread id ----------->: + Thread.currentThread().getId());
     44. mLocClient = new LocationClient(this);
     45. mLocClient.registerLocationListener(myListener);
     46. //定位参数设置
     47. LocationClientOption option = new LocationClientOption();
     48. option.setCoorType(bd09ll); //返回的定位结果是百度经纬度，默认值gcj02
     49. option.setAddrType(all); //返回的定位结果包含地址信息
     50. option.setScanSpan(5000); //设置发起定位请求的间隔时间为5000ms
     51. option.disableCache(true); //禁止启用缓存定位
     52. option.setProdName(app.ui.activity);
     53. option.setOpenGps(true);
     54. option.setPriority(LocationClientOption.GpsFirst); //设置GPS优先
     55. mLocClient.setLocOption(option);
     56. mLocClient.start();
     57. mLocClient.requestLocation();
     58.  
     59. }
     60.  
     61. @Override
     62. @Deprecated
     63. public void onStart(Intent intent, int startId) {
     64. super.onStart(intent, startId);
     65. }
     66.  
     67. @Override
     68. public void onDestroy() {
     69. super.onDestroy();
     70. if (null != mLocClient) {
     71. mLocClient.stop();
     72. }
     73. startService(new Intent(this, LocationService.class));
     74. }
     75.  
     76. private class Task implements Callable{
     77. private BDLocation location;
     78. public Task(BDLocation location){
     79. this.location = location;
     80. }
     81.  
     82. /**
     83. * 检测是否在原地不动
     84. *
     85. * @param distance
     86. * @return
     87. */
     88. private boolean noMove(float distance){
     89. if (distance < 0.01) {
     90. return true;
     91. }
     92. return false;
     93. }
     94.  
     95. /**
     96. * 检测是否在正确的移动
     97. *
     98. * @param distance
     99. * @return
     100. */
     101. private boolean checkProperMove(float distance){
     102. if(distance <= 0.1 * discard){
     103. return true;
     104. }else{
     105. return false;
     106. }
     107. }
     108.  
     109. /**
     110. * 检测获取的数据是否是正常的
     111. *
     112. * @param location
     113. * @return
     114. */
     115. private boolean checkProperLocation(BDLocation location){
     116. if (location != null && location.getLatitude() != 0 && location.getLongitude() != 0){
     117. return true;
     118. }
     119. return false;
     120. }
     121.  
     122. @Override
     123. public String call() throws Exception {
     124. synchronized (lock) {
     125. if (!checkProperLocation(location)){
     126. LogUtil.info(LocationService.class, location data is null);
     127. discard++;
     128. return null;
     129. }
     130.  
     131. if (MyApplication.orderDealInfoId != -1) {
     132. DistanceInfo mDistanceInfo = mDistanceInfoDao.getById(MyApplication.orderDealInfoId); //根据MainActivity中赋值的全局id查询数据库的值
     133. if(mDistanceInfo != null) //不为空则说明车已经开始行使，并可以获得经纬度，计算移动距离
     134. {
     135. LogUtil.info(LocationService.class, 行驶中......);
     136. GpsLocation tempGpsLocation = BDLocation2GpsUtil.convertWithBaiduAPI(location); //位置转换
     137. if (tempGpsLocation != null) {
     138. currentGpsLocation = tempGpsLocation;
     139. }else{
     140. discard ++;
     141. }
     142. //日志
     143. String logMsg = (plat:---> + prevGpsLocation.lat + plgt:---> + prevGpsLocation.lng +) +
     144. (clat:---> + currentGpsLocation.lat + clgt:---> + currentGpsLocation.lng + );
     145. LogUtil.info(LocationService.class, logMsg);
     146.  
     147. /** 计算距离 */
     148. float distance = 0.0f;
     149. DistanceComputeInterface distanceComputeInterface = DistanceComputeImpl.getInstance(); //计算距离类对象
     150. distance = (float) distanceComputeInterface.getLongDistance(prevGpsLocation.lat,prevGpsLocation.lng,
     151. currentGpsLocation.lat,currentGpsLocation.lng); //移动距离计算
     152. if (!noMove(distance)) { //是否在移动
     153. if (checkProperMove(distance)) { //合理的移动
     154. float drivedDistance = mDistanceInfo.getDistance();
     155. mDistanceInfo.setDistance(distance + drivedDistance); //拿到数据库原始距离值， 加上当前值
     156. mDistanceInfo.setLongitude(currentGpsLocation.lng); //经度
     157. mDistanceInfo.setLatitude(currentGpsLocation.lat); //纬度
     158.  
     159. //日志记录
     160. FileUtils.saveToSDCard(FILE_NAME,移动距离--->:+distance+drivedDistance+ +数据库中保存的距离+mDistanceInfo.getDistance());
     161. mDistanceInfoDao.updateDistance(mDistanceInfo);
     162. discard = 1;
     163. }
     164. }
     165. prevGpsLocation = currentGpsLocation;
     166. }
     167. }
     168. return null;
     169. }
     170. }
     171. }
     172.  
     173. /**
     174. * 定位SDK监听函数
     175. */
     176. public class MyLocationListenner implements BDLocationListener {
     177. @Override
     178. public void onReceiveLocation(BDLocation location) {
     179. executor.submit(new Task(location));
     180.  
     181. LogUtil.info(LocationService.class, 经度：+location.getLongitude());
     182. LogUtil.info(LocationService.class, 纬度：+location.getLatitude());
     183. //将经纬度保存于全局变量，在MainActivity中点击按钮时初始化数据库字段
     184. if(MyApplication.lng <=0 && MyApplication.lat <= 0)
     185. {
     186. MyApplication.lng = location.getLongitude();
     187. MyApplication.lat = location.getLatitude();
     188. }
     189. }
     190.  
     191. public void onReceivePoi(BDLocation poiLocation) {
     192. if (poiLocation == null){
     193. return ;
     194. }
     195. }
     196. }
     197. } 以下是应用中需要使用的DBOpenHelper数据库类 DBOpenHelper.java

           

          [java] 
          1. package app.db;
          2. import android.content.Context;
          3. import android.database.sqlite.SQLiteDatabase;
          4. import android.database.sqlite.SQLiteOpenHelper;
          5.  
          6. public class DBOpenHelper extends SQLiteOpenHelper{
          7. private static final int VERSION = 1; //数据库版本号
          8. private static final String DB_NAME = distance.db; //数据库名
          9.  
          10. public DBOpenHelper(Context context){ //创建数据库
          11. super(context, DB_NAME, null, VERSION);
          12. }
          13.  
          14. @Override
          15. public void onCreate(SQLiteDatabase db) { //创建数据表
          16. db.execSQL(CREATE TABLE IF NOT EXISTS milestone(id INTEGER PRIMARY KEY AUTOINCREMENT, distance INTEGER,longitude DOUBLE, latitude DOUBLE ));
          17. }
          18.  
          19. @Override
          20. public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { //版本号发生改变的时
          21. db.execSQL(drop table milestone);
          22. db.execSQL(CREATE TABLE IF NOT EXISTS milestone(id INTEGER PRIMARY KEY AUTOINCREMENT, distance INTEGER,longitude FLOAT, latitude FLOAT ));
          23. }
          24.  
          25. }

               

              以下是应用中需要使用的数据库业务逻辑封装类 DistanceInfoDao.java

               

              [java] 
              1. package app.db;
              2. import android.content.Context;
              3. import android.database.Cursor;
              4. import android.database.sqlite.SQLiteDatabase;
              5. import app.model.DistanceInfo;
              6. import app.utils.LogUtil;
              7.  
              8. public class DistanceInfoDao {
              9. private DBOpenHelper helper;
              10. private SQLiteDatabase db;
              11.  
              12. public DistanceInfoDao(Context context) {
              13. helper = new DBOpenHelper(context);
              14. }
              15.  
              16. public void insert(DistanceInfo mDistanceInfo) {
              17. if (mDistanceInfo == null) {
              18. return;
              19. }
              20. db = helper.getWritableDatabase();
              21. String sql = INSERT INTO milestone(distance,longitude,latitude) VALUES('+ mDistanceInfo.getDistance() + ','+ mDistanceInfo.getLongitude() + ','+ mDistanceInfo.getLatitude() + ');
              22. LogUtil.info(DistanceInfoDao.class, sql);
              23. db.execSQL(sql);
              24. db.close();
              25. }
              26.  
              27. public int getMaxId() {
              28. db = helper.getReadableDatabase();
              29. Cursor cursor = db.rawQuery(SELECT MAX(id) as id from milestone,null);
              30. if (cursor.moveToFirst()) {
              31. return cursor.getInt(cursor.getColumnIndex(id));
              32. }
              33. return -1;
              34. }
              35.  
              36. /**
              37. * 添加数据
              38. * @param orderDealInfo
              39. * @return
              40. */
              41. public synchronized int insertAndGet(DistanceInfo mDistanceInfo) {
              42. int result = -1;
              43. insert(mDistanceInfo);
              44. result = getMaxId();
              45. return result;
              46. }
              47.  
              48. /**
              49. * 根据id获取
              50. * @param id
              51. * @return
              52. */
              53. public DistanceInfo getById(int id) {
              54. db = helper.getReadableDatabase();
              55. Cursor cursor = db.rawQuery(SELECT * from milestone WHERE id = ?,new String[] { String.valueOf(id) });
              56. DistanceInfo mDistanceInfo = null;
              57. if (cursor.moveToFirst()) {
              58. mDistanceInfo = new DistanceInfo();
              59. mDistanceInfo.setId(cursor.getInt(cursor.getColumnIndex(id)));
              60. mDistanceInfo.setDistance(cursor.getFloat(cursor.getColumnIndex(distance)));
              61. mDistanceInfo.setLongitude(cursor.getFloat(cursor.getColumnIndex(longitude)));
              62. mDistanceInfo.setLatitude(cursor.getFloat(cursor.getColumnIndex(latitude)));
              63. }
              64. cursor.close();
              65. db.close();
              66. return mDistanceInfo;
              67. }
              68.  
              69. /**
              70. * 更新距离
              71. * @param orderDealInfo
              72. */
              73. public void updateDistance(DistanceInfo mDistanceInfo) {
              74. if (mDistanceInfo == null) {
              75. return;
              76. }
              77. db = helper.getWritableDatabase();
              78. String sql = update milestone set distance=+ mDistanceInfo.getDistance() +,longitude=+mDistanceInfo.getLongitude()+,latitude=+mDistanceInfo.getLatitude()+ where id = + mDistanceInfo.getId();
              79. LogUtil.info(DistanceInfoDao.class, sql);
              80. db.execSQL(sql);
              81. db.close();
              82. }
              83. }

                   

                  以下是需要使用到的实体类 DistanceInfo.java (set数据到对应变量，以实体类作为参数更新数据库)

                   

                  [java] 
                  1. package app.model;
                  2. public class DistanceInfo {
                  3. private int id;
                  4. private float distance;
                  5. private double longitude;
                  6. private double latitude;
                  7.  
                  8. public int getId() {
                  9. return id;
                  10. }
                  11. public void setId(int id) {
                  12. this.id = id;
                  13. }
                  14. public float getDistance() {
                  15. return distance;
                  16. }
                  17. public void setDistance(float distance) {
                  18. this.distance = distance;
                  19. }
                  20. public double getLongitude() {
                  21.  
                  22. return longitude;
                  23. }
                  24. public void setLongitude(double longitude) {
                  25.  
                  26. this.longitude = longitude;
                  27. }
                  28. public double getLatitude() {
                  29.  
                  30. return latitude;
                  31. }
                  32. public void setLatitude(double latitude) {
                  33.  
                  34. this.latitude = latitude;
                  35. }
                  36. @Override
                  37. public String toString() {
                  38.  
                  39. return DistanceInfo [id= + id + , distance= + distance
                  40. + , longitude= + longitude + , latitude= + latitude + ];
                  41. }
                  42. }
                      保存经纬度信息的类 GpsLocation
                      

                       

                       

                      [java] 
                      1. package app.model;
                      2. public class GpsLocation {
                      3. public double lat;//纬度
                      4. public double lng;//经度
                      5. } 将从百度定位中获得的经纬度转换为精准的GPS数据 BDLocation2GpsUtil.java
                         

                          

                         [java] view plaincopyprint?
                         1. package app.utils;
                         2. import it.sauronsoftware.base64.Base64;
                         3. import java.io.BufferedReader;
                         4. import java.io.IOException;
                         5. import java.io.InputStreamReader;
                         6. import java.net.HttpURLConnection;
                         7. import java.net.URL;
                         8. import org.json.JSONObject;
                         9. import app.model.GpsLocation;
                         10. import com.baidu.location.BDLocation;
                         11. public class BDLocation2GpsUtil {
                         12. static BDLocation tempBDLocation = new BDLocation(); // 临时变量，百度位置
                         13. static GpsLocation tempGPSLocation = new GpsLocation(); // 临时变量，gps位置
                         14. public static enum Method{
                         15. origin, correct;
                         16. }
                         17. private static final Method method = Method.correct;
                         18. /**
                         19. * 位置转换
                         20. *
                         21. * @param lBdLocation 百度位置
                         22. * @return GPS位置
                         23. */
                         24. public static GpsLocation convertWithBaiduAPI(BDLocation lBdLocation) {
                         25. switch (method) {
                         26. case origin: //原点
                         27. GpsLocation location = new GpsLocation();
                         28. location.lat = lBdLocation.getLatitude();
                         29. location.lng = lBdLocation.getLongitude();
                         30. return location;
                         31. case correct: //纠偏
                         32. //同一个地址不多次转换
                         33. if (tempBDLocation.getLatitude() == lBdLocation.getLatitude() && tempBDLocation.getLongitude() == lBdLocation.getLongitude()) {
                         34. return tempGPSLocation;
                         35. }
                         36. String url = http://api.map.baidu.com/ag/coord/convert?from=0&to=4&
                         37. + x= + lBdLocation.getLongitude() + &y=
                         38. + lBdLocation.getLatitude();
                         39. String result = executeHttpGet(url);
                         40. LogUtil.info(BDLocation2GpsUtil.class, result: + result);
                         41. if (result != null) {
                         42. GpsLocation gpsLocation = new GpsLocation();
                         43. try {
                         44. JSONObject jsonObj = new JSONObject(result);
                         45. String lngString = jsonObj.getString(x);
                         46. String latString = jsonObj.getString(y);
                         47. // 解码
                         48. double lng = Double.parseDouble(new String(Base64.decode(lngString)));
                         49. double lat = Double.parseDouble(new String(Base64.decode(latString)));
                         50. // 换算
                         51. gpsLocation.lng = 2 * lBdLocation.getLongitude() - lng;
                         52. gpsLocation.lat = 2 * lBdLocation.getLatitude() - lat;
                         53. tempGPSLocation = gpsLocation;
                         54. LogUtil.info(BDLocation2GpsUtil.class, result: + gpsLocation.lat + || + gpsLocation.lng);
                         55. } catch (Exception e) {
                         56. e.printStackTrace();
                         57. return null;
                         58. }
                         59. tempBDLocation = lBdLocation;
                         60. return gpsLocation;
                         61. }else{
                         62. LogUtil.info(BDLocation2GpsUtil.class, 百度API执行出错,url is: + url);
                         63. return null;
                         64. }
                         65. }
                         66. }
                         67. }
                             需要声明相关权限，且项目中所用到的jar有：
                             android-support-v4.jar
                             commons-codec.jar
                             commons-lang3-3.0-beta.jar
                             javabase64-1.3.1.jar
                             locSDK_3.1.jar
                             

                              

                             Android中计算地图上两点距离的算法

                             
                             项目中目前尚有部分不健全的地方，如：
                             1.在行驶等待时间较长后，使用TimerTask 、Handler刷新界面是偶尔会出现卡住的现象，车仍在行驶，
                             但是数据不动了，通过改善目前测试近7次未出现此问题。
                             

                             2.较快的消耗电量

                             源码下载地址