百度地图定位代码保存

    private void init_position_map() {
        MyPositioning myPositioning=new MyPositioning();
        //设置定位图层
        mBaiduMap.setMyLocationConfiguration(myPositioning.locationConfig());
        //开启定位
        MyLocationListener myListener = new MyLocationListener();

        mLocationClient= myPositioning.initLBS(mLocationClient,myListener);
        mLocationClient.start();
        // 开启定位图层
        mBaiduMap.setMyLocationEnabled(true);
    }
    public MainActivity() {
        mainActivity = this;
    }
    public static MainActivity getMainActivity() {
        return mainActivity;
    }

package com.example.administrator.test_map;

import android.Manifest;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.graphics.Color;
import android.graphics.Typeface;
import android.os.Build;
import android.support.annotation.NonNull;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.TextView;
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.SDKInitializer;
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.MapPoi;
import com.baidu.mapapi.map.MapStatusUpdate;
import com.baidu.mapapi.map.MapStatusUpdateFactory;
import com.baidu.mapapi.map.MapView;
import com.baidu.mapapi.map.MapViewLayoutParams;
import com.baidu.mapapi.map.Marker;
import com.baidu.mapapi.map.MarkerOptions;
import com.baidu.mapapi.map.MyLocationConfiguration;
import com.baidu.mapapi.map.MyLocationData;
import com.baidu.mapapi.map.Stroke;
import com.baidu.mapapi.map.TextOptions;
import com.baidu.mapapi.map.offline.MKOfflineMapListener;
import com.baidu.mapapi.model.LatLng;
import com.baidu.mapapi.search.core.SearchResult;
import com.baidu.mapapi.search.geocode.GeoCodeOption;
import com.baidu.mapapi.search.geocode.GeoCodeResult;
import com.baidu.mapapi.search.geocode.GeoCoder;
import com.baidu.mapapi.search.geocode.OnGetGeoCoderResultListener;
import com.baidu.mapapi.search.geocode.ReverseGeoCodeResult;

public class MainActivity extends AppCompatActivity {

    private static MainActivity mainActivity;
    private MapView mMapView = null;
    public BaiduMap mBaiduMap = null;
    private MKOfflineMapListener listener = null;
    public LocationClient mLocationClient;
    private BitmapDescriptor geo;
    public LatLng my_now_latLng = new LatLng(0.0, 0.0);
    //定位
    //要显示的pop
    private View pop;
    //pop中的文本信息
    private TextView title;
    private BaiduMap baiduMap;
    private GeoCoder mSearch = null;
    private Button mButtonOne;
    private Button mButtonTwo;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        onTakePhoto();
        //获取地图控件引用
        mMapView = (MapView) findViewById(R.id.bmapView);//获得地图视图的对象
        mBaiduMap = mMapView.getMap();//获得地图对象
        get_main_map();
        //单击地图事件
        map_onclick_sinple();
        //初始化
        init();
        init_position_map();
//        mLocationClient.start();

        //初始化搜索模块，注册事件监听
        mSearch = GeoCoder.newInstance();//获得搜索的对象
        mSearch.setOnGetGeoCodeResultListener(new OnGetGeoCoderResultListener() {
            @Override
            public void onGetGeoCodeResult(GeoCodeResult geoCodeResult) {
                if (geoCodeResult == null || geoCodeResult.error != SearchResult.ERRORNO.NO_ERROR) {
                    Toast.makeText(MainActivity.this, "抱歉，未能找到结果", Toast.LENGTH_LONG)
                            .show();
                    return;
                }
                mBaiduMap.addOverlay(new MarkerOptions().position(geoCodeResult.getLocation())
                        .icon(BitmapDescriptorFactory
                                .fromResource(R.mipmap.icon_mark)));
                mBaiduMap.setMapStatus(MapStatusUpdateFactory.newLatLng(geoCodeResult
                        .getLocation()));
                String strInfo = String.format("纬度：%f 经度：%f",
                        geoCodeResult.getLocation().latitude, geoCodeResult.getLocation().longitude);
                Log.d("data", strInfo);
                Toast.makeText(MainActivity.this, strInfo, Toast.LENGTH_LONG).show();
            }

            @Override
            public void onGetReverseGeoCodeResult(ReverseGeoCodeResult reverseGeoCodeResult) {
            }
        });
        //获取布局中的各个控件对象
        mButtonOne = (Button) findViewById(R.id.button_one);
        mButtonTwo = (Button) findViewById(R.id.button_two);
        Toast.makeText(MainActivity.this, "现在我的位置"+my_now_latLng, Toast.LENGTH_LONG).show();

    }

    public BaiduMap get_main_map() {
        return mBaiduMap;
    }
    private void init_position_map() {
        MyPositioning myPositioning=new MyPositioning();
        //设置定位图层
        mBaiduMap.setMyLocationConfiguration(myPositioning.locationConfig());
        //开启定位
        MyLocationListener myListener = new MyLocationListener();

        mLocationClient= myPositioning.initLBS(mLocationClient,myListener);
        mLocationClient.start();
        // 开启定位图层
        mBaiduMap.setMyLocationEnabled(true);
    }
    public MainActivity() {
        mainActivity = this;
    }
    public static MainActivity getMainActivity() {
        return mainActivity;
    }
    //参数 requestCode是我们在申请权限的时候使用的唯一的申请码
    //String[] permission则是权限列表，一般用不到
    //int[] grantResults 是用户的操作响应，包含这权限是够请求成功
    //由于在权限申请的时候，我们就申请了一个权限，所以此处的数组的长度都是1
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == 123) {            //当然权限多了，建议使用Switch，不必纠结于此
            if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(this, "权限申请成功", Toast.LENGTH_SHORT).show();
            } else if (grantResults[0] == PackageManager.PERMISSION_DENIED) {
//                Toast.makeText(this, "权限申请失败，用户拒绝权限", Toast.LENGTH_SHORT).show();
            }
        }
    }

    public void onTakePhoto() {
        if (Build.VERSION.SDK_INT >= 23) {
            ActivityCompat EasyPermissions = null;
            EasyPermissions.requestPermissions(MainActivity.this, new String[]{
                    Manifest.permission.READ_CONTACTS,
                    Manifest.permission.RECEIVE_SMS,
                    Manifest.permission.WRITE_CONTACTS,
                    Manifest.permission.CAMERA,
                    Manifest.permission.ACCESS_COARSE_LOCATION,
                    Manifest.permission.ACCESS_WIFI_STATE,
                    Manifest.permission.ACCESS_NETWORK_STATE,
                    Manifest.permission.CHANGE_WIFI_STATE,
                    Manifest.permission.ACCESS_FINE_LOCATION,
                    Manifest.permission.READ_PHONE_STATE,
                    Manifest.permission.WRITE_EXTERNAL_STORAGE,
                    Manifest.permission.INTERNET,
                    Manifest.permission.WAKE_LOCK,
                    Manifest.permission.READ_EXTERNAL_STORAGE}, 123
            );
            int request = ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION);
            if (request != PackageManager.PERMISSION_GRANTED)//缺少权限，进行权限申请
            {
                ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_COARSE_LOCATION}, 123);
                return;//
            } else {
                //权限同意，不需要处理,去掉用拍照的方法
                Toast.makeText(this,"定位权限同意",Toast.LENGTH_SHORT).show();
            }
        } else {
            //低于23 不需要特殊处理，去掉用拍照的方法
        }
    }

    private void map_onclick_sinple() {

        //地图单击事件
        BaiduMap.OnMapClickListener listener2 = new BaiduMap.OnMapClickListener() {
            @Override
            public void onMapClick(LatLng latLng) {

                drawCircle(latLng);
                Toast.makeText(getApplicationContext(), "点击事件:" + latLng, Toast.LENGTH_LONG).show();
            }

            @Override
            public void onMapPoiClick(MapPoi mapPoi) {

            }
        };
        //设置地图单击事件监听
        mBaiduMap.setOnMapClickListener(listener2);

        //覆盖物单击事件监听
        mBaiduMap.setOnMarkerClickListener(new BaiduMap.OnMarkerClickListener() {
            @Override
            /**mark的点击事件
             * 点击某一个mark在他上放显示泡泡
             * 加载pop 添加到mapview 把他设置为隐藏 当点击的时候更新pop的位置 设置为显示
             */
            public boolean onMarkerClick(Marker marker) {
                Bundle bundle = marker.getExtraInfo();
                //get data from bundle and do something
                //处理点击 ,当点击的时候更新并且显示位置
                initPop();
                ViewGroup.LayoutParams params = new MapViewLayoutParams.Builder().
                        layoutMode(MapViewLayoutParams.ELayoutMode.mapMode) //按照经纬度设置位置
                        .position(marker.getPosition()) //这个坐标无所谓的，但是不能传null
                        .width(MapViewLayoutParams.WRAP_CONTENT)  //宽度
                        .height(MapViewLayoutParams.WRAP_CONTENT)  //高度
                        .yOffset(-5)  //相距  正值往下  负值往上
                        .build();
                mMapView.updateViewLayout(pop, params);
                pop.setVisibility(View.VISIBLE);
                //更新下title
                title.setText(marker.getTitle());
                return false;
            }
        });

    }

    //    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.button_one:
                //获得*的地址
                mSearch.geocode(new GeoCodeOption().city("北京市").address("海淀区中关村海龙大厦"));
                break;
            case R.id.button_two:
                //获得中关村的地址
                mSearch.geocode(new GeoCodeOption().city("北京市").address("西城区西便门"));
                break;
        }
    }

    private void init() {
        //注册广播判断网络
        IntentFilter filter = new IntentFilter();
        // 网络错误
        filter.addAction(SDKInitializer.SDK_BROADCAST_ACTION_STRING_NETWORK_ERROR);
        // 效验key失败
        filter.addAction(SDKInitializer.SDK_BROADTCAST_ACTION_STRING_PERMISSION_CHECK_ERROR);
        SDKReceiver receiver = new SDKReceiver();
        registerReceiver(receiver, filter);

        //改变地图显示方式
        //普通地图 ,mBaiduMap是地图控制器对象
        mBaiduMap.setMapType(BaiduMap.MAP_TYPE_NORMAL);
//        开启地图的定位图层
        mBaiduMap.setIndoorEnable(true);//打开室内图，默认为关闭状态
        //描述地图将要发生的变化，使用工厂类MapStatusUpdateFactory创建，设置级别
        //为18，进去就是18了，默认是12
        MapStatusUpdate mapStatusUpdate = MapStatusUpdateFactory.zoomTo(18);
        mBaiduMap.setMapStatus(mapStatusUpdate);
        //显示指南针
        mBaiduMap.getUiSettings().setCompassEnabled(false);
        //显示位置
//        mBaiduMap.getUiSettings().setCompassPosition(new Point(100, 400));


    }

    //初始化pop
    private void initPop() {
        pop = View.inflate(getApplicationContext(), R.layout.layout, null);
        //必须使用百度的params
        ViewGroup.LayoutParams params = new MapViewLayoutParams.Builder().layoutMode(MapViewLayoutParams.ELayoutMode.mapMode) //按照经纬度设置
                .position(new LatLng(22.5422870000, 113.9804440000)) //这个坐标无所谓的，但是不能传null
                .width(MapViewLayoutParams.WRAP_CONTENT)  //宽度
                .height(MapViewLayoutParams.WRAP_CONTENT)  //高度
                .build();
        mMapView.addView(pop, params);
        //先设置隐藏，点击的时候显示
        pop.setVisibility(View.INVISIBLE);
        //初始化这个title
        title = (TextView) pop.findViewById(R.id.title);
    }

    // 绘制圆
    private void drawCircle(LatLng p1) {
        // 1.创建自己
        CircleOptions circleOptions = new CircleOptions();
        circleOptions.center(p1)//中心
                .radius(200)  //半径
                .fillColor(0x3000FF00)//填充圆的颜色
                .stroke(new Stroke(10, 0x600FF000));  //边框的宽度和颜色
        //把绘制的圆添加到百度地图上去
        mBaiduMap.addOverlay(circleOptions);
    }

    // 绘制文字
    private void drawText() {
        TextOptions textOptions = new TextOptions();
        textOptions.fontColor(Color.RED) //设置字体颜色
                .text("自定义文字覆盖物")  //设置显示文本
                .position(new LatLng(22.5422870000, 113.9804440000))   //设置显示坐标
                .fontSize(20) //设置文本大小
                .typeface(Typeface.SERIF)  //设置字体 Android的字体就三种，对称的，不对称的，等宽的
                .rotate(30);  //设置旋转角度
        //把绘制的圆添加到百度地图上去
        mBaiduMap.addOverlay(textOptions);
    }

    // 绘制mark覆盖物
    private void drawMark() {

        Bundle extraInfo = new Bundle();
        extraInfo.putString("title", "世界之窗旁边的草房");

        MarkerOptions markerOptions = new MarkerOptions();
        BitmapDescriptor bitmap = BitmapDescriptorFactory.fromResource(R.mipmap.icon_mark); // 描述图片
        markerOptions.position(new LatLng(22.5422870000, 113.9804440000)) // 设置位置
                .icon(bitmap) // 加载图片
                .draggable(true) // 支持拖拽
                .extraInfo(extraInfo.getBundle("title")); // 显示文本
        //把绘制的圆添加到百度地图上去
        mBaiduMap.addOverlay(markerOptions);
    }

    @Override
    /*
    Activity关闭时将地图关闭
     */
    protected void onDestroy() {
        super.onDestroy();
        // 在activity执行onDestroy时执行mMapView.onDestroy()，实现地图生命周期管理
        mMapView.onDestroy();
    }

    @Override
    protected void onResume() {
        super.onResume();
        // 在activity执行onResume时执行mMapView. onResume ()，实现地图生命周期管理
        mMapView.onResume();
    }

    @Override
    protected void onPause() {
        super.onPause();
        // 在activity执行onPause时执行mMapView. onPause ()，实现地图生命周期管理
        mMapView.onPause();
    }
    public class MyLocationListener extends BDAbstractLocationListener {
        @Override
        public void onReceiveLocation(BDLocation location) {
            double latitude = location.getLatitude();    //获取纬度信息
            double longitude = location.getLongitude();    //获取经度信息
            Log.e("444", latitude + " " + longitude);
            // 构造定位数据
            MyLocationData locData = new MyLocationData.Builder()
                    .accuracy(location.getRadius())
                    // 此处设置开发者获取到的方向信息，顺时针0-360
                    .direction(100).latitude(location.getLatitude())
                    .longitude(location.getLongitude()).build();
            // 设置定位数据
            mBaiduMap.setMyLocationData(locData);
            mLocationClient.stop();
            //地理坐标基本数据结构
            LatLng latLng = new LatLng(latitude, longitude);
            my_now_latLng=latLng;
            Toast.makeText(MainActivity.this, "现在我的位置1"+my_now_latLng, Toast.LENGTH_LONG).show();

            //描述地图状态将要发生的变化,通过当前经纬度来使地图显示到该位置
            MapStatusUpdate msu = MapStatusUpdateFactory.newLatLng(latLng);
            //改变地图状态
            mBaiduMap.setMapStatus(msu);

        }
    }

}

package com.example.administrator.test_map;

import android.content.Context;
import android.graphics.Color;
import com.baidu.location.LocationClient;
import com.baidu.location.LocationClientOption;
import com.baidu.mapapi.map.BitmapDescriptor;
import com.baidu.mapapi.map.BitmapDescriptorFactory;
import com.baidu.mapapi.map.MyLocationConfiguration;

/**
 * Created by Administrator on 2019/10/12.
 * 专门使用来进行定位
 */
public class MyPositioning {
    private Context maincontext= MainActivity.getMainActivity();;

    /**
     * 初始化定位参数配置
     */
    public void initLocationOption(MainActivity.MyLocationListener myLocationListener ) {
//定位服务的客户端。宿主程序在客户端声明此类，并调用，目前只支持在主线程中启动
        LocationClient locationClient = new LocationClient(maincontext);
//声明LocationClient类实例并配置定位参数
        LocationClientOption locationOption = new LocationClientOption();
//注册监听函数
        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，设置是否当gps有效时按照1S1次频率输出GPS结果
        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，设置是否开启Gps定位
        locationOption.setOpenGps(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();
    }
    /**
     * 实现定位回调
     */
    public MyLocationConfiguration locationConfig() {
//        mCurrentMode = LocationMode.FOLLOWING;//定位跟随态
//        mCurrentMode = LocationMode.NORMAL;   //默认为 LocationMode.NORMAL 普通态
//        mCurrentMode = LocationMode.COMPASS;  //定位罗盘态
        MyLocationConfiguration.LocationMode locationMode = MyLocationConfiguration.LocationMode.NORMAL;
        //是否开启方向
        boolean enableDirection = true;
        //自定义定位图标
        BitmapDescriptor bitmapDescriptor = BitmapDescriptorFactory.fromResource(R.mipmap.ic_launcher);
        //精度圈填充颜色
        int accuracyCircleFillColor = Color.parseColor("#99ff0000");
        //自定义精度圈边框颜色
        int accuracyCircleStrokeColor = Color.parseColor("#11ff0000");
        MyLocationConfiguration locationConfiguration = new MyLocationConfiguration(
                locationMode,
                enableDirection,
                bitmapDescriptor,
                accuracyCircleFillColor,
                accuracyCircleStrokeColor
        );
        return locationConfiguration;
    }
    public LocationClient initLBS(LocationClient mLocationClient,MainActivity.MyLocationListener myListener) {
        mLocationClient= new LocationClient(maincontext);
        //声明LocationClient类
        mLocationClient.registerLocationListener(myListener);
        //注册监听函数
        LocationClientOption option = new LocationClientOption();
        option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);
        option.setCoorType("bd09ll");
        option.setScanSpan(1000);
        option.setOpenGps(true);
        mLocationClient.setLocOption(option);
        return mLocationClient;
    }
}

package com.example.administrator.test_map;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.widget.Toast;

import com.baidu.mapapi.SDKInitializer;

/**
 * Created by Administrator on 2019/10/11.
 */

public class SDKReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        // 网络错误
        if (action.equals(SDKInitializer.SDK_BROADCAST_ACTION_STRING_NETWORK_ERROR)) {

            Toast.makeText(context, "无法连接网络", Toast.LENGTH_SHORT).show();
            // key效验失败
        } else if(action.equals(SDKInitializer.SDK_BROADTCAST_ACTION_STRING_PERMISSION_CHECK_ERROR)) {
            Toast.makeText(context, "百度地图key效验失败",Toast.LENGTH_SHORT).show();
        } else if (action.equals(SDKInitializer.SDK_BROADTCAST_ACTION_STRING_PERMISSION_CHECK_OK)) {
            //key验证成功，做相应处理
        }
    }
}

package com.example.administrator.test_map;

import android.app.Application;

import com.baidu.mapapi.CoordType;
import com.baidu.mapapi.SDKInitializer;

/**
 * Created by Administrator on 2019/10/8.
 */

public class DemoApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        //在使用SDK各组件之前初始化context信息，传入ApplicationContext
        SDKInitializer.initialize(this);
        //自4.3.0起，百度地图SDK所有接口均支持百度坐标和国测局坐标，用此方法设置您使用的坐标类型.
        //包括BD09LL和GCJ02两种坐标，默认是BD09LL坐标。
        SDKInitializer.setCoordType(CoordType.BD09LL);
    }
}