安卓百度地图定位

//百度地图
    implementation 'com.baidu.lbsyun:BaiduMapSDK_Map:7.6.4'
    implementation 'com.baidu.lbsyun:BaiduMapSDK_Util:7.6.4' // 工具库（部分功能需要）
    implementation 'com.baidu.lbsyun:BaiduMapSDK_Location_All:9.6.4' // 高精度定位

     //百度地图：在使用SDK各组件之前初始化context信息，传入ApplicationContext
        SDKInitializer.setAgreePrivacy(getApplicationContext(),true);
        SDKInitializer.initialize(getApplicationContext());
        //自4.3.0起，百度地图SDK所有接口均支持百度坐标和国测局坐标，用此方法设置您使用的坐标类型.
        //包括BD09LL和GCJ02两种坐标，默认是BD09LL坐标。
        SDKInitializer.setCoordType(CoordType.BD09LL);

        /**
     * 设置地图定位
     */
    public void setupMap(){
        Log.e("location", "百度隐私合规状态: " + SDKInitializer.getAgreePrivacy());
        // 1. 显式设置定位SDK隐私合规
        com.baidu.location.LocationClient.setAgreePrivacy(true);
        //定位服务的客户端。宿主程序在客户端声明此类，并调用，目前只支持在主线程中启动

        try {
            locationClient = new LocationClient(mContext);
        } catch (Exception e) {
            Log.e("location","初始化失败"+e);
            return;
        }
        //声明LocationClient类实例并配置定位参数
        LocationClientOption locationOption = new LocationClientOption();
        MyLocationListener myLocationListener = new MyLocationListener();
        //注册监听函数
        locationClient.registerLocationListener(myLocationListener);
        //可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
        locationOption.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);
        //可选，默认gcj02，设置返回的定位结果坐标系，如果配合百度地图使用，建议设置为bd09ll;
        //        locationOption.setCoorType("gcj02");
        //可选，默认0，即仅定位一次，设置发起连续定位请求的间隔需要大于等于1000ms才是有效的
        locationOption.setScanSpan(1000);
        //可选，设置是否需要地址信息，默认不需要
        locationOption.setIsNeedAddress(true);
        //可选，设置是否需要地址描述
        locationOption.setIsNeedLocationDescribe(true);
        //可选，设置是否需要设备方向结果
        locationOption.setNeedDeviceDirect(false);
        //可选，默认false，设置是否当卫星定位有效时按照1S1次频率输出卫星定位结果
        locationOption.setLocationNotify(true);
        //可选，默认true，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认不杀死
        locationOption.setIgnoreKillProcess(true);
        //可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
        locationOption.setIsNeedLocationDescribe(true);
        //可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
        locationOption.setIsNeedLocationPoiList(true);
        //可选，默认false，设置是否收集CRASH信息，默认收集
        locationOption.SetIgnoreCacheException(false);
        //可选，默认false，设置是否开启卫星定位
        locationOption.setOpenGnss(true);
        //可选，默认false，设置定位时是否需要海拔信息，默认不需要，除基础定位版本都可用
        locationOption.setIsNeedAltitude(false);
        //设置打开自动回调位置模式，该开关打开后，期间只要定位SDK检测到位置变化就会主动回调给开发者，该模式下开发者无需再关心定位间隔是多少，定位SDK本身发现位置变化就会及时回调给开发者
        locationOption.setOpenAutoNotifyMode();
        //设置打开自动回调位置模式，该开关打开后，期间只要定位SDK检测到位置变化就会主动回调给开发者
        locationOption.setOpenAutoNotifyMode(3000,1, LocationClientOption.LOC_SENSITIVITY_HIGHT);
        //需将配置好的LocationClientOption对象，通过setLocOption方法传递给LocationClient对象使用
        locationClient.setLocOption(locationOption);
        //开始定位
        locationClient.start();
    }

    private class MyLocationListener extends BDAbstractLocationListener {
        @Override
        public void onReceiveLocation(BDLocation location){
            //此处的BDLocation为定位结果信息类，通过它的各种get方法可获取定位相关的全部结果
            //以下只列举部分获取经纬度相关（常用）的结果信息
            //更多结果信息获取说明，请参照类参考中BDLocation类中的说明
            LogUtils.d("坐标类型："+location.getCoorType());

            //获取纬度信息
            double latitude = location.getLatitude();
            //获取经度信息
            double longitude = location.getLongitude();
            //获取定位精度，默认值为0.0f
            float radius = location.getRadius();
            //获取经纬度坐标类型，以LocationClientOption中设置过的坐标类型为准
            String coorType = location.getCoorType();
            //获取定位类型、定位错误返回码，具体信息可参照类参考中BDLocation类中的说明
            int errorCode = location.getLocType();
            LatLng baiduPoint = BaiduCoordinateTransformUtils.convertToBaiduCoord(location);
            addControllMarker(baiduPoint);
            MapPoint mapPoint = new MapPoint(latitude, longitude, "");
            SPUtils.putObject(SPKeysConstance.MAP_POINT, mapPoint);  // 建议内部用 apply()

        }
    }




    以下是自己封装的工具类，可供外部调用：


import android.content.Context;
import android.graphics.Color;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;

import com.baidu.location.BDAbstractLocationListener;
import com.baidu.location.BDLocation;
import com.baidu.location.LocationClient;
import com.baidu.location.LocationClientOption;
import com.baidu.mapapi.SDKInitializer;
import com.baidu.mapapi.map.BMTrackOptions;
import com.baidu.mapapi.map.BMTrackType;
import com.baidu.mapapi.map.BaiduMap;
import com.baidu.mapapi.map.BitmapDescriptor;
import com.baidu.mapapi.map.BitmapDescriptorFactory;
import com.baidu.mapapi.map.CircleOptions;
import com.baidu.mapapi.map.MapStatusUpdate;
import com.baidu.mapapi.map.MapStatusUpdateFactory;
import com.baidu.mapapi.map.Marker;
import com.baidu.mapapi.map.MarkerOptions;
import com.baidu.mapapi.map.MyLocationConfiguration;
import com.baidu.mapapi.map.Polyline;
import com.baidu.mapapi.map.PolylineOptions;
import com.baidu.mapapi.map.Stroke;
import com.baidu.mapapi.map.Track;
import com.baidu.mapapi.map.track.TraceAnimationListener;
import com.baidu.mapapi.model.LatLng;
import com.baidu.mapapi.utils.CoordinateConverter;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.htnova.fly.R;
import com.htnova.fly.activity.HtFlightBaiduMapActivity;
import com.htnova.fly.entity.AirPortNoFlyEntity;
import com.htnova.fly.entity.MapPoint;
import com.htnova.fly.entity.SPKeysConstance;

import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @author xqm
 * @date 2025/8/1 9:42
 * @description BaiduMapHelper 将 BaiduMap 绑定到工具类实例中，避免重复传递，同时保持生命周期安全。
 */
public class BaiduMapHelper {
    private final BaiduMap baiduMap;
    private final Handler mainHandler; // 主线程Handler
    private final Context mContext; // 添加Context成员变量
    private static final double RADIUS_KM = 5; // 5公里半径
    private static final int CIRCLE_COLOR = 0x22FF0000; // 半透明红色
    private static final int STROKE_COLOR = 0xFFFF0000; // 红色边框
    private static final int STROKE_WIDTH = 2; // 边框宽度

    private Polyline realtimePolyline;
    private Track finalizedTrack;
    private List<LatLng> allPoints = new ArrayList<>();
    private int[] allHeights = new int[0];

    private int heightCounter = 1000;
    private Marker aircraftMarker;//
    private Marker aircraftControllMarker; // 
    private LocationClient locationClient;


    // 初始化时绑定 BaiduMap
    public BaiduMapHelper(Context context,BaiduMap baiduMap) {
        this.mContext = context.getApplicationContext();
        this.baiduMap = baiduMap;
        this.mainHandler = new Handler(Looper.getMainLooper()); // 绑定主线程Looper
    }

    /**
     * 在主线程执行任务
     */
    private void runOnUiThread(Runnable task) {
        mainHandler.post(task);
    }

    /**
     * 读取assets目录下的json文件并添加在地图上
     * @param context
     * @param baiduMap
     * @param filePath
     */
    public void drawCirclesFromFile(Context context, BaiduMap baiduMap,
                                           String filePath) {
        new Thread(() -> {
            try (InputStream is = context.getAssets().open(filePath)) {
                List<AirPortNoFlyEntity> points = parseExcelPoints2(is);
                addMarkersToMap(baiduMap,points,RADIUS_KM);

            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
    }

    private  List<AirPortNoFlyEntity> parseExcelPoints2(InputStream is) throws Exception {
        try {
            // 从 assets 读取 JSON 文件
            byte[] buffer = new byte[is.available()];
            is.read(buffer);
            is.close();
            String json = new String(buffer, StandardCharsets.UTF_8);

            // 使用 Gson 解析为 List<Point>
            return new Gson().fromJson(json, new TypeToken<List<AirPortNoFlyEntity>>() {}.getType());
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    private void addMarkersToMap(BaiduMap baiduMap,List<AirPortNoFlyEntity> points,double radiusKm) {

        if (points == null || points.isEmpty()) return;

        // 分批次添加（每批50个）
        int batchSize = 50;
        for (int i = 0; i < points.size(); i += batchSize) {
            int end = Math.min(i + batchSize, points.size());
            List<AirPortNoFlyEntity> batch = points.subList(i, end);

            // 延迟分批提交，减轻主线程压力
            new Handler(Looper.getMainLooper()).postDelayed(() -> {
                for (AirPortNoFlyEntity point : batch) {
                    LatLng corrected = BaiduCoordinateTransformUtils.wgsToBd(new LatLng(point.getLatitude(), point.getLongitude()));

                    CircleOptions options = new CircleOptions()
                            .center(corrected)
                            .radius((int) (radiusKm * 1000))
                            .fillColor(CIRCLE_COLOR)
                            .stroke(new Stroke(STROKE_WIDTH, STROKE_COLOR));
                    baiduMap.addOverlay(options);
                }
            }, i * 10L); // 间隔时间（毫秒）
        }
    }




    // 在地图上添加圆形覆盖物
    private void addCircleToMap(BaiduMap baiduMap, LatLng center, double radiusKm) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                CircleOptions options = new CircleOptions()
                        .center(center)
                        .radius((int) (radiusKm * 1000)) // 转换为米
                        .fillColor(CIRCLE_COLOR)
                        .stroke(new Stroke(STROKE_WIDTH, STROKE_COLOR));

                baiduMap.addOverlay(options);
            }
        });

    }

    public void addControllMarker(LatLng latLng){
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                if(aircraftControllMarker  == null){
                    MarkerOptions markerOptions = new MarkerOptions()
                            .position(latLng)
                            .title("飞机位置")
                            .icon(BitmapDescriptorFactory.fromResource(R.mipmap.ic_fly_control)) // 你的飞机图标
                            .anchor(0.5f, 0.5f);
                    aircraftControllMarker = (Marker) baiduMap.addOverlay(markerOptions);
                }else{
                    // 更新已有Marker位置
                    aircraftControllMarker.setPosition(latLng);
                }
            }
        });



    }

    /**
     * 设置地图定位
     */
    public void setupMap(){
        Log.e("location", "百度隐私合规状态: " + SDKInitializer.getAgreePrivacy());
        // 1. 显式设置定位SDK隐私合规
        com.baidu.location.LocationClient.setAgreePrivacy(true);
        //定位服务的客户端。宿主程序在客户端声明此类，并调用，目前只支持在主线程中启动

        try {
            locationClient = new LocationClient(mContext);
        } catch (Exception e) {
            Log.e("location","初始化失败"+e);
            return;
        }
        //声明LocationClient类实例并配置定位参数
        LocationClientOption locationOption = new LocationClientOption();
        MyLocationListener myLocationListener = new MyLocationListener();
        //注册监听函数
        locationClient.registerLocationListener(myLocationListener);
        //可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
        locationOption.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);
        //可选，默认gcj02，设置返回的定位结果坐标系，如果配合百度地图使用，建议设置为bd09ll;
        //        locationOption.setCoorType("gcj02");
        //可选，默认0，即仅定位一次，设置发起连续定位请求的间隔需要大于等于1000ms才是有效的
        locationOption.setScanSpan(1000);
        //可选，设置是否需要地址信息，默认不需要
        locationOption.setIsNeedAddress(true);
        //可选，设置是否需要地址描述
        locationOption.setIsNeedLocationDescribe(true);
        //可选，设置是否需要设备方向结果
        locationOption.setNeedDeviceDirect(false);
        //可选，默认false，设置是否当卫星定位有效时按照1S1次频率输出卫星定位结果
        locationOption.setLocationNotify(true);
        //可选，默认true，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认不杀死
        locationOption.setIgnoreKillProcess(true);
        //可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
        locationOption.setIsNeedLocationDescribe(true);
        //可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
        locationOption.setIsNeedLocationPoiList(true);
        //可选，默认false，设置是否收集CRASH信息，默认收集
        locationOption.SetIgnoreCacheException(false);
        //可选，默认false，设置是否开启卫星定位
        locationOption.setOpenGnss(true);
        //可选，默认false，设置定位时是否需要海拔信息，默认不需要，除基础定位版本都可用
        locationOption.setIsNeedAltitude(false);
        //设置打开自动回调位置模式，该开关打开后，期间只要定位SDK检测到位置变化就会主动回调给开发者，该模式下开发者无需再关心定位间隔是多少，定位SDK本身发现位置变化就会及时回调给开发者
        locationOption.setOpenAutoNotifyMode();
        //设置打开自动回调位置模式，该开关打开后，期间只要定位SDK检测到位置变化就会主动回调给开发者
        locationOption.setOpenAutoNotifyMode(3000,1, LocationClientOption.LOC_SENSITIVITY_HIGHT);
        //需将配置好的LocationClientOption对象，通过setLocOption方法传递给LocationClient对象使用
        locationClient.setLocOption(locationOption);
        //开始定位
        locationClient.start();
    }

    private class MyLocationListener extends BDAbstractLocationListener {
        @Override
        public void onReceiveLocation(BDLocation location){
            //此处的BDLocation为定位结果信息类，通过它的各种get方法可获取定位相关的全部结果
            //以下只列举部分获取经纬度相关（常用）的结果信息
            //更多结果信息获取说明，请参照类参考中BDLocation类中的说明
            LogUtils.d("坐标类型："+location.getCoorType());

            //获取纬度信息
            double latitude = location.getLatitude();
            //获取经度信息
            double longitude = location.getLongitude();
            //获取定位精度，默认值为0.0f
            float radius = location.getRadius();
            //获取经纬度坐标类型，以LocationClientOption中设置过的坐标类型为准
            String coorType = location.getCoorType();
            //获取定位类型、定位错误返回码，具体信息可参照类参考中BDLocation类中的说明
            int errorCode = location.getLocType();
            LatLng baiduPoint = BaiduCoordinateTransformUtils.convertToBaiduCoord(location);
            addControllMarker(baiduPoint);
            MapPoint mapPoint = new MapPoint(latitude, longitude, "");
            SPUtils.putObject(SPKeysConstance.MAP_POINT, mapPoint);  // 建议内部用 apply()

        }
    }

    public void stopLocation() {
        if (locationClient != null) {
            locationClient.stop();
        }
    }

    // 添加资源释放方法
    public void release() {
        if (locationClient != null) {
            locationClient.stop();
            locationClient = null;
        }
        // 清理其他资源...
        // 释放地图资源
        if (baiduMap != null) {
            baiduMap.setMyLocationEnabled(false);
            baiduMap.clear();
        }
    }

    /**
     * 添加点 高度 进入地图
     * @param newPoint
     * @param height
     */
    public void addPointCombined(LatLng newPoint, int height) {

        // 添加新数据
        allPoints.add(newPoint);

        // 更新高度数组
        int[] newHeights = Arrays.copyOf(allHeights, allHeights.length + 1);
        newHeights[allHeights.length] = height;
        allHeights = newHeights;

        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                //更新点
                if (aircraftMarker == null) {
                    // 第一次创建标记
                    MarkerOptions markerOptions = new MarkerOptions()
                            .position(newPoint)
                            .title("飞机位置")
                            .icon(BitmapDescriptorFactory.fromResource(R.mipmap.icon_plane)) // 你的飞机图标
                            .anchor(0.5f, 0.5f);
                    aircraftMarker = (Marker) baiduMap.addOverlay(markerOptions);
                } else {
                    // 后续更新位置
                    aircraftMarker.setPosition(newPoint);
                }

                // 更新实时线段
                if(allPoints.size()>=2){
                    if (realtimePolyline == null) {
                        PolylineOptions options = new PolylineOptions()
                                .points(allPoints)
                                .width(8)
                                .color(0xAA0000FF);
                        realtimePolyline = (Polyline) baiduMap.addOverlay(options);
                    } else {
                        realtimePolyline.setPoints(allPoints);
                    }
                }


                // 每20个点生成一次3D轨迹
                if (allPoints.size() % 20 == 0) {
                    update3DTrack();
                }

                // 调整视角
                MapStatusUpdate mapStatusUpdate = MapStatusUpdateFactory.newLatLng(newPoint);
                baiduMap.animateMapStatus(mapStatusUpdate);
            }
        });

    }

    /**
     * 更新3D路线
     */
    private void update3DTrack() {
        if (finalizedTrack != null) {
            finalizedTrack.remove();
        }

        // ... 自定义绘制颜色渐变到paletteBitmap ...
        BitmapDescriptor paletteDesc = BitmapDescriptorFactory.fromResource(R.mipmap.ic_color);
// 方法1：从资源文件创建（推荐）
        BitmapDescriptor projPalette = BitmapDescriptorFactory.fromResource(R.mipmap.ic_color);


        BMTrackOptions options = new BMTrackOptions();
        options.setTrackType(BMTrackType.Surface);
        options.setPoints(allPoints);
        options.setHeights(allHeights);

        options.setPalette(paletteDesc);           // 颜色渐变
        options.setPaletteOpacity(0.8f);            // 透明度
        options.setProjectionPalette(projPalette);
        options.setWidth(10);                       // 轨迹宽度
        options.setAnimationTime(1000);             // 动画时长（毫秒）
        options.setTraceAnimationListener(mTraceAnimationListener);
        // 其他设置...

        finalizedTrack = (Track) baiduMap.addOverlay(options);

    }

    /**
     * 动画监听
     */
    private TraceAnimationListener mTraceAnimationListener = new TraceAnimationListener() {

        @Override
        public void onTraceAnimationUpdate(float v) {
//            LogUtils.d("onTraceAnimationUpdate:"+v);
        }

        @Override
        public void onTraceUpdatePosition(com.baidu.mapapi.model.LatLng latLng) {
//            LogUtils.d("onTraceUpdatePosition:"+latLng.toString());
        }

        @Override
        public void onTraceAnimationFinish() {
//            LogUtils.d("onTraceAnimationFinish:");
        }
    };


    // 模拟实时接收GPS数据并调用方法
    public void simulateRealTimeGPS() {
        // 模拟调用飞机飞行
        // 起点，比如某地经纬度
        final double startLat = 39.90923;
        final double startLng = 116.397428;

        final Handler handler = new Handler(Looper.getMainLooper());
        final int[] step = {0};

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // 模拟飞机沿直线慢慢向北移动，每次移动0.0001度纬度
                double newLat = startLat + 0.0001 * step[0];
                double newLng = startLng;

                LatLng newPosition = new LatLng(newLat, newLng);
                addPointCombined(newPosition,heightCounter+=300);

                step[0]++;
                if (step[0] < 100) { // 模拟100次更新
                    handler.postDelayed(this, 1000); // 1秒更新一次
                }
            }
        };
        handler.post(runnable);

    }

}