Java Code Examples for com.baidu.location.LocationClientOption#setIsNeedLocationDescribe()

private void initLocation() {
    LocationClientOption option = new LocationClientOption();
    option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy
    );//可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
    option.setCoorType("bd09ll");//可选，默认gcj02，设置返回的定位结果坐标系
    int span = 1000;
    option.setScanSpan(span);//可选，默认0，即仅定位一次，设置发起定位请求的间隔需要大于等于1000ms才是有效的
    option.setIsNeedAddress(true);//可选，设置是否需要地址信息，默认不需要
    option.setOpenGps(true);//可选，默认false,设置是否使用gps
    option.setLocationNotify(true);//可选，默认false，设置是否当GPS有效时按照1S/1次频率输出GPS结果
    option.setIsNeedLocationDescribe(true);//可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
    option.setIsNeedLocationPoiList(true);//可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
    option.setIgnoreKillProcess(false);//可选，默认true，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认不杀死
    option.SetIgnoreCacheException(false);//可选，默认false，设置是否收集CRASH信息，默认收集
    option.setEnableSimulateGps(false);//可选，默认false，设置是否需要过滤GPS仿真结果，默认需要
    mLocationClient.setLocOption(option);

}
 

private void initLocation() {
    LocationClientOption option = new LocationClientOption();
    option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy
    );//可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
    option.setCoorType("bd09ll");//可选，默认gcj02，设置返回的定位结果坐标系
    int span = 2000;
    option.setScanSpan(0);//可选，默认0，即仅定位一次，设置发起定位请求的间隔需要大于等于1000ms才是有效的
    option.setIsNeedAddress(true);//可选，设置是否需要地址信息，默认不需要
    option.setOpenGps(true);//可选，默认false,设置是否使用gps
    option.setLocationNotify(true);//可选，默认false，设置是否当gps有效时按照1S1次频率输出GPS结果
    option.setIsNeedLocationDescribe(true);//可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
    option.setIsNeedLocationPoiList(true);//可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
    option.setIgnoreKillProcess(false);//可选，默认true，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认不杀死
    option.SetIgnoreCacheException(false);//可选，默认false，设置是否收集CRASH信息，默认收集
    option.setEnableSimulateGps(false);//可选，默认false，设置是否需要过滤gps仿真结果，默认需要
    mLocationClient.setLocOption(option);
}
 

private void initLocation() {
    LocationClientOption option = new LocationClientOption();
    option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy
    );//可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
    option.setCoorType("bd09ll");//可选，默认gcj02，设置返回的定位结果坐标系
    int span = 2000;
    option.setScanSpan(0);//可选，默认0，即仅定位一次，设置发起定位请求的间隔需要大于等于1000ms才是有效的
    option.setIsNeedAddress(true);//可选，设置是否需要地址信息，默认不需要
    option.setOpenGps(true);//可选，默认false,设置是否使用gps
    option.setLocationNotify(true);//可选，默认false，设置是否当gps有效时按照1S1次频率输出GPS结果
    option.setIsNeedLocationDescribe(true);//可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
    option.setIsNeedLocationPoiList(true);//可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
    option.setIgnoreKillProcess(false);//可选，默认true，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认不杀死
    option.SetIgnoreCacheException(false);//可选，默认false，设置是否收集CRASH信息，默认收集
    option.setEnableSimulateGps(false);//可选，默认false，设置是否需要过滤gps仿真结果，默认需要
    mLocationClient.setLocOption(option);
}
 

private static void initLocation()
{
	LocationClientOption option = new LocationClientOption();
	option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy
	);//可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
	option.setCoorType("bd09ll");//可选，默认gcj02，设置返回的定位结果坐标系
	int span = 0;
	option.setScanSpan(span);//可选，默认0，即仅定位一次，设置发起定位请求的间隔需要大于等于1000ms才是有效的
	option.setIsNeedAddress(true);//可选，设置是否需要地址信息，默认不需要
	option.setOpenGps(true);//可选，默认false,设置是否使用gps
	option.setLocationNotify(true);//可选，默认false，设置是否当gps有效时按照1S1次频率输出GPS结果
	option.setIsNeedLocationDescribe(true);//可选，默认false，设置是否需要位置语义化结果，可以在BDLocation
	// .getLocationDescribe里得到，结果类似于“在北京天安门附近”
	option.setIsNeedLocationPoiList(false);//可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
	option.setIgnoreKillProcess(false);
	//可选，默认false，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认杀死
	option.SetIgnoreCacheException(true);//可选，默认false，设置是否收集CRASH信息，默认收集
	option.setEnableSimulateGps(false);//可选，默认false，设置是否需要过滤gps仿真结果，默认需要
	mClient.setLocOption(option);
}
 

private void initLocationClient() {
        geoCoder = GeoCoder.newInstance();
        poiSearch = PoiSearch.newInstance();
        poiSearch.setOnGetPoiSearchResultListener(this);
        locationClient = new LocationClient(getApplication());
        LocationClientOption option = new LocationClientOption();
        option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);
        option.setCoorType(CoordinateType.BD09LL);
//        option.setScanSpan(5000);//
        option.setIsNeedAddress(true);
        option.setOpenGps(true);
        option.setLocationNotify(true);
        option.setIsNeedLocationDescribe(true);
        option.setIsNeedLocationPoiList(true);
        option.setIgnoreKillProcess(true);
        option.SetIgnoreCacheException(true);
        option.setEnableSimulateGps(true);
        locationClient.setLocOption(option);
        locationClient.registerLocationListener(this);
        locationClient.start();
    }
 

private void initLocationClient() {
    locationClient = new LocationClient(getApplicationContext());
    LocationClientOption option = new LocationClientOption();
    option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);
    option.setCoorType(CoordinateType.BD09LL);
    option.setIsNeedAddress(true);
    option.setOpenGps(true);
    option.setLocationNotify(true);
    option.setNeedDeviceDirect(true);
    option.setIsNeedLocationDescribe(false);
    option.setIsNeedLocationPoiList(true);
    option.setIgnoreKillProcess(true);
    option.SetIgnoreCacheException(true);
    option.setEnableSimulateGps(true);
    //5s发送一次自己的位置
    option.setScanSpan(5000);
    locationClient.setLocOption(option);
    locationClient.registerLocationListener(this);
    locationClient.start();
}
 

private void initLocation() {
	// 声明LocationClient类
	mLocationClient = new LocationClient(getContext());
	option = new LocationClientOption();
	option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);
	option.setCoorType("bd09ll");
	option.setOpenGps(true);
	option.setLocationNotify(true);
	option.setIgnoreKillProcess(true);
	option.SetIgnoreCacheException(false);
	option.setEnableSimulateGps(false);
	option.setIsNeedLocationDescribe(true);
	option.setIsNeedLocationPoiList(true);
	option.setIsNeedAddress(true);

	mLocationClient.setLocOption(option);
	// 注册监听函数
	mLocationClient.registerLocationListener(myListener);
	mLocationClient.start();
}
 

private void initLocation() {
    LocationClientOption option = new LocationClientOption();
    option.setLocationMode(LocationClientOption.LocationMode.Battery_Saving);
    //可选，默认高精度，设置定位模式，高精度，低功耗，仅设备

    option.setCoorType("bd09ll");
    //可选，默认gcj02，设置返回的定位结果坐标系

    option.setIsNeedAddress(true);
    //可选，设置是否需要地址信息，默认不需要

    option.setOpenGps(true);
    //可选，默认false,设置是否使用gps

    option.setLocationNotify(true);
    //可选，默认false，设置是否当GPS有效时按照1S/1次频率输出GPS结果

    option.setIsNeedLocationDescribe(true);
    //可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”

    option.setIsNeedLocationPoiList(true);
    //可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到

    option.setIgnoreKillProcess(false);
    //可选，默认true，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认不杀死

    option.SetIgnoreCacheException(false);
    //可选，默认false，设置是否收集CRASH信息，默认收集

    option.setEnableSimulateGps(false);
    //可选，默认false，设置是否需要过滤GPS仿真结果，默认需要

    mLocationClient.setLocOption(option);
}
 

/***
 * @return Default LocationClientOption
 * 详情请查看{ http://wiki.lbsyun.baidu.com/cms/androidloc/doc/v7.1/index.html }
 */
private LocationClientOption getDefaultLocationClientOption() {
    final LocationClientOption option = new LocationClientOption();
    option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);
    option.setIsNeedAddress(true);
    option.setIsNeedLocationDescribe(true);
    option.setNeedDeviceDirect(false);
    option.setLocationNotify(false);
    option.setIgnoreKillProcess(true);
    option.setIsNeedLocationDescribe(true);
    option.setIsNeedLocationPoiList(true);
    option.SetIgnoreCacheException(false);
    option.setIsNeedAltitude(false);
    return option;
}
 

private void initLocation() {
    LocationClientOption option = new LocationClientOption();
    option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);//可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
    option.setCoorType("bd09ll");//可选，默认gcj02，设置返回的定位结果坐标系
    option.setScanSpan(1000);//可选，默认0，即仅定位一次，设置发起定位请求的间隔需要大于等于1000ms才是有效的
    option.setIsNeedAddress(true);//可选，设置是否需要地址信息，默认不需要
    option.setOpenGps(true);//可选，默认false,设置是否使用gps
    option.setLocationNotify(true);//可选，默认false，设置是否当GPS有效时按照1S/1次频率输出GPS结果
    option.setIsNeedLocationDescribe(true);//可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
    option.setIsNeedLocationPoiList(true);//可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
    option.setIgnoreKillProcess(false);//可选，默认true，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认不杀死
    option.SetIgnoreCacheException(false);//可选，默认false，设置是否收集CRASH信息，默认收集
    option.setEnableSimulateGps(false);//可选，默认false，设置是否需要过滤GPS仿真结果，默认需要
    MyApplication.getmLocationClient().setLocOption(option);
}
 

/**
 * 获取LocationClient配置
 * @return
 */
public static LocationClientOption getLocationClientOption() {
    LocationClientOption option = new LocationClientOption();
    //可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
    option.setLocationMode(LocationClientOption.LocationMode.Battery_Saving);
    //可选，默认gcj02，设置返回的定位结果坐标系
    option.setCoorType("bd09ll");
    //可选，默认0，即仅定位一次，设置发起定位请求的间隔需要大于等于1000ms才是有效的
    int span = 1000;
    option.setScanSpan(span);
    //可选，设置是否需要地址信息，默认不需要
    option.setIsNeedAddress(true);
    //可选，默认false,设置是否使用gps
    option.setOpenGps(true);
    //可选，默认false，设置是否当GPS有效时按照1S/1次频率输出GPS结果
    option.setLocationNotify(true);
    //可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
    option.setIsNeedLocationDescribe(true);
    //可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
    option.setIsNeedLocationPoiList(true);
    //可选，默认true，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认不杀死
    option.setIgnoreKillProcess(false);
    //可选，默认false，设置是否收集CRASH信息，默认收集
    option.SetIgnoreCacheException(false);
    //可选，默认false，设置是否需要过滤GPS仿真结果，默认需要
    option.setEnableSimulateGps(false);
    return option;
}
 

private LocationClientOption initLocationOption() {
    LocationClientOption option = new LocationClientOption();
    // optional,default is high accuracy. low power ,only on the device
    option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);
    // optional，default is gcj02，later can return converted coordinate system type
    option.setCoorType("gcj02");
    // optional，default is 0，only location once,
    // it is work when inteval time between location request is greater than or equal to 1000ms
    option.setScanSpan(SPAN_MIL);
    // optional，default is false
    option.setIsNeedAddress(false);
    // optional，default is false,whether use gps
    option.setOpenGps(true);
    // optional，default is false，whether output GPS results acording to 1S1 frequency when gps is valid
    option.setLocationNotify(false);
    // optional，default is false，whether need the describe of the location
    option.setIsNeedLocationDescribe(false);
    // optional，default is false，whether need POI result which can get in BDLocation.getPoiList
    option.setIsNeedLocationPoiList(false);
    // optional，default is true，there is a service in the loaction sdk,
    // and it run in a independent process, whether kill the service when stop
    option.setIgnoreKillProcess(true);
    // optional，default is false，whether collect crash info
    option.SetIgnoreCacheException(false);
    // optional，default is false，weather filter the result of the gps simulation
    option.setEnableSimulateGps(true);

    return option;
}
 

@Override
public void requestLocation(Context context, @NonNull LocationCallback callback){
    this.callback = callback;

    LocationClientOption option = new LocationClientOption();
    option.setLocationMode(LocationClientOption.LocationMode.Battery_Saving); // 可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
    option.setCoorType("wgs84"); // 可选，默认gcj02，设置返回的定位结果坐标系
    option.setScanSpan(0); // 可选，默认0，即仅定位一次，设置发起定位请求的间隔需要大于等于1000ms才是有效的
    option.setIsNeedAddress(true); // 可选，设置是否需要地址信息，默认不需要
    option.setOpenGps(false); // 可选，默认false,设置是否使用gps
    option.setLocationNotify(false); // 可选，默认false，设置是否当gps有效时按照1S1次频率输出GPS结果
    option.setIsNeedLocationDescribe(false); // 可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
    option.setIsNeedLocationPoiList(false); // 可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
    option.setIgnoreKillProcess(false); // 可选，默认true，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认不杀死
    option.SetIgnoreCacheException(true); // 可选，默认false，设置是否收集CRASH信息，默认收集
    option.setEnableSimulateGps(false); // 可选，默认false，设置是否需要过滤gps仿真结果，默认需要
    option.setWifiCacheTimeOut(5 * 60 * 1000); // 可选，如果设置了该接口，首次启动定位时，会先判断当前WiFi是否超出有效期，若超出有效期，会先重新扫描WiFi，然后定位
    client = new LocationClient(context.getApplicationContext());
    client.setLocOption(option);
    client.registerLocationListener(listener);

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        manager.createNotificationChannel(getLocationNotificationChannel(context));
        client.enableLocInForeground(
                GeometricWeather.NOTIFICATION_ID_LOCATION,
                getLocationNotification(context));
    }
    client.start();
}
 

private void initLocation() {
    // 利用LocationClientOption类配置定位SDK参数
    option = new LocationClientOption();
    option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);
    // 可选，设置定位模式，默认高精度
    // LocationMode.Hight_Accuracy：高精度；
    // LocationMode. Battery_Saving：低功耗；
    // LocationMode. Device_Sensors：仅使用设备；

    option.setCoorType("bd09ll");
    // 可选，设置返回经纬度坐标类型，默认gcj02
    // gcj02：国测局坐标；
    // bd09ll：百度经纬度坐标；
    // bd09：百度墨卡托坐标；
    // 海外地区定位，无需设置坐标类型，统一返回wgs84类型坐标

    option.setOpenGps(true);
    // 可选，设置是否使用gps，默认false
    // 使用高精度和仅用设备两种定位模式的，参数必须设置为true

    option.setLocationNotify(true);
    // 可选，设置是否当GPS有效时按照1S/1次频率输出GPS结果，默认false

    option.setIgnoreKillProcess(true);
    // 可选，定位SDK内部是一个service，并放到了独立进程。
    // 设置是否在stop的时候杀死这个进程，默认（建议）不杀死，即setIgnoreKillProcess(true)

    option.SetIgnoreCacheException(false);
    // 可选，设置是否收集Crash信息，默认收集，即参数为false

    option.setEnableSimulateGps(false);
    // 可选，设置是否需要过滤GPS仿真结果，默认需要，即参数为false

    option.setIsNeedLocationDescribe(true);
    // 可选，是否需要位置描述信息，默认为不需要，即参数为false
    // 如果开发者需要获得当前点的位置信息，此处必须为true

    option.setIsNeedLocationPoiList(true);
    // 可选，是否需要周边POI信息，默认为不需要，即参数为false
    // 如果开发者需要获得周边POI信息，此处必须为true

    option.setIsNeedAddress(true);// 获取详细信息

    mLocationClient.setLocOption(option);
    // mLocationClient为第二步初始化过的LocationClient对象
    // 需将配置好的LocationClientOption对象，通过setLocOption方法传递给LocationClient对象使用
    // 更多LocationClientOption的配置，请参照类参考中LocationClientOption类的详细说明
}
 

private void initLocation() {
    // 利用LocationClientOption类配置定位SDK参数
    option = new LocationClientOption();
    option.setLocationMode(LocationMode.Hight_Accuracy);
    // 可选，设置定位模式，默认高精度
    // LocationMode.Hight_Accuracy：高精度；
    // LocationMode. Battery_Saving：低功耗；
    // LocationMode. Device_Sensors：仅使用设备；

    option.setCoorType("bd09ll");
    // 可选，设置返回经纬度坐标类型，默认gcj02
    // gcj02：国测局坐标；
    // bd09ll：百度经纬度坐标；
    // bd09：百度墨卡托坐标；
    // 海外地区定位，无需设置坐标类型，统一返回wgs84类型坐标

    option.setOpenGps(true);
    // 可选，设置是否使用gps，默认false
    // 使用高精度和仅用设备两种定位模式的，参数必须设置为true

    option.setLocationNotify(true);
    // 可选，设置是否当GPS有效时按照1S/1次频率输出GPS结果，默认false

    option.setIgnoreKillProcess(true);
    // 可选，定位SDK内部是一个service，并放到了独立进程。
    // 设置是否在stop的时候杀死这个进程，默认（建议）不杀死，即setIgnoreKillProcess(true)

    option.SetIgnoreCacheException(false);
    // 可选，设置是否收集Crash信息，默认收集，即参数为false

    option.setEnableSimulateGps(false);
    // 可选，设置是否需要过滤GPS仿真结果，默认需要，即参数为false

    option.setIsNeedLocationDescribe(true);
    // 可选，是否需要位置描述信息，默认为不需要，即参数为false
    // 如果开发者需要获得当前点的位置信息，此处必须为true

    option.setIsNeedLocationPoiList(true);
    // 可选，是否需要周边POI信息，默认为不需要，即参数为false
    // 如果开发者需要获得周边POI信息，此处必须为true

    option.setIsNeedAddress(true);// 获取详细信息

    mLocationClient.setLocOption(option);
    // mLocationClient为第二步初始化过的LocationClient对象
    // 需将配置好的LocationClientOption对象，通过setLocOption方法传递给LocationClient对象使用
    // 更多LocationClientOption的配置，请参照类参考中LocationClientOption类的详细说明
}
 

private void initView() {
    mMapView = (MapView) findViewById(R.id.main_bdmap);
    mBaiduMap = mMapView.getMap();

    poisLL = (ListView) findViewById(R.id.main_pois);

    topRL = (RelativeLayout) findViewById(R.id.main_top_RL);

    searchAddress = (EditText) findViewById(R.id.main_search_address);

    searchPois = (ListView) findViewById(R.id.main_search_pois);

    //定义地图状态
    MapStatus mMapStatus = new MapStatus.Builder().zoom(18).build();
    MapStatusUpdate mMapStatusUpdate = MapStatusUpdateFactory.newMapStatus(mMapStatus);
    //改变地图状态
    mBaiduMap.setMapStatus(mMapStatusUpdate);

    //地图状态改变相关监听
    mBaiduMap.setOnMapStatusChangeListener(this);

    //开启定位图层
    mBaiduMap.setMyLocationEnabled(true);

    //定位图层显示方式
    mCurrentMode = MyLocationConfiguration.LocationMode.NORMAL;

    /**
     * 设置定位图层配置信息，只有先允许定位图层后设置定位图层配置信息才会生效
     * customMarker用户自定义定位图标
     * enableDirection是否允许显示方向信息
     * locationMode定位图层显示方式
     */
    mBaiduMap.setMyLocationConfigeration(new MyLocationConfiguration(mCurrentMode, true, null));

    //初始化定位
    mLocClient = new LocationClient(this);
    //注册定位监听
    mLocClient.registerLocationListener(this);

    //定位选项
    LocationClientOption option = new LocationClientOption();
    /**
     * coorType - 取值有3个：
     * 返回国测局经纬度坐标系：gcj02
     * 返回百度墨卡托坐标系 ：bd09
     * 返回百度经纬度坐标系 ：bd09ll
     */
    option.setCoorType("bd09ll");
    //设置是否需要地址信息，默认为无地址
    option.setIsNeedAddress(true);
    //设置是否需要返回位置语义化信息，可以在BDLocation.getLocationDescribe()中得到数据，ex:"在天安门附近"， 可以用作地址信息的补充
    option.setIsNeedLocationDescribe(true);
    //设置是否需要返回位置POI信息，可以在BDLocation.getPoiList()中得到数据
    option.setIsNeedLocationPoiList(true);
    /**
     * 设置定位模式
     * Battery_Saving
     * 低功耗模式
     * Device_Sensors
     * 仅设备(Gps)模式
     * Hight_Accuracy
     * 高精度模式
     */
    option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);
    //设置是否打开gps进行定位
    option.setOpenGps(true);
    //设置扫描间隔，单位是毫秒 当<1000(1s)时，定时定位无效
    option.setScanSpan(1000);

    //设置 LocationClientOption
    mLocClient.setLocOption(option);

    //开始定位
    mLocClient.start();

}
 

private void initLocation() {
        LocationClientOption option = new LocationClientOption();
        option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy
        );//可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
        option.setCoorType("bd09ll");//可选，默认gcj02，设置返回的定位结果坐标系
        int span=100;
        option.setScanSpan(span);//大于等于1000ms时，使用定时定位模式。调用requestLocation()后，每隔设定的时间定定一次位
        option.setIsNeedAddress(true);//可选，设置是否需要地址信息，默认不需要
        option.setOpenGps(true);//可选，默认false,设置是否使用gps
        option.setLocationNotify(true);//可选，默认false，设置是否当GPS有效时按照1S/1次频率输出GPS结果
        option.setIsNeedLocationDescribe(true);//可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
        option.setIsNeedLocationPoiList(true);//可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
        option.setIgnoreKillProcess(false);//可选，默认true，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认不杀死
        option.SetIgnoreCacheException(false);//可选，默认false，设置是否收集CRASH信息，默认收集
        option.setEnableSimulateGps(false);//可选，默认false，设置是否需要过滤GPS仿真结果，默认需要
        mLocationClient.setLocOption(option);

        mLocationClient.registerLocationListener(new BDLocationListener() {
            @Override
            public void onReceiveLocation(BDLocation location) {
                //Receive Location
                StringBuffer sb = new StringBuffer(256);
                sb.append("定位时间: ");
                sb.append(location.getTime());
                sb.append("，纬度: ");
                sb.append(location.getLatitude());
                sb.append(",经度: ");
                sb.append(location.getLongitude());
                sb.append("，定位精度: ");
                sb.append(location.getRadius()+"米;");
                if (location.getLocType() == BDLocation.TypeGpsLocation) {// GPS定位结果
                   /*  sb.append(";我的速度");
                     sb.append(location.getSpeed());// 单位：公里每小时*/
//                     sb.append("\nsatellite : ");
//                     sb.append(location.getSatelliteNumber());
//                     sb.append("\nheight : ");
//                     sb.append(location.getAltitude());// 单位：米
//                     sb.append("\ndirection : ");
//                     sb.append(location.getDirection());// 单位度
                    sb.append("所在地址: ");
                    sb.append(location.getAddrStr());
                     sb.append("；定位方式: ");
                     sb.append("gps定位成功");

                } else if (location.getLocType() == BDLocation.TypeNetWorkLocation) {// 网络定位结果
                    sb.append("所在位置: ");
                    sb.append(location.getAddrStr());
                    //运营商信息
//                     sb.append("\noperationers : ");
//                     sb.append(location.getOperators());
//                     sb.append("；定位方式: ");
//                     sb.append("网络定位成功");
                } else if (location.getLocType() == BDLocation.TypeOffLineLocation) {// 离线定位结果
//                     sb.append("；定位方式: ");
//                     sb.append("离线定位成功，离线定位结果也是有效的");
                } else if (location.getLocType() == BDLocation.TypeServerError) {
//                     sb.append("；定位方式: ");
//                     sb.append("服务端网络定位失败，可以反馈IMEI号和大体定位时间到[email protected]，会有人追查原因");
                } else if (location.getLocType() == BDLocation.TypeNetWorkException) {
                   /*  sb.append("；定位方式: : ");
                     sb.append("网络不同导致定位失败，请检查网络是否通畅");*/
                } else if (location.getLocType() == BDLocation.TypeCriteriaException) {
//                     sb.append("；定位方式:");
//                     sb.append("无法获取有效定位依据导致定位失败，一般是由于手机的原因，处于飞行模式下一般会造成这种结果，可以试着重启手机");
                }
                sb.append(";位置描述: ");
                sb.append(location.getLocationDescribe());// 位置语义化信息
//                 List<Poi> list = location.getPoiList();// POI数据
//                 if (list != null) {
//                     sb.append("\npoilist size = : ");
//                     sb.append(list.size());
//                     for (Poi p : list) {
//                         sb.append("\npoi= : ");
//                         sb.append(p.getId() + " " + p.getName() + " " + p.getRank());
//                     }
//                 }
                editor.putString("location",sb.toString()).commit();

                Log.i("111111111111",sb.toString());
//               Toast.makeText(context, prefs.getString("location",""), Toast.LENGTH_LONG).show();


            }
        });
    }
 

void initializeService() {

    /**-------------定位---------------*/
    locationListener = new MyLocationListener();
    mLocationClient = new LocationClient(getApplicationContext());     //声明LocationClient类
    mLocationClient.registerLocationListener(locationListener);    //注册监听函数
    LocationClientOption option = new LocationClientOption();
    option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);//可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
    int span = 5000;
    option.setScanSpan(span);//可选，默认0，即仅定位一次，设置发起定位请求的间隔需要大于等于1000ms才是有效的
    option.setIsNeedAddress(true);//可选，设置是否需要地址信息，默认不需要
    option.setOpenGps(true);//可选，默认false,设置是否使用gps
    option.setLocationNotify(true);//可选，默认false，设置是否当gps有效时按照1S1次频率输出GPS结果
    option.setIsNeedLocationDescribe(true);//可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
    option.setIsNeedLocationPoiList(true);//可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
    option.setCoorType("bd09ll");
    mLocationClient.setLocOption(option);
    /**-------------周边雷达---------------*/
    //实例化
    radarSearchManager = RadarSearchManager.getInstance();
    radarNearbyOption = new RadarNearbySearchOption();
    radarNearbyOption.pageCapacity(50);
    radarNearbyOption.sortType(RadarNearbySearchSortType.distance_from_far_to_near);
    radarNearbyOption.pageNum(0);
    radarNearbyOption.radius(5000);

    /**-------------鹰眼轨迹--------------*/
    //实例化轨迹服务客户端
    lbsTraceClient = new LBSTraceClient(getApplicationContext());
    // 设置定位模式
    lbsTraceClient.setLocationMode(LocationMode.High_Accuracy);
    //位置采集周期
    int gatherInterval = 5;
    //打包周期
    int packInterval = 30;
    //设置位置采集和打包周期
    lbsTraceClient.setInterval(gatherInterval, packInterval);
    //轨迹服务类型（0 : 不上传位置数据，也不接收报警信息； 1 : 不上传位置数据，但接收报警信息；2 : 上传位置数据，且接收报警信息）
    traceType = 2;
    //轨迹监听器
    myOnTrackListener = new MyOnTrackListener();
    lbsTraceClient.setOnTrackListener(myOnTrackListener);
    /**-------------地理围栏---------------*/
    //OnTrackListener接口的实现类，实现轨迹监听器回调方法

    //轨迹服务中地理围栏监听器
    myOnGeoFenceListener = new MyOnGeoFenceListener();
    //Entity监听器
    myOnEntityListener = new MyOnEntityListener();
    lbsTraceClient.setOnGeoFenceListener(myOnGeoFenceListener);
    lbsTraceClient.setOnEntityListener(myOnEntityListener);

    /**--------------广播------------------*/
    mLocalBroadcastManager = LocalBroadcastManager.getInstance(this);
    myServiceReceiver = new myServiceReceiver();
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction("cc.bitlight.broadcast.service.start");
    intentFilter.addAction("cc.bitlight.broadcast.service.stop");
    intentFilter.addAction("cc.bitlight.broadcast.track.queryhistorytrack");
    intentFilter.addAction("cc.bitlight.broadcast.geofence.query");
    intentFilter.addAction("cc.bitlight.broadcast.mytemp");
    mLocalBroadcastManager.registerReceiver(myServiceReceiver, intentFilter);
  }
 

private void initLocationAndSearch() {

        //location
        mLocationClient = new LocationClient(getApplicationContext());     //声明LocationClient类
        mLocationClient.registerLocationListener(this);    //注册监听函数
        LocationClientOption option = new LocationClientOption();
        option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy
        );//可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
        option.setCoorType("bd09ll");//可选，默认gcj02，设置返回的定位结果坐标系
        int span = 1000;
        option.setScanSpan(span);//可选，默认0，即仅定位一次，设置发起定位请求的间隔需要大于等于1000ms才是有效的
        option.setIsNeedAddress(true);//可选，设置是否需要地址信息，默认不需要
        option.setOpenGps(true);//可选，默认false,设置是否使用gps
        option.setLocationNotify(true);//可选，默认false，设置是否当GPS有效时按照1S/1次频率输出GPS结果
        option.setIsNeedLocationDescribe(true);//可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
        option.setIsNeedLocationPoiList(true);//可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
        option.setIgnoreKillProcess(false);//可选，默认true，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认不杀死
        option.SetIgnoreCacheException(false);//可选，默认false，设置是否收集CRASH信息，默认收集
        option.setEnableSimulateGps(false);//可选，默认false，设置是否需要过滤GPS仿真结果，默认需要
        mLocationClient.setLocOption(option);
        //search

        mPoiSearch = PoiSearch.newInstance();
        mPoiSearch.setOnGetPoiSearchResultListener(new MyPoiSearchListener());
        mNearbySearchOption = new PoiNearbySearchOption()
                .radius(5000)
                .pageNum(1)
                .pageCapacity(20)
                .sortType(PoiSortType.distance_from_near_to_far);


        ////////////////
        mGeoCoder = GeoCoder.newInstance();
        mGeoCoder.setOnGetGeoCodeResultListener(new OnGetGeoCoderResultListener() {
            @Override
            public void onGetGeoCodeResult(GeoCodeResult geoCodeResult) {
                Log.e(TAG, "onGetGeoCodeResult: " + geoCodeResult.toString());
            }

            @Override
            public void onGetReverseGeoCodeResult(ReverseGeoCodeResult reverseGeoCodeResult) {
                Log.e(TAG, "onGetReverseGeoCodeResult: " + reverseGeoCodeResult.toString());
            }
        });


    }
 

private void initLocation() {
		// 声明LocationClient类
		mLocationClient = new LocationClient(getContext());

		// 利用LocationClientOption类配置定位SDK参数
		option = new LocationClientOption();
		option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);
		// 可选，设置定位模式，默认高精度  LocationMode.Hight_Accuracy：高精度； LocationMode. Battery_Saving：低功耗； LocationMode. Device_Sensors：仅使用设备；

		option.setCoorType("bd09ll");
		// 可选，设置返回经纬度坐标类型，默认gcj02
		// gcj02：国测局坐标；
		// bd09ll：百度经纬度坐标；
		// bd09：百度墨卡托坐标；
		// 海外地区定位，无需设置坐标类型，统一返回wgs84类型坐标

		option.setOpenGps(true);
		// 可选，设置是否使用gps，默认false
		// 使用高精度和仅用设备两种定位模式的，参数必须设置为true

		option.setLocationNotify(true);
		// 可选，设置是否当GPS有效时按照1S/1次频率输出GPS结果，默认false

		option.setIgnoreKillProcess(true);
		// 可选，定位SDK内部是一个service，并放到了独立进程。
		// 设置是否在stop的时候杀死这个进程，默认（建议）不杀死，即setIgnoreKillProcess(true)

		option.SetIgnoreCacheException(false);
		// 可选，设置是否收集Crash信息，默认收集，即参数为false

		option.setEnableSimulateGps(false);
		// 可选，设置是否需要过滤GPS仿真结果，默认需要，即参数为false

		option.setIsNeedLocationDescribe(true);
		// 可选，是否需要位置描述信息，默认为不需要，即参数为false

		option.setIsNeedLocationPoiList(true);
		// 可选，是否需要周边POI信息，默认为不需要，即参数为false
		option.setIsNeedAddress(true);// 获取详细信息
		//设置扫描间隔
//        option.setScanSpan(10000);
		mLocationClient.setLocOption(option);
		// 注册监听函数
		mLocationClient.registerLocationListener(myListener);
		mLocationClient.start();
	}