Android教程網 >> Android技術 >> 關於Android編程 >> Android百度地圖結合方向傳感器我們自己定位哪裡走

Android百度地圖結合方向傳感器我們自己定位哪裡走

編輯：關於Android編程

本篇我們准備為地圖添加：第一，定位功能；第二，與方向傳感器結合，通過旋轉手機進行道路的方向確認。有了這兩個功能，地圖已經可以為我服務了

@一啟動就自動定位了

a，MainActivity 中添加定位代碼，定位的監聽器MyLocationListener

b，封裝的方向傳感器的類MyOrientationListener

c，記得在AndroidManifest.xml配一個service

我剛開始看的時候差點蒙了，因為筆者思路很清晰，可是我不懂啊，最後我總結了下，其實就是改了上面的三個文件，下載他的代碼看了，有些還沒用到，就放進來了，我整理了好大一會才明白，

還有就是鴻洋大神有好大一個bug，害我浪費一個小時，

import com.baidu.mapapi.map.MyLocationConfigeration;

看者沒問題吧，但是報錯，開始我以為百度包有問題，是不是我沒把百度demo上的包導入正確啊，然後各種查詢，網上各種解決。。cannot resovle。。。

最後我發現是MyLocationConfiguration

一個字母一個字母對去吧。。。

好了，不說了，下面給大家附上我的代碼。。

有興趣的話可以compare一下上篇的代碼

記住還是真機測試

實現功能有普通地圖，衛星地圖，實時交通

普通地圖
衛星地圖

布局文件或者素材

這裡寫圖片描述

下面是我實現的代碼

布局文件：activity_main.xml

`展示視圖控制文件：MainActivity`

package com.yang.baidumapceshi;
import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.Window;

import com.baidu.location.BDLocation;
import com.baidu.location.BDLocationListener;
import com.baidu.location.LocationClient;
import com.baidu.location.LocationClientOption;
import com.baidu.mapapi.SDKInitializer;
import com.baidu.mapapi.map.BaiduMap;
import com.baidu.mapapi.map.BitmapDescriptor;
import com.baidu.mapapi.map.BitmapDescriptorFactory;
import com.baidu.mapapi.map.MapStatusUpdate;
import com.baidu.mapapi.map.MapStatusUpdateFactory;
import com.baidu.mapapi.map.MapView;
import com.baidu.mapapi.map.MyLocationConfiguration;
import com.baidu.mapapi.map.MyLocationConfiguration.LocationMode;
import com.baidu.mapapi.map.MyLocationData;
import com.baidu.mapapi.model.LatLng;
import com.yang.baidumapceshi.MyOrientationListener.OnOrientationListener;

import java.lang.reflect.Method;

public class MainActivity extends Activity
{
    /**
     * 地圖控件
     */
    private MapView mMapView = null;
    /**
     * 地圖實例
     */
    private BaiduMap mBaiduMap;
    /**
     * 定位的客戶端
     */
    private LocationClient mLocationClient;
    /**
     * 定位的監聽器
     */
    public MyLocationListener mMyLocationListener;
    /**
     * 當前定位的模式
     */
    private LocationMode mCurrentMode = LocationMode.NORMAL;
    /***
     * 是否是第一次定位
     */
    private volatile boolean isFristLocation = true;

    /**
     * 最新一次的經緯度
     */
    private double mCurrentLantitude;
    private double mCurrentLongitude;
    /**
     * 當前的精度
     */
    private float mCurrentAccracy;
    /**
     * 方向傳感器的監聽器
     */
    private MyOrientationListener myOrientationListener;
    /**
     * 方向傳感器X方向的值
     */
    private int mXDirection;

    /**
     * 地圖定位的模式
     */
    private String[] mStyles = new String[] { "地圖模式【正常】", "地圖模式【跟隨】",
            "地圖模式【羅盤】" };
    private int mCurrentStyle = 0;

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);

        requestWindowFeature(Window.FEATURE_NO_TITLE);
        // 注意該方法要再setContentView方法之前實現
        SDKInitializer.initialize(getApplicationContext());
        setContentView(R.layout.activity_main);
        // 第一次定位
        isFristLocation = true;
        // 獲取地圖控件引用
        mMapView = (MapView) findViewById(R.id.id_bmapView);
        // 獲得地圖的實例
        mBaiduMap = mMapView.getMap();
        MapStatusUpdate msu = MapStatusUpdateFactory.zoomTo(15.0f);
        mBaiduMap.setMapStatus(msu);
        // 初始化定位
        initMyLocation();
        // 初始化傳感器
        initOritationListener();

    }

    /**
     * 初始化方向傳感器
     */
    private void initOritationListener()
    {
        myOrientationListener = new MyOrientationListener(
                getApplicationContext());
        myOrientationListener
                .setOnOrientationListener(new OnOrientationListener()
                {
                    @Override
                    public void onOrientationChanged(float x)
                    {
                        mXDirection = (int) x;

                        // 構造定位數據
                        MyLocationData locData = new MyLocationData.Builder()
                                .accuracy(mCurrentAccracy)
                                // 此處設置開發者獲取到的方向信息，順時針0-360
                                .direction(mXDirection)
                                .latitude(mCurrentLantitude)
                                .longitude(mCurrentLongitude).build();
                        // 設置定位數據
                        mBaiduMap.setMyLocationData(locData);
                        // 設置自定義圖標
                        BitmapDescriptor mCurrentMarker = BitmapDescriptorFactory
                                .fromResource(R.mipmap.navi_map_gps_locked);
                        MyLocationConfiguration config = new MyLocationConfiguration(
                                mCurrentMode, true, mCurrentMarker);
                        mBaiduMap.setMyLocationConfigeration(config);

                    }
                });
    }

    /**
     * 初始化定位相關代碼
     */
    private void initMyLocation()
    {
        // 定位初始化
        mLocationClient = new LocationClient(this);
        mMyLocationListener = new MyLocationListener();
        mLocationClient.registerLocationListener(mMyLocationListener);
        // 設置定位的相關配置
        LocationClientOption option = new LocationClientOption();
        option.setOpenGps(true);// 打開gps
        option.setCoorType("bd09ll"); // 設置坐標類型
        option.setScanSpan(1000);
        mLocationClient.setLocOption(option);
    }

    /**
     * 實現實位回調監聽
     */
    public class MyLocationListener implements BDLocationListener
    {
        @Override
        public void onReceiveLocation(BDLocation location)
        {

            // map view 銷毀後不在處理新接收的位置
            if (location == null || mMapView == null)
                return;
            // 構造定位數據
            MyLocationData locData = new MyLocationData.Builder()
                    .accuracy(location.getRadius())
                    // 此處設置開發者獲取到的方向信息，順時針0-360
                    .direction(mXDirection).latitude(location.getLatitude())
                    .longitude(location.getLongitude()).build();
            mCurrentAccracy = location.getRadius();
            // 設置定位數據
            mBaiduMap.setMyLocationData(locData);
            mCurrentLantitude = location.getLatitude();
            mCurrentLongitude = location.getLongitude();
            // 設置自定義圖標
            BitmapDescriptor mCurrentMarker = BitmapDescriptorFactory
                    .fromResource(R.mipmap.navi_map_gps_locked);
            MyLocationConfiguration config = new MyLocationConfiguration(
                    mCurrentMode, true, mCurrentMarker);
            mBaiduMap.setMyLocationConfigeration(config);
            // 第一次定位時，將地圖位置移動到當前位置
            if (isFristLocation)
            {
                isFristLocation = false;
                LatLng ll = new LatLng(location.getLatitude(),
                        location.getLongitude());
                MapStatusUpdate u = MapStatusUpdateFactory.newLatLng(ll);
                mBaiduMap.animateMapStatus(u);
            }
        }

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu)
    {
        getMenuInflater().inflate(R.menu.main, menu);
        return super.onCreateOptionsMenu(menu);
    }

    /**
     * 默認點擊menu菜單，菜單項不現實圖標，反射強制其顯示
     */
    @Override
    public boolean onMenuOpened(int featureId, Menu menu)
    {

        if (featureId == Window.FEATURE_OPTIONS_PANEL && menu != null)
        {
            if (menu.getClass().getSimpleName().equals("MenuBuilder"))
            {
                try
                {
                    Method m = menu.getClass().getDeclaredMethod(
                            "setOptionalIconsVisible", Boolean.TYPE);
                    m.setAccessible(true);
                    m.invoke(menu, true);
                } catch (Exception e)
                {
                }
            }

        }
        return super.onMenuOpened(featureId, menu);
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item)
    {

        switch (item.getItemId())
        {
            case R.id.id_menu_map_common:
                // 普通地圖
                mBaiduMap.setMapType(BaiduMap.MAP_TYPE_NORMAL);
                break;
            case R.id.id_menu_map_site:// 衛星地圖
                mBaiduMap.setMapType(BaiduMap.MAP_TYPE_SATELLITE);
                break;
            case R.id.id_menu_map_traffic:
                // 開啟交通圖

                if (mBaiduMap.isTrafficEnabled())
                {
                    item.setTitle("開啟實時交通");
                    mBaiduMap.setTrafficEnabled(false);
                } else
                {
                    item.setTitle("關閉實時交通");
                    mBaiduMap.setTrafficEnabled(true);
                }
                break;
            case R.id.id_menu_map_myLoc:
                center2myLoc();
                break;
            case R.id.id_menu_map_style:
                mCurrentStyle = (++mCurrentStyle) % mStyles.length;
                item.setTitle(mStyles[mCurrentStyle]);
                // 設置自定義圖標
                switch (mCurrentStyle)
                {
                    case 0:
                        mCurrentMode = LocationMode.NORMAL;
                        break;
                    case 1:
                        mCurrentMode = LocationMode.FOLLOWING;
                        break;
                    case 2:
                        mCurrentMode = LocationMode.COMPASS;
                        break;
                }
                BitmapDescriptor mCurrentMarker = BitmapDescriptorFactory
                        .fromResource(R.mipmap.navi_map_gps_locked);
                MyLocationConfiguration config = new MyLocationConfiguration(
                        mCurrentMode, true, mCurrentMarker);
                mBaiduMap.setMyLocationConfigeration(config);
                break;
        }

        return super.onOptionsItemSelected(item);
    }

    /**
     * 地圖移動到我的位置,此處可以重新發定位請求，然後定位；
     * 直接拿最近一次經緯度，如果長時間沒有定位成功，可能會顯示效果不好
     */
    private void center2myLoc()
    {
        LatLng ll = new LatLng(mCurrentLantitude, mCurrentLongitude);
        MapStatusUpdate u = MapStatusUpdateFactory.newLatLng(ll);
        mBaiduMap.animateMapStatus(u);
    }

    @Override
    protected void onStart()
    {
        // 開啟圖層定位
        mBaiduMap.setMyLocationEnabled(true);
        if (!mLocationClient.isStarted())
        {
            mLocationClient.start();
        }
        // 開啟方向傳感器
        myOrientationListener.start();
        super.onStart();
    }

    @Override
    protected void onStop()
    {
        // 關閉圖層定位
        mBaiduMap.setMyLocationEnabled(false);
        mLocationClient.stop();

        // 關閉方向傳感器
        myOrientationListener.stop();
        super.onStop();
    }

    @Override
    protected void onDestroy()
    {
        super.onDestroy();
        // 在activity執行onDestroy時執行mMapView.onDestroy()，實現地圖生命周期管理
        mMapView.onDestroy();
        mMapView = null;
    }

    @Override
    protected void onResume()
    {
        super.onResume();
        // 在activity執行onResume時執行mMapView. onResume ()，實現地圖生命周期管理
        mMapView.onResume();
    }

    @Override
    protected void onPause()
    {
        super.onPause();
        // 在activity執行onPause時執行mMapView. onPause ()，實現地圖生命周期管理
        mMapView.onPause();
    }

}

`寫個MyOrientationListener`

package com.yang.baidumapceshi;

/**
 * Created by yang_zzheng on 2016/7/18
 * [email protected]
 */
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;

public class MyOrientationListener implements SensorEventListener
{

    private Context context;
    private SensorManager sensorManager;
    private Sensor sensor;

    private float lastX ;

    private OnOrientationListener onOrientationListener ;

    public MyOrientationListener(Context context)
    {
        this.context = context;
    }

    // 開始
    public void start()
    {
        // 獲得傳感器管理器
        sensorManager = (SensorManager) context
                .getSystemService(Context.SENSOR_SERVICE);
        if (sensorManager != null)
        {
            // 獲得方向傳感器
            sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);
        }
        // 注冊
        if (sensor != null)
        {//SensorManager.SENSOR_DELAY_UI
            sensorManager.registerListener(this, sensor,
                    SensorManager.SENSOR_DELAY_UI);
        }

    }

    // 停止檢測
    public void stop()
    {
        sensorManager.unregisterListener(this);
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy)
    {

    }

    @Override
    public void onSensorChanged(SensorEvent event)
    {
        // 接受方向感應器的類型
        if (event.sensor.getType() == Sensor.TYPE_ORIENTATION)
        {
            // 這裡我們可以得到數據，然後根據需要來處理
            float x = event.values[SensorManager.DATA_X];

            if( Math.abs(x- lastX) > 1.0 )
            {
                onOrientationListener.onOrientationChanged(x);
            }
//            Log.e("DATA_X", x+"");
            lastX = x ;

        }
    }

    public void setOnOrientationListener(OnOrientationListener onOrientationListener)
    {
        this.onOrientationListener = onOrientationListener ;
    }


    public interface OnOrientationListener
    {
        void onOrientationChanged(float x);
    }

}