安卓原生百度地图（5）导航和语音播报

Love The Way You Lie 2023-08-17 17:09 107阅读 0赞

1、在AndroidManifest.xml文件加入配置权限

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
        
        <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
        <uses-permission android:name="android.permission.ACCESS_GPS"/>
        
        <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
        
        <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
        
        <uses-permission android:name="android.permission.ACCESS_LOCATION_EXTRA_COMMANDS"/>
        
        <uses-permission android:name="android.permission.INTERNET">
        </uses-permission>
        
        <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE">
        </uses-permission>
        
        <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
        
        <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>

2、在MainActivity的布局文件中加入导航按钮

3、[下载导航的资源包][Link 1]一一加入到项目当中（提取码：k0il）

![1264306-20190820112238687-1414104961.png][]

4、把下载好的com中的sdkdemo文件包，放到项目中java/com下（和之前的baidu、example文件包放在一起）

![1264306-20190820112515582-1300744994.png][]

5、导入全部包后，在build.gradle文件中加入如下一段代码

ndk {
                abiFilters "armeabi", "x86", "x86_64", "mips64", "mips"
            }

如下图（记得点击Android studio右上角的“Sync Now”同步）：

![1264306-20190820112805237-403697720.png][]

6、附上MainActivity的代码

package com.example.baidumap;
    
    import androidx.annotation.Nullable;
    import androidx.appcompat.app.AppCompatActivity;
    
    import android.Manifest;
    import android.content.Context;
    import android.content.Intent;
    import android.content.pm.PackageManager;
    import android.os.Bundle;
    import android.os.Environment;
    import android.os.Handler;
    import android.os.Looper;
    import android.os.Message;
    import android.util.Log;
    import android.view.View;
    import android.widget.Button;
    import android.widget.Toast;
    
    import com.baidu.location.BDAbstractLocationListener;
    import com.baidu.location.BDLocation;
    import com.baidu.location.LocationClient;
    import com.baidu.location.LocationClientOption;
    import com.baidu.mapapi.CoordType;
    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.MarkerOptions;
    import com.baidu.mapapi.map.MyLocationConfiguration;
    import com.baidu.mapapi.map.MyLocationData;
    import com.baidu.mapapi.map.OverlayOptions;
    import com.baidu.mapapi.model.LatLng;
    import com.baidu.mapapi.overlayutil.BikingRouteOverlay;
    import com.baidu.mapapi.overlayutil.DrivingRouteOverlay;
    import com.baidu.mapapi.overlayutil.MassTransitRouteOverlay;
    import com.baidu.mapapi.overlayutil.TransitRouteOverlay;
    import com.baidu.mapapi.overlayutil.WalkingRouteOverlay;
    import com.baidu.mapapi.search.core.SearchResult;
    import com.baidu.mapapi.search.route.BikingRoutePlanOption;
    import com.baidu.mapapi.search.route.BikingRouteResult;
    import com.baidu.mapapi.search.route.DrivingRoutePlanOption;
    import com.baidu.mapapi.search.route.DrivingRouteResult;
    import com.baidu.mapapi.search.route.IndoorRouteResult;
    import com.baidu.mapapi.search.route.MassTransitRoutePlanOption;
    import com.baidu.mapapi.search.route.MassTransitRouteResult;
    import com.baidu.mapapi.search.route.OnGetRoutePlanResultListener;
    import com.baidu.mapapi.search.route.PlanNode;
    import com.baidu.mapapi.search.route.RoutePlanSearch;
    import com.baidu.mapapi.search.route.TransitRoutePlanOption;
    import com.baidu.mapapi.search.route.TransitRouteResult;
    import com.baidu.mapapi.search.route.WalkingRoutePlanOption;
    import com.baidu.mapapi.search.route.WalkingRouteResult;
    import com.baidu.navisdk.adapter.BNRoutePlanNode;
    import com.baidu.navisdk.adapter.BaiduNaviManagerFactory;
    import com.baidu.navisdk.adapter.IBNRoutePlanManager;
    import com.baidu.navisdk.adapter.IBNTTSManager;
    import com.baidu.navisdk.adapter.IBaiduNaviManager;
    import com.sdkdemo.NormalUtils;
    import com.sdkdemo.newif.DemoGuideActivity;
    
    import java.io.File;
    import java.util.ArrayList;
    import java.util.List;
    
    public class MainActivity extends AppCompatActivity implements View.OnClickListener{
        private MapView mMapView = null;
        private BaiduMap mBaiduMap = null;
    
        private Context context;
    
        //定位相关
        private double mLatitude;
        private double mLongtitude;
    
        //方向传感器
        private MyOrientationListener mMyOrientationListener;
        private float mCurrentX;
        //自定义图标
        private BitmapDescriptor mIconLocation;
        private LocationClient mLocationClient;
        public BDAbstractLocationListener myListener;
        private LatLng mLastLocationData;
        private boolean isFirstin = true;
    
        // 路线规划相关
        private RoutePlanSearch mSearch = null;
    
        //导航相关
        private static final String APP_FOLDER_NAME = "MyBNDTSDK-Api";
        private String mSDCardPath = null;
        private static final String[] authBaseArr = {
                Manifest.permission.WRITE_EXTERNAL_STORAGE,
                Manifest.permission.ACCESS_FINE_LOCATION
        };
        private static final int authBaseRequestCode = 1;
        private boolean hasInitSuccess = false;
        static final String ROUTE_PLAN_NODE = "routePlanNode";
        private BNRoutePlanNode mStartNode = null;
        private LatLng mDestLocationData;
    
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            SDKInitializer.initialize(getApplicationContext());
            setContentView(R.layout.activity_main);
            SDKInitializer.setCoordType(CoordType.BD09LL);
            this.context = this;
            mMapView = (MapView) findViewById(R.id.baiduMapView);
            //获取地图控件引用
            mBaiduMap = mMapView.getMap();
            initMyLocation();
            initPoutePlan();
            button();
            initLongClick();
            //初始化导航相关
            if(initDirs()){
                initNavi();
            }
        }
        protected void onStart() {
            super.onStart();
            //开启定位
            mBaiduMap.setMyLocationEnabled(true);
            if (!mLocationClient.isStarted())
                mLocationClient.start();
            //开启方向传感器
            mMyOrientationListener.start();
        }
        @Override
        protected void onResume() {
            super.onResume();
            mMapView.onResume();
        }
        @Override
        protected void onPause() {
            super.onPause();
            mMapView.onPause();
        }
        @Override
        protected void onStop() {
            super.onStop();
            //停止定位
            mBaiduMap.setMyLocationEnabled(false);
            mLocationClient.stop();
            //停止方向传感器
            mMyOrientationListener.stop();
        }
        @Override
        protected void onDestroy() {
            super.onDestroy();
            mBaiduMap.setMyLocationEnabled(false);
            mMapView.onDestroy();
            mMapView = null;
            mSearch.destroy();
        }
        @Override
        public void onClick(View v) {
            SDKInitializer.initialize(getApplicationContext());
            switch (v.getId()) {
                case R.id.btn_Location: {
                    centerToMyLocation(mLatitude, mLongtitude);
                    break;
                }
                case R.id.btn_Plan: {
                    Intent intent = new Intent(context,RoutePlanActivity.class);
                    startActivityForResult(intent,0x11);
                    break;
                }
                case R.id.btn_Navi:
                    if(mDestLocationData == null){
                        Toast.makeText(context, "长按设置导航目标地点", Toast.LENGTH_SHORT).show();
                        return;
                    }
                    routeplanToNavi();
                    break;
            }
        }
    
        //按钮响应
        private void button() {
            //按钮
            Button btn_Location = (Button) findViewById(R.id.btn_Location);
            Button btn_Plan = (Button) findViewById(R.id.btn_Plan);
            Button btn_Navi = (Button) findViewById(R.id.btn_Navi);
            //按钮处理
            btn_Location.setOnClickListener(this);
            btn_Plan.setOnClickListener(this);
            btn_Navi.setOnClickListener(this);
        }
    
        //定位
        private class MyLocationListener extends BDAbstractLocationListener {
            @Override
            public void onReceiveLocation(BDLocation location) {
                //mapView 销毁后不在处理新接收的位置
                if (location == null || mMapView == null){
                    return;
                }
                MyLocationData locData = new MyLocationData.Builder()
                        .accuracy(location.getRadius())
                        // 此处设置开发者获取到的方向信息，顺时针0-360
                        .direction(mCurrentX).latitude(location.getLatitude())
                        .longitude(location.getLongitude()).build();
                mBaiduMap.setMyLocationData(locData);
                //设置自定义图标
                MyLocationConfiguration config = new
                        MyLocationConfiguration(
                        MyLocationConfiguration.LocationMode.NORMAL, true, mIconLocation);
                mBaiduMap.setMyLocationConfiguration(config);
                //更新经纬度
                mLatitude = location.getLatitude();
                mLongtitude = location.getLongitude();
                //设置起点
                mLastLocationData = new LatLng(mLatitude, mLongtitude);
                if (isFirstin) {
                    centerToMyLocation(location.getLatitude(), location.getLongitude());
    
                    if (location.getLocType() == BDLocation.TypeGpsLocation) {
                        // GPS定位结果
                        Toast.makeText(context, "定位:"+location.getAddrStr(), Toast.LENGTH_SHORT).show();
                    } else if (location.getLocType() == BDLocation.TypeNetWorkLocation) {
                        // 网络定位结果
                        Toast.makeText(context, "定位:"+location.getAddrStr(), Toast.LENGTH_SHORT).show();
                    } else if (location.getLocType() == BDLocation.TypeOffLineLocation) {
                        // 离线定位结果
                        Toast.makeText(context, "定位:"+location.getAddrStr(), Toast.LENGTH_SHORT).show();
                    } else if (location.getLocType() == BDLocation.TypeServerError) {
                        Toast.makeText(context, "定位:服务器错误", Toast.LENGTH_SHORT).show();
                    } else if (location.getLocType() == BDLocation.TypeNetWorkException) {
                        Toast.makeText(context, "定位:网络错误", Toast.LENGTH_SHORT).show();
                    } else if (location.getLocType() == BDLocation.TypeCriteriaException) {
                        Toast.makeText(context, "定位:手机模式错误，请检查是否飞行", Toast.LENGTH_SHORT).show();
                    }
                    isFirstin = false;
                }
            }
        }
        //初始化定位
        private void initMyLocation() {
            //缩放地图
            MapStatusUpdate msu = MapStatusUpdateFactory.zoomTo(15.0f);
            mBaiduMap.setMapStatus(msu);
            //开启定位
            mBaiduMap.setMyLocationEnabled(true);
            //声明LocationClient类
            mLocationClient = new LocationClient(this);
            //通过LocationClientOption设置LocationClient相关参数
            LocationClientOption option = new LocationClientOption();
            option.setOpenGps(true); // 打开gps
            option.setCoorType("bd09ll"); // 设置坐标类型
            option.setIsNeedAddress(true);//设置是否需要地址信息
            option.setScanSpan(1000);
            //设置locationClientOption
            mLocationClient.setLocOption(option);
            myListener = new MyLocationListener();
            //注册监听函数
            mLocationClient.registerLocationListener(myListener);
            //初始化图标
            mIconLocation = BitmapDescriptorFactory.fromResource(R.drawable.navi_map_gps);
            initOrientation();
            //开始定位
            mLocationClient.start();
        }
        //回到定位中心
        private void centerToMyLocation(double latitude, double longtitude) {
            mBaiduMap.clear();
            mLastLocationData = new LatLng(latitude, longtitude);
            MapStatusUpdate msu = MapStatusUpdateFactory.newLatLng(mLastLocationData);
            mBaiduMap.animateMapStatus(msu);
        }
        //传感器
        private void initOrientation() {
            //传感器
            mMyOrientationListener = new MyOrientationListener(context);
            mMyOrientationListener.setOnOrientationListener(new MyOrientationListener.OnOrientationListener() {
                @Override
                public void onOrientationChanged(float x) {
                    mCurrentX = x;
                }
            });
        }
    
        //路线规划初始化
        private void initPoutePlan() {
            mSearch = RoutePlanSearch.newInstance();
            mSearch.setOnGetRoutePlanResultListener(listener);
        }
        // 路线规划模块
        public OnGetRoutePlanResultListener listener = new OnGetRoutePlanResultListener() {
            @Override
            public void onGetWalkingRouteResult(WalkingRouteResult result) {
                if (result == null || result.error != SearchResult.ERRORNO.NO_ERROR) {
                    Toast.makeText(MainActivity.this, "路线规划:未找到结果,检查输入", Toast.LENGTH_SHORT).show();
                    //禁止定位
                    isFirstin = false;
                }
                assert result != null;
                if (result.error == SearchResult.ERRORNO.AMBIGUOUS_ROURE_ADDR) {
                    // 起终点或途经点地址有岐义，通过以下接口获取建议查询信息
                    result.getSuggestAddrInfo();
                    return;
                }
                if (result.error == SearchResult.ERRORNO.NO_ERROR) {
                    mBaiduMap.clear();
                    Toast.makeText(MainActivity.this, "路线规划:搜索完成", Toast.LENGTH_SHORT).show();
                    WalkingRouteOverlay overlay = new WalkingRouteOverlay(mBaiduMap);
                    overlay.setData(result.getRouteLines().get(0));
                    overlay.addToMap();
                    overlay.zoomToSpan();
                }
                //禁止定位
                isFirstin = false;
            }
            @Override
            public void onGetTransitRouteResult(TransitRouteResult result) {
                if (result == null || result.error != SearchResult.ERRORNO.NO_ERROR) {
                    Toast.makeText(MainActivity.this, "路线规划:未找到结果,检查输入", Toast.LENGTH_SHORT).show();
                    //禁止定位
                    isFirstin = false;
                }
                assert result != null;
                if (result.error == SearchResult.ERRORNO.AMBIGUOUS_ROURE_ADDR) {
                    // 起终点或途经点地址有岐义，通过以下接口获取建议查询信息
                    result.getSuggestAddrInfo();
                    return;
                }
                if (result.error == SearchResult.ERRORNO.NO_ERROR) {
                    mBaiduMap.clear();
                    Toast.makeText(MainActivity.this, "路线规划:搜索完成", Toast.LENGTH_SHORT).show();
                    TransitRouteOverlay overlay = new TransitRouteOverlay(mBaiduMap);
                    overlay.setData(result.getRouteLines().get(0));
                    overlay.addToMap();
                    overlay.zoomToSpan();
                }
                //禁止定位
                isFirstin = false;
            }
            @Override
            public void onGetMassTransitRouteResult(MassTransitRouteResult result) {
                if (result == null || result.error != SearchResult.ERRORNO.NO_ERROR) {
                    Toast.makeText(MainActivity.this, "路线规划:未找到结果,检查输入", Toast.LENGTH_SHORT).show();
                    //禁止定位
                    isFirstin = false;
                }
                assert result != null;
                if (result.error == SearchResult.ERRORNO.AMBIGUOUS_ROURE_ADDR) {
                    // 起终点或途经点地址有岐义，通过以下接口获取建议查询信息
                    result.getSuggestAddrInfo();
                    return;
                }
                if (result.error == SearchResult.ERRORNO.NO_ERROR) {
                    mBaiduMap.clear();
                    Toast.makeText(MainActivity.this, "路线规划:搜索完成", Toast.LENGTH_SHORT).show();
                    MassTransitRouteOverlay overlay = new MassTransitRouteOverlay(mBaiduMap);
                    overlay.setData(result.getRouteLines().get(0));
                    overlay.addToMap();
                    overlay.zoomToSpan();
                }
                //禁止定位
                isFirstin = false;
            }
            @Override
            public void onGetDrivingRouteResult(DrivingRouteResult result) {
                if (result == null || result.error != SearchResult.ERRORNO.NO_ERROR) {
                    Toast.makeText(MainActivity.this, "路线规划:未找到结果,检查输入", Toast.LENGTH_SHORT).show();
                    //禁止定位
                    isFirstin = false;
                }
                assert result != null;
                if (result.error == SearchResult.ERRORNO.AMBIGUOUS_ROURE_ADDR) {
                    // 起终点或途经点地址有岐义，通过以下接口获取建议查询信息
                    result.getSuggestAddrInfo();
                    return;
                }
                if (result.error == SearchResult.ERRORNO.NO_ERROR) {
                    mBaiduMap.clear();
                    Toast.makeText(MainActivity.this, "路线规划:搜索完成", Toast.LENGTH_SHORT).show();
                    DrivingRouteOverlay overlay = new DrivingRouteOverlay(mBaiduMap);
                    overlay.setData(result.getRouteLines().get(0));
                    overlay.addToMap();
                    overlay.zoomToSpan();
                }
                //禁止定位
                isFirstin = false;
            }
            @Override
            public void onGetIndoorRouteResult(IndoorRouteResult var1) {
            }
            @Override
            public void onGetBikingRouteResult(BikingRouteResult result) {
                if (result == null || result.error != SearchResult.ERRORNO.NO_ERROR) {
                    Toast.makeText(MainActivity.this, "路线规划:未找到结果,检查输入", Toast.LENGTH_SHORT).show();
                    //禁止定位
                    isFirstin = false;
                }
                assert result != null;
                if (result.error == SearchResult.ERRORNO.AMBIGUOUS_ROURE_ADDR) {
                    // 起终点或途经点地址有岐义，通过以下接口获取建议查询信息
                    result.getSuggestAddrInfo();
                    return;
                }
                if (result.error == SearchResult.ERRORNO.NO_ERROR) {
                    mBaiduMap.clear();
                    Toast.makeText(MainActivity.this, "路线规划:搜索完成", Toast.LENGTH_SHORT).show();
                    BikingRouteOverlay overlay = new BikingRouteOverlay(mBaiduMap);
                    overlay.setData(result.getRouteLines().get(0));
                    overlay.addToMap();
                    overlay.zoomToSpan();
                }
                //禁止定位
                isFirstin = false;
            }
        };
        //开始规划
        private void StarRoute(int id,ArrayList list) {
            SDKInitializer.initialize(getApplicationContext());
            //经纬度规划路线和动态输入规划路线二选一
    
            // 设置起、终点信息 动态输入规划路线
            PlanNode stNode = PlanNode.withCityNameAndPlaceName(list.get(0).toString(), list.get(1).toString());
            PlanNode enNode = PlanNode.withCityNameAndPlaceName(list.get(2).toString(), list.get(3).toString());
    
    
            //经纬度规划路线
    //        LatLng startPoint = new LatLng(39.917380, 116.37978);
    //        LatLng endPoint = new LatLng(22.27503, 113.523431);
    //        PlanNode stNode = PlanNode.withLocation(startPoint);
    //        PlanNode enNode = PlanNode.withLocation(endPoint);
    
           switch (id){
               case 1:
                   mSearch.drivingSearch((new DrivingRoutePlanOption()).from(stNode).to(enNode));
                   break;
               case 2:
                   if(list.get(0).toString() == list.get(2).toString()){
                       mSearch.transitSearch((new TransitRoutePlanOption()).from(stNode).to(enNode));
                   }else{
                       mSearch.masstransitSearch((new MassTransitRoutePlanOption()).from(stNode).to(enNode));
                   }
                   break;
                   default:break;
    
           }
        }
    
        @Override
        protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            if(requestCode == 0x11){
                ArrayList address = data.getCharSequenceArrayListExtra("address");
                StarRoute(resultCode,address);
            }
        }
    
        //导航 ----获取Sdcard目录
        private String getSdcardDir() {
            if (Environment.getExternalStorageState().equalsIgnoreCase(Environment.MEDIA_MOUNTED)) {
                return Environment.getExternalStorageDirectory().toString();
            }
            return null;
        }
        //初始化导航目录
        private boolean initDirs() {
            mSDCardPath = getSdcardDir();
            if (mSDCardPath == null) {
                return false;
            }
            File f = new File(mSDCardPath, APP_FOLDER_NAME);
            if (!f.exists()) {
                try {
                    f.mkdir();
                } catch (Exception e) {
                    e.printStackTrace();
                    return false;
                }
            }
            return true;
        }
        private boolean hasBasePhoneAuth() {
            PackageManager pm = this.getPackageManager();
            for (String auth : authBaseArr) {
                if (pm.checkPermission(auth, this.getPackageName()) != PackageManager.PERMISSION_GRANTED) {
                    return false;
                }
            }
            return true;
        }
        //初始化语音播报
        private void initTTS() {
            // 使用内置TTS
            BaiduNaviManagerFactory.getTTSManager().initTTS(getApplicationContext(),
                    getSdcardDir(), APP_FOLDER_NAME, NormalUtils.getTTSAppID());
    
            // 注册同步内置tts状态回调
            BaiduNaviManagerFactory.getTTSManager().setOnTTSStateChangedListener(
                    new IBNTTSManager.IOnTTSPlayStateChangedListener() {
                        @Override
                        public void onPlayStart() {
                            Log.e("BNSDKDemo", "ttsCallback.onPlayStart");
                        }
    
                        @Override
                        public void onPlayEnd(String speechId) {
                            Log.e("BNSDKDemo", "ttsCallback.onPlayEnd");
                        }
    
                        @Override
                        public void onPlayError(int code, String message) {
                            Log.e("BNSDKDemo", "ttsCallback.onPlayError");
                        }
                    }
            );
            // 注册内置tts 异步状态消息
            BaiduNaviManagerFactory.getTTSManager().setOnTTSStateChangedHandler(
                    new Handler(Looper.getMainLooper()) {
                        @Override
                        public void handleMessage(Message msg) {
                            Log.e("BNSDKDemo", "ttsHandler.msg.what=" + msg.what);
                        }
                    }
            );
        }
        //初始化导航
        private void initNavi() {
            // 申请权限
            if (android.os.Build.VERSION.SDK_INT >= 23) {
                if (!hasBasePhoneAuth()) {
                    this.requestPermissions(authBaseArr, authBaseRequestCode);
                    return;
                }
            }
    
            BaiduNaviManagerFactory.getBaiduNaviManager().init(this, mSDCardPath, APP_FOLDER_NAME, new IBaiduNaviManager.INaviInitListener() {
                        @Override
                        public void onAuthResult(int status, String msg) {
                            String result;
                            if (0 == status) {
                                result = "key校验成功!";
                            } else {
                                result = "key校验失败, " + msg;
                            }
                            Toast.makeText(MainActivity.this, result, Toast.LENGTH_LONG).show();
                        }
    
                        @Override
                        public void initStart() {
                            Toast.makeText(MainActivity.this, "导航引擎初始化开始", Toast.LENGTH_SHORT).show();
                        }
    
                        @Override
                        public void initSuccess() {
                            Toast.makeText(MainActivity.this, "导航引擎初始化成功", Toast.LENGTH_SHORT).show();
                            hasInitSuccess = true;
                            // 初始化tts
                            initTTS();
                        }
    
                        @Override
                        public void initFailed() {
                            Toast.makeText(MainActivity.this, "导航引擎初始化失败", Toast.LENGTH_SHORT).show();
                        }
                    });
    
        }
        //添加导航目的地图标
        private void addDestInfoOverlay(LatLng latLng) {
            mBaiduMap.clear();
            OverlayOptions options = new MarkerOptions().position(latLng)
                    .icon(BitmapDescriptorFactory.fromResource(R.drawable.icon_geo))
                    .zIndex(5);
            mBaiduMap.addOverlay(options);
        }
        //坐标转换
        public static BDLocation bd2gcj(BDLocation loc) {
            return LocationClient.getBDLocationInCoorType(loc,BDLocation.BDLOCATION_BD09LL_TO_GCJ02);
        }
        //导航算路
        private void routeplanToNavi() {
    
            final int coType = BNRoutePlanNode.CoordinateType.GCJ02;
            if (!hasInitSuccess) {
                Toast.makeText(MainActivity.this, "还未初始化!", Toast.LENGTH_SHORT).show();
            }
    
            BDLocation srcBdLocation = new BDLocation();
            srcBdLocation.setLatitude(mLastLocationData.latitude);
            srcBdLocation.setLongitude(mLastLocationData.longitude);
            BDLocation srcGcj = bd2gcj(srcBdLocation);
            BDLocation destBdLocation = new BDLocation();
            destBdLocation.setLatitude(mDestLocationData.latitude);
            destBdLocation.setLongitude(mDestLocationData.longitude);
            BDLocation destGcj = bd2gcj(destBdLocation);
    
            BNRoutePlanNode sNode = new BNRoutePlanNode(srcGcj.getLongitude(),srcGcj.getLatitude(),"我的地点",null,coType);
            BNRoutePlanNode eNode = new BNRoutePlanNode(destGcj.getLongitude(),destGcj.getLatitude(),"目标地点",null,coType);
    
            mStartNode = sNode;
    
            List<BNRoutePlanNode> list = new ArrayList<>();
            list.add(sNode);
            list.add(eNode);
    
    
            BaiduNaviManagerFactory.getRoutePlanManager().routeplanToNavi(list,
                    IBNRoutePlanManager.RoutePlanPreference.ROUTE_PLAN_PREFERENCE_DEFAULT,
                    null,
                    new Handler(Looper.getMainLooper()) {
                        @Override
                        public void handleMessage(Message msg) {
                            switch (msg.what) {
                                case IBNRoutePlanManager.MSG_NAVI_ROUTE_PLAN_START:
                                    Toast.makeText(MainActivity.this, "导航:算路开始", Toast.LENGTH_SHORT)
                                            .show();
                                    break;
                                case IBNRoutePlanManager.MSG_NAVI_ROUTE_PLAN_SUCCESS:
                                    Toast.makeText(MainActivity.this, "导航:算路成功", Toast.LENGTH_SHORT)
                                            .show();
                                    break;
                                case IBNRoutePlanManager.MSG_NAVI_ROUTE_PLAN_FAILED:
                                    Toast.makeText(MainActivity.this, "导航:算路失败", Toast.LENGTH_SHORT)
                                            .show();
                                    break;
                                case IBNRoutePlanManager.MSG_NAVI_ROUTE_PLAN_TO_NAVI:
                                    Toast.makeText(MainActivity.this, "导航:算路成功准备进入导航", Toast.LENGTH_SHORT)
                                            .show();
                                    Intent intent = new Intent(MainActivity.this,
                                            DemoGuideActivity.class);
                                    Bundle bundle = new Bundle();
                                    bundle.putSerializable(ROUTE_PLAN_NODE, mStartNode);
                                    intent.putExtras(bundle);
                                    startActivity(intent);
                                    break;
                                default:
                                    // nothing
                                    break;
                            }
                        }
                    });
        }
        //长按处理
        private void initLongClick() {
            mBaiduMap.setOnMapLongClickListener(new BaiduMap.OnMapLongClickListener() {
                @Override
                public void onMapLongClick(LatLng latLng) {
                    Toast.makeText(context,"导航:设置目的地成功", Toast.LENGTH_LONG).show();
                    mDestLocationData = latLng;
                    addDestInfoOverlay(latLng);
                }
            });
        }
    }

7、在AndroidManifest.xml中声明定位的activity组件

8、加上语音播报导航路线（[点击跳转到语音创建地址][Link 2]）：

1.找到语音技术或者语音识别（点击创建应用）

![1264306-20190820135402919-1873486764.png][]

2.填上必填的，包名写自个的包名

![1264306-20190820135743132-1382412427.png][]

3.进入应用管理或进入语音技术-应用列表

![1264306-20190820140035596-1502622280.png][]

4.复制AppId到MainActivity找到初始化语音播报那段代码（按住Ctrl+鼠标键跳转到NormalUtils类下）

![1264306-20190820140239307-1965498596.png][]

5.把刚才复制的APPId放到返回的return中

![1264306-20190820140841019-1524393687.png][]

9、启动项目（这是用手机启动的项目，用模拟器可能会出现闪退）

![1264306-20190820142758336-1724180988.png][]

10、启动的过程中可能会出现一个错误，有一个.os没找到

1.在build.gradle去掉主动导入jniLibs文件包（记得点击右上角的“Sync Now”同步）

![1264306-20190820141615634-445984503.png][]

2.下载一个jniLibs文件包（在之前下载的百度地图资源包中包含jniLibs包），[点击获取][Link 3]（提取码：urgy）

![1264306-20190820142138049-921422930.png][]

3.把jniLibs文件复制到项目中main文件下

![1264306-20190820142303705-1399420705.png][]

11、附上项目代码（[点击获取][Link 4]，提取码：le4c），下载下来的项目可能会出现缺少KEY的错误

转载于:https://www.cnblogs.com/Mr-Deng/p/11381888.html

[Link 1]: https://pan.baidu.com/s/15BrQk5Yv5kWobPgZ2X-rMQ
[1264306-20190820112238687-1414104961.png]: /images/20230808/64bdb9e2eaa74c8e9293e93dffe6bb89.png
[1264306-20190820112515582-1300744994.png]: /images/20230808/67fa164c3cbb4c7e981639f544bef83b.png
[1264306-20190820112805237-403697720.png]: /images/20230808/d71f6f06eb154efe9ae71d9548f795a0.png
[Link 2]: https://console.bce.baidu.com/ai/
[1264306-20190820135402919-1873486764.png]: /images/20230808/f656a7cc60d74a8f8933d876e58e8441.png
[1264306-20190820135743132-1382412427.png]: /images/20230808/7277dd7375d34364a54bc669d8d6b1a7.png
[1264306-20190820140035596-1502622280.png]: /images/20230808/5a41822e97fe4e54bd1e4ef6bc9a6948.png
[1264306-20190820140239307-1965498596.png]: /images/20230808/fab9cb01226c469dac2b8ede8ce35afb.png
[1264306-20190820140841019-1524393687.png]: /images/20230808/c924d4b6322146578536f1d01748c598.png
[1264306-20190820142758336-1724180988.png]: /images/20230808/dd1d12bc1ee041babab0bc836f8410da.png
[1264306-20190820141615634-445984503.png]: /images/20230808/0b113b94b64346489ce20624f9aed828.png
[Link 3]: https://pan.baidu.com/s/1AlJDhAid2-9NiQH4WwWFow
[1264306-20190820142138049-921422930.png]: /images/20230808/71a7e3b8459a4215b636785ef8f82fde.png
[1264306-20190820142303705-1399420705.png]: /images/20230808/e9007f18895f4d7ab27e17eab8ea23ba.png
[Link 4]: https://pan.baidu.com/s/1EwBU0ByDfKsdKYZO_fBMjQ