Android 百度地图 SDK v3.0.0 （二） 定位与结合方向传感器

在上一篇博客中，我们成功把地图导入了我们的项目。本篇我们准备为地图添加：第一，定位功能；第二，与方向传感器结合，通过旋转手机进行道路的方向确认。有了这两个功能，地图已经可以为我服务了~~~~

效果图：

好了，可以代码，为了方便，我把所有的按钮都放到了menu菜单中。

1、初次启动定位

[java] view plaincopy

1. /**
2. * 定位的客户端
3. */
4. private LocationClient mLocationClient;
5. /**
6. * 定位的监听器
7. */
8. public MyLocationListener mMyLocationListener;
9. /**
10. * 当前定位的模式
11. */
12. private LocationMode mCurrentMode = LocationMode.NORMAL;
13. /***
14. * 是否是第一次定位
15. */
16. private volatile boolean isFristLocation = true;
17. /**
18. * 初始化定位相关代码
19. */
20. private void initMyLocation()
21. {
22. // 定位初始化
23. mLocationClient = new LocationClient(this);
24. mMyLocationListener = new MyLocationListener();
25. mLocationClient.registerLocationListener(mMyLocationListener);
26. // 设置定位的相关配置
27. LocationClientOption option = new LocationClientOption();
28. option.setOpenGps(true);// 打开gps
29. option.setCoorType("bd09ll"); // 设置坐标类型
30. option.setScanSpan(1000);
31. mLocationClient.setLocOption(option);
32. }

然后是定位的监听器MyLocationListener：

[java] view plaincopy

1. /**
2. * 实现实位回调监听
3. */
4. public class MyLocationListener implements BDLocationListener
5. {
6. @Override
7. public void onReceiveLocation(BDLocation location)
8. {
9. // map view 销毁后不在处理新接收的位置
10. if (location == null || mMapView == null)
11. return;
12. // 构造定位数据
13. MyLocationData locData = new MyLocationData.Builder()
14. .accuracy(location.getRadius())
15. // 此处设置开发者获取到的方向信息，顺时针0-360
16. .direction(mXDirection).latitude(location.getLatitude())
17. .longitude(location.getLongitude()).build();
18. mCurrentAccracy = location.getRadius();
19. // 设置定位数据
20. mBaiduMap.setMyLocationData(locData);
21. mCurrentLantitude = location.getLatitude();
22. mCurrentLongitude = location.getLongitude();
23. // 设置自定义图标
24. BitmapDescriptor mCurrentMarker = BitmapDescriptorFactory
25. .fromResource(R.drawable.navi_map_gps_locked);
26. MyLocationConfigeration config = new MyLocationConfigeration(
27. mCurrentMode, true, mCurrentMarker);
28. mBaiduMap.setMyLocationConfigeration(config);
29. // 第一次定位时，将地图位置移动到当前位置
30. if (isFristLocation)
31. {
32. isFristLocation = false;
33. LatLng ll = new LatLng(location.getLatitude(),
34. location.getLongitude());
35. MapStatusUpdate u = MapStatusUpdateFactory.newLatLng(ll);
36. mBaiduMap.animateMapStatus(u);
37. }
38. }
39. }

可以看到，我们初始化了定位的参数，设置了定位的监听器，每隔1s会进行一次定位，应用打开时，第一定位，会把地图中心设置当前用户位置。
定位也是比较耗电的，所以我们在onStart中开启定位，在onStop中关闭定位~~这样应用最小化时就不会一直在哪GPS请求定位了，用户要是看你app一直在那定位，估计马上就被卸载了~

[java] view plaincopy

1. @Override
2. protected void onStart()
3. {
4. // 开启图层定位
5. mBaiduMap.setMyLocationEnabled(true);
6. if (!mLocationClient.isStarted())
7. {
8. mLocationClient.start();
9. }
10. // 开启方向传感器
11. myOrientationListener.start();
12. super.onStart();
13. }
14. @Override
15. protected void onStop()
16. {
17. // 关闭图层定位
18. mBaiduMap.setMyLocationEnabled(false);
19. mLocationClient.stop();
20. // 关闭方向传感器
21. myOrientationListener.stop();
22. super.onStop();
23. }

上面的传感器的代码，一会就会介绍~

记得在AndroidManifest.xml配一个service

[html] view plaincopy

1. <service
2. android:name="com.baidu.location.f"
3. android:enabled="true"
4. android:process=":remote" >
5. <intent-filter>
6. <action android:name="com.baidu.location.service_v2.2" >
7. </action>
8. </intent-filter>
9. </service>

现在基本的定位功能已经实现了~不过我们还需要添加点击定位按钮和方向传感器

2、我的位置

点击我的位置菜单会调用center2myLoc方法。

[java] view plaincopy

1. case R.id.id_menu_map_myLoc:
2. center2myLoc();
3. break;

[java] view plaincopy

1. /**
2. * 地图移动到我的位置,此处可以重新发定位请求，然后定位；
3. * 直接拿最近一次经纬度，如果长时间没有定位成功，可能会显示效果不好
4. */
5. private void center2myLoc()
6. {
7. LatLng ll = new LatLng(mCurrentLantitude, mCurrentLongitude);
8. MapStatusUpdate u = MapStatusUpdateFactory.newLatLng(ll);
9. mBaiduMap.animateMapStatus(u);
10. }

很简单，我们在定位的监听器中已经保存了最近一次的定位经纬度，所以只需要点击时，把地图移动到相应的位置即可。

3、集成方向传感器

首先是封装的方向传感器的类MyOrientationListener.java

[java] view plaincopy

1. package com.zhy.zhy_baidu_ditu_demo00;
2. import android.content.Context;
3. import android.hardware.Sensor;
4. import android.hardware.SensorEvent;
5. import android.hardware.SensorEventListener;
6. import android.hardware.SensorManager;
7. public class MyOrientationListener implements SensorEventListener
8. {
9. private Context context;
10. private SensorManager sensorManager;
11. private Sensor sensor;
12. private float lastX ;
13. private OnOrientationListener onOrientationListener ;
14. public MyOrientationListener(Context context)
15. {
16. this.context = context;
17. }
18. // 开始
19. public void start()
20. {
21. // 获得传感器管理器
22. sensorManager = (SensorManager) context
23. .getSystemService(Context.SENSOR_SERVICE);
24. if (sensorManager != null)
25. {
26. // 获得方向传感器
27. sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);
28. }
29. // 注册
30. if (sensor != null)
31. {//SensorManager.SENSOR_DELAY_UI
32. sensorManager.registerListener(this, sensor,
33. SensorManager.SENSOR_DELAY_UI);
34. }
35. }
36. // 停止检测
37. public void stop()
38. {
39. sensorManager.unregisterListener(this);
40. }
41. @Override
42. public void onAccuracyChanged(Sensor sensor, int accuracy)
43. {
44. }
45. @Override
46. public void onSensorChanged(SensorEvent event)
47. {
48. // 接受方向感应器的类型
49. if (event.sensor.getType() == Sensor.TYPE_ORIENTATION)
50. {
51. // 这里我们可以得到数据，然后根据需要来处理
52. float x = event.values[SensorManager.DATA_X];
53. if( Math.abs(x- lastX) > 1.0 )
54. {
55. onOrientationListener.onOrientationChanged(x);
56. }
57. //            Log.e("DATA_X", x+"");
58. lastX = x ;
59. }
60. }
61. public void setOnOrientationListener(OnOrientationListener onOrientationListener)
62. {
63. this.onOrientationListener = onOrientationListener ;
64. }
65. public interface OnOrientationListener
66. {
67. void onOrientationChanged(float x);
68. }
69. }

在onCreate中初始化方向传感器

[java] view plaincopy

1. /**
2. * 初始化方向传感器
3. */
4. private void initOritationListener()
5. {
6. myOrientationListener = new MyOrientationListener(
7. getApplicationContext());
8. myOrientationListener
9. .setOnOrientationListener(new OnOrientationListener()
10. {
11. @Override
12. public void onOrientationChanged(float x)
13. {
14. mXDirection = (int) x;
15. // 构造定位数据
16. MyLocationData locData = new MyLocationData.Builder()
17. .accuracy(mCurrentAccracy)
18. // 此处设置开发者获取到的方向信息，顺时针0-360
19. .direction(mXDirection)
20. .latitude(mCurrentLantitude)
21. .longitude(mCurrentLongitude).build();
22. // 设置定位数据
23. mBaiduMap.setMyLocationData(locData);
24. // 设置自定义图标
25. BitmapDescriptor mCurrentMarker = BitmapDescriptorFactory
26. .fromResource(R.drawable.navi_map_gps_locked);
27. MyLocationConfigeration config = new MyLocationConfigeration(
28. mCurrentMode, true, mCurrentMarker);
29. mBaiduMap.setMyLocationConfigeration(config);
30. }
31. });
32. }

最后在onStart和onStop中分别开启和关闭方向传感器。

对于旋转手机确定方向，实际上利用了

[java] view plaincopy

1. new MyLocationData.Builder()
2. //
   此处设置开发者获取到的方向信息，顺时针
   0-360                                                                                                .direction(mXDirection)

只需要把x方向的角度设置即可~~~是不是很简单~~~

好了，介绍完毕了，关闭地图样式的切换，以及跟随、罗盘等模式的切换就不介绍了，大家自己看下源码~~

转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/37730469

Android 百度地图 SDK v3.0.0 （二） 定位与结合方向传感器,布布扣,bubuko.com