RxJava封装百度地图一行代码搞定获取PoiList

最近一直忙新项目，做社交音乐类的项目，很多黑科技，等过段时间分享，好长时间没有写文章了，今天就拿项目中发动态，用到百度地图获取附近POI列表，以前没有做过这些，用了一天才拿到POI的列表（分页那种），其实百度地图的定位功能就已经可以获取到POI列表，但是只有5个，明显不满足需求，后面看了一下文档说是用范地理编码才可以拿到一分也形式获取POI列表。

思路：

1、先通过定位获取经纬度；
2、通过经纬度信息，经过反地理编码ReverseGeoCodeResult，获取到POIList，
3、ReverseGeoCodeOption 范地理编码参数：

 option.radius(5000).pageSize(20).pageNum(0).location(LatLng(latitude, longitude))

radius：搜索半径；
pageSize：返回信息的页面有多少条目；
pageNum：当前第几页；
location：就是通过定位获取到的当前位置的经纬度，或通过这个经纬度为中心点去搜索POI信息；

看我使用RxJava封装：

//初始化定位工具类

class QiHeLocationClient constructor(context: Context) {
private val realClient: com.baidu.location.LocationClient by lazy { com.baidu.location.LocationClient(context) }

init {
    initOptions()
}

private fun initOptions() {
    val option = LocationClientOption()
    option.locationMode = LocationClientOption.LocationMode.Hight_Accuracy//可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
    option.setCoorType("bd09ll")//可选，默认gcj02，设置返回的定位结果坐标系，如果配合百度地图使用，建议设置为bd09ll;
    option.setScanSpan(0)//可选，默认0，即仅定位一次，设置发起连续定位请求的间隔需要大于等于1000ms才是有效的
    option.setIsNeedAddress(true)//可选，设置是否需要地址信息，默认不需要
    option.setIsNeedLocationDescribe(true)//可选，设置是否需要地址描述
    option.setNeedDeviceDirect(false)//可选，设置是否需要设备方向结果
    option.isLocationNotify = false//可选，默认false，设置是否当gps有效时按照1S1次频率输出GPS结果
    option.setIgnoreKillProcess(true)//可选，默认true，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认不杀死
    option.setIsNeedLocationDescribe(true)//可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
    option.setIsNeedLocationPoiList(true)//可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
    option.SetIgnoreCacheException(false)//可选，默认false，设置是否收集CRASH信息，默认收集
    option.isOpenGps = true//可选，默认false，设置是否开启Gps定位
    option.setIsNeedAltitude(true)//可选，默认false，设置定位时是否需要海拔信息，默认不需要，除基础定位版本都可用
    option.disableLocCache = false
    realClient.locOption = option
}


fun locate(bdLocationListener: BDLocationListener) {
//注册定位监听
    realClient.registerLocationListener(
            object : BDLocationListener {
                override fun onReceiveLocation(bdLocation: BDLocation) {
                    bdLocationListener.onReceiveLocation(bdLocation)
                    //防止内存溢出
                    realClient.unRegisterLocationListener(this)
                    realClient.stop()
                }
            }
    )
    if (!realClient.isStarted) {
        realClient.start()
    }
}
}

class LocationOnSubscribe(val context: Context) : ObservableOnSubscribe<BDLocation> {
override fun subscribe(emitter: ObservableEmitter<BDLocation>) {
    QiHeLocationClient(context).locate(
            BDLocationListener {
                if (LocationUtil.isLocationResultEffective(it)) {
                    emitter.onNext(it)
                    emitter.onComplete()
                } else {
                    emitter.onError(RuntimeException("点位失败"))
                }
            }
    )
}
}


class ReverseGeoCodeOnSubscribe(private val pageNum: Int, private val latitude: Double, private val longitude: Double) : ObservableOnSubscribe<ReverseGeoCodeResult> {
override fun subscribe(emitter: ObservableEmitter<ReverseGeoCodeResult>) {
    ReverseGeoCodeUtil(latitude, longitude)
            .poi(pageNum, object : OnGetGeoCoderResultListener {
                override fun onGetGeoCodeResult(result: GeoCodeResult?) = Unit
                override fun onGetReverseGeoCodeResult(reseult: ReverseGeoCodeResult?) {
                    if (LocationUtil.isReverGeoCodeResultEffective(reseult)) {
                        emitter.onNext(reseult!!)
                        emitter.onComplete()
                    } else {
                        emitter.onError(RuntimeException("点位失败"))
                    }
                }
            })
}
}



class ReverseGeoCodeUtil(val latitude: Double, val longitude: Double) {
private val realGeoCoder = GeoCoder.newInstance()
private lateinit var option: ReverseGeoCodeOption

init {
    initOptions()
}

private fun initOptions() {
    option = ReverseGeoCodeOption()
    option.radius(5000).pageSize(20).pageNum(0).location(LatLng(latitude, longitude))
}

fun poi(pageNum: Int, listener: OnGetGeoCoderResultListener) {
    realGeoCoder.setOnGetGeoCodeResultListener(
            object : OnGetGeoCoderResultListener {
                override fun onGetGeoCodeResult(result: GeoCodeResult?) = Unit
                override fun onGetReverseGeoCodeResult(reseult: ReverseGeoCodeResult?) {
                    listener.onGetReverseGeoCodeResult(reseult)
                    //防止内存溢出
                    realGeoCoder.destroy()
                }
            })
    option.pageNum(pageNum)
    realGeoCoder.reverseGeoCode(option)
}

}

object RxBaiduLocate {
fun locate(context: Context): Observable<BDLocation> {
    return Observable.create(LocationOnSubscribe(context))
}

fun locateAndReverseGeoCode(context: Context, pageNum: Int): Observable<ReverseGeoCodeResult?> {
    return Observable.create(LocationOnSubscribe(context))
            .flatMap { reverseGeoCode(pageNum, it.latitude, it.longitude) }
}

fun reverseGeoCode(pageNum: Int, latitude: Double, longitude: Double): Observable<ReverseGeoCodeResult?> {
    return Observable.create(ReverseGeoCodeOnSubscribe(pageNum, latitude, longitude))
}
}

使用：

RxBaiduLocate.locateAndReverseGeoCode(context!!, 1)
                           .subscribe( {
                                it?.poiList
                    },
                    {
                        it.printStackTrace()
                    }
            )

总结：这里只是提供一个封装的思路，大家有什么好的思路或者问题，请指教。