emmmm，效果图先行(搜索定位以及自由滑动地图展示周边位置信息,根据点击的位置获取经纬度)

aa.gif

主要代码

package com.dydd.wsp.dreamtree.ui.map

import android.content.Context
import android.os.Bundle
import android.support.v7.widget.LinearLayoutManager
import android.util.Log
import android.view.KeyEvent
import com.amap.api.location.AMapLocation
import com.amap.api.maps.AMap
import com.amap.api.maps.CameraUpdateFactory
import com.amap.api.maps.LocationSource
import com.amap.api.maps.model.*
import com.dydd.wsp.dreamtree.R
import com.dydd.wsp.dreamtree.ui.base.BaseActivity
import com.dydd.wsp.dreamtree.utils.LocationInfo
import com.amap.api.services.core.LatLonPoint
import com.amap.api.services.core.PoiItem
import com.amap.api.services.geocoder.GeocodeResult
import com.amap.api.services.poisearch.PoiResult
import com.amap.api.services.poisearch.PoiSearch
import com.dydd.wsp.dreamtree.ui.adapter.common.CommonAdapter
import com.dydd.wsp.dreamtree.ui.adapter.common.ViewHolder
import com.dydd.wsp.dreamtree.utils.InitAmap.initAmap
import com.dydd.wsp.dreamtree.utils.TOT
import com.dydd.wsp.dreamtree.utils.getLatLngByAddress
import kotlinx.android.synthetic.main.activity_map_search.*
import android.view.WindowManager
import android.view.inputmethod.InputMethodManager


/**
 * Created by ${吴心良} on 2018/7/5.
 * E-mail:wusongpingsmile@gmail.com
 * Describe:搜索地址展示附近地址
 */
class MapSearchActivity : BaseActivity() {

    private lateinit var aMap: AMap
    private var locationMaker: Marker? = null
    private var mListener: LocationSource.OnLocationChangedListener? = null
    override fun bindLayout() = R.layout.activity_map_search
    override fun beforeSetContentView() {
        super.beforeSetContentView()
        window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN)
    }

    override fun init(savedInstanceState: Bundle?) {
        //初始化地图
        map_ams.onCreate(savedInstanceState)
        aMap = map_ams.map
        initAmap(aMap, { locationSourceListener(it) }, { markerListener(it) })
        //设置地图拖动监听
        aMap.setOnCameraChangeListener(object : AMap.OnCameraChangeListener {
            override fun onCameraChangeFinish(cameraPosition: CameraPosition) {
                val latLng = cameraPosition.target
                searchNearby(latLng)
            }

            override fun onCameraChange(p0: CameraPosition?) {
            }

        })
        //定位初始化
        LocationInfo.getLocationInfo(this, {
            locationSuccess(it)
        })
        //搜索框监听
        et_search_ams.setOnKeyListener { v, keyCode, event ->
            if (keyCode == KeyEvent.KEYCODE_ENTER) {
                val string = et_search_ams.text.toString()
                getLatLngByAddress(this, string, string, { getLatlngSuccess(it) })
                val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
                // 强制隐藏软键盘
                imm.hideSoftInputFromWindow(et_search_ams.windowToken, 0)
            }
            false
        }
    }

    private fun locationSourceListener(locationSource: LocationSource.OnLocationChangedListener?) {
        mListener = locationSource
    }

    //marker的点击事件监听
    private fun markerListener(marker: Marker): Boolean {

        return true
    }

    private fun locationSuccess(location: AMapLocation) {
        //显示系统小蓝点
        mListener?.let { mListener!!.onLocationChanged(location) }
        // 设置缩放级别
        aMap.animateCamera(CameraUpdateFactory.newLatLngZoom(LatLng(location.latitude, location.longitude), 17f))
        // 将地图移动到定位点
        aMap.moveCamera(CameraUpdateFactory.changeLatLng(
                LatLng(location.latitude, location.longitude)))
        val markerOption = MarkerOptions()
        markerOption
                .icon(BitmapDescriptorFactory.fromResource(R.drawable.icon_location))
                .position(LatLng(location.latitude, location.longitude))
                .draggable(true)
                .title("")
                .snippet("哼哼哈哈哈")
        locationMaker = aMap.addMarker(markerOption)
        locationMaker?.setPositionByPixels(map_ams.width / 2,
                map_ams.height / 2)
        searchNearby(LatLng(location.latitude, location.longitude))
    }

    /**
     * 开始搜索附近
     */
    private fun searchNearby(latLng: LatLng) {
        //这三个参数，第一个是搜索关键字，第二个是搜索的类型，具体类型参照高德api 
        val query = PoiSearch.Query("", "", "")
        //查询条数
        query.pageSize = 6
        val search = PoiSearch(this, query)
        search.bound = PoiSearch.SearchBound(LatLonPoint(latLng.latitude, latLng.longitude), 10000)
        search.setOnPoiSearchListener(object : PoiSearch.OnPoiSearchListener {
            override fun onPoiItemSearched(p0: PoiItem?, p1: Int) {
            }

            override fun onPoiSearched(result: PoiResult?, code: Int) {
                if (code == 1000) {
                    val query = result?.query
                    val pois = result?.pois
                    rlv_search_ams.layoutManager = LinearLayoutManager(this@MapSearchActivity)
                    rlv_search_ams.adapter = object : CommonAdapter<PoiItem>(this@MapSearchActivity
                            , R.layout.item_rlv_search_ams, pois) {
                        override fun convert(holder: ViewHolder, t: Any?, position: Int) {
                            val data = t as PoiItem
                            holder.setText(R.id.tv_title_irsa, data.title)
                            holder.setText(R.id.tv_address_irsa, data.snippet)
                            holder.convertView.setOnClickListener {
                                val address = data.provinceName + data.cityName + data.adName + data.snippet
                                Log.e("aa", "点击的地址：$address")
                                getLatLngByAddress(this@MapSearchActivity, data.cityCode, address, { getLatlngSuccess(it) })
                            }
                        }
                    }
                } else {
                    TOT("搜索错误")
                }
            }
        })
        search.searchPOIAsyn()
    }

    private fun getLatlngSuccess(geocodeResult: GeocodeResult) {
        val address = geocodeResult.geocodeAddressList[0]
        Log.e("aa", ("经纬度值:" + address.latLonPoint + "\n位置描述:"
                + address.formatAddress))
        val latLng = LatLng(address.latLonPoint.latitude, address.latLonPoint.longitude)
        searchNearby(latLng)
        aMap.moveCamera(CameraUpdateFactory.changeLatLng(latLng))
        //设置返回值

    }

    override fun onResume() {
        super.onResume()
        // 重新绘制加载地图
        map_ams.onResume()
    }

    override fun onPause() {
        super.onPause()
        // 暂停地图的绘制
        map_ams.onPause()
    }

    override fun onDestroy() {
        super.onDestroy()
        // 销毁地图
        map_ams.onDestroy()
    }
}

html代码

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <com.amap.api.maps.MapView
        android:id="@+id/map_ams"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

    </com.amap.api.maps.MapView>
    <android.support.v7.widget.RecyclerView
        android:id="@+id/rlv_search_ams"
        android:background="@color/colorWhite"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom"
        android:paddingBottom="12dp">

    </android.support.v7.widget.RecyclerView>
    <EditText
        android:id="@+id/et_search_ams"
        android:layout_width="match_parent"
        android:imeOptions="actionSearch"
        android:inputType="text"
        android:maxLines="1"
        android:layout_height="wrap_content"
        android:layout_margin="12dp"
        android:padding="8dp"
        android:hint="输入详细地址查询"
        android:background="@drawable/shape_fill_white_with_gray_rec_bg"/>
</FrameLayout>

用到的工具类方法：
1、initAmap

object InitAmap {
    fun initAmap(aMap: AMap, locationSource: (LocationSource.OnLocationChangedListener?) -> Unit,
                 marker: (Marker) -> Boolean) {
        aMap.uiSettings.isZoomControlsEnabled = false
        // 设置地图默认的指南针是否显示
        aMap.uiSettings.isCompassEnabled = false
        // 设置定位监听
        aMap.setLocationSource(object : LocationSource {
            override fun deactivate() {
            }

            override fun activate(p0: LocationSource.OnLocationChangedListener?) {
                locationSource(p0)
            }
        })
        // 设置默认定位按钮是否显示
        aMap.uiSettings.isMyLocationButtonEnabled = false
        // 设置为true表示显示定位层并可触发定位，false表示隐藏定位层并不可触发定位，默认是false
        aMap.isMyLocationEnabled = true
//        aMap.setMyLocationType(AMap.LOCATION_TYPE_LOCATE)
        aMap.setOnMarkerClickListener {
            marker(it)
        }
    }
}

2、定位信息

object LocationInfo {
    fun getLocationInfo(context: Context, success: (AMapLocation) -> Unit) {
        val mLocationClient = AMapLocationClient(context)
        val mLocationOption = AMapLocationClientOption()
        // 初始化定位
        // 设置高德地图定位回调监听
        mLocationClient.setLocationListener { aMapLocation ->
            if (aMapLocation != null) {
                if (aMapLocation.errorCode == 0) {
                    val locationType = aMapLocation.locationType // 获取当前定位结果来源，如网络定位结果，详见定位类型表
                    val latitude = aMapLocation.latitude // 获取纬度
                    val longitude = aMapLocation.longitude // 获取经度
                    val accuracy = aMapLocation.accuracy // 获取精度信息
                    val address = aMapLocation.address // 地址，如果option中设置isNeedAddress为false，则没有此结果，
                    // 网络定位结果中会有地址信息，GPS定位不返回地址信息。
                    val country = aMapLocation.country // 国家信息
                    val province = aMapLocation.province // 省信息
                    val city = aMapLocation.city // 城市信息
                    val district = aMapLocation.district // 城区信息
                    val street = aMapLocation.street // 街道信息
                    val streetNum = aMapLocation.streetNum // 街道门牌号信息
                    val cityCode = aMapLocation.cityCode // 城市编码
                    val adCode = aMapLocation.adCode // 地区编码
                    val aoiName = aMapLocation.aoiName // 获取当前定位点的AOI信息
                    val buildingId = aMapLocation.buildingId // 获取当前室内定位的建筑物Id
                    val floor = aMapLocation.floor // 获取当前室内定位的楼层
                    val gpsAccuracyStatus = aMapLocation.gpsAccuracyStatus //获取GPS的当前状态
                    // 获取定位时间
                    val df = SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
                    val date = Date(aMapLocation.time)
                    df.format(date)
                    success(aMapLocation)
                } else {
                    // 定位失败时，可通过ErrCode（错误码）信息来确定失败的原因，errInfo是错误信息，详见错误码表。
                    TOT("获取定位失败")
                }

            }
        }
        // 初始化AMapLocationClientOption对象
        // 高精度定位模式：会同时使用网络定位和GPS定位，优先返回最高精度的定位结果，以及对应的地址描述信息
        // 设置定位模式为AMapLocationMode.Hight_Accuracy，高精度模式
        mLocationOption.locationMode = AMapLocationClientOption.AMapLocationMode.Hight_Accuracy
        // 低功耗定位模式：不会使用GPS和其他传感器，只会使用网络定位（Wi-Fi和基站定位）；
        //设置定位模式为AMapLocationMode.Battery_Saving，低功耗模式。
        //mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Battery_Saving);
        // 仅用设备定位模式：不需要连接网络，只使用GPS进行定位，这种模式下不支持室内环境的定位，自 v2.9.0 版本支持返回地址描述信息。
        // 设置定位模式为AMapLocationMode.Device_Sensors，仅设备模式。
        //mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Device_Sensors);
        // SDK默认采用连续定位模式，时间间隔2000ms
        // 设置定位间隔，单位毫秒，默认为2000ms，最低1000ms。
        mLocationOption.interval = 60000
        // 设置定位同时是否需要返回地址描述
        //设置是否返回地址信息（默认返回地址信息）
        mLocationOption.isNeedAddress = true
        // 设置是否强制刷新WIFI，默认为强制刷新。每次定位主动刷新WIFI模块会提升WIFI定位精度，但相应的会多付出一些电量消耗。
        // 设置是否强制刷新WIFI，默认为true，强制刷新。
//        mLocationOption.isWifiActiveScan = true
        // 设置是否允许模拟软件Mock位置结果，多为模拟GPS定位结果，默认为false，不允许模拟位置。
        // 设置是否允许模拟位置,默认为false，不允许模拟位置
        mLocationOption.isMockEnable = false
        // 设置定位请求超时时间，默认为30秒
        // 单位是毫秒，默认30000毫秒，建议超时时间不要低于8000毫秒。
        mLocationOption.httpTimeOut = 50000
        // 设置是否开启定位缓存机制
        // 缓存机制默认开启，可以通过以下接口进行关闭。
        // 当开启定位缓存功能，在高精度模式和低功耗模式下进行的网络定位结果均会生成本地缓存，不区分单次定位还是连续定位。GPS定位结果不会被缓存。
        // 关闭缓存机制
        mLocationOption.isLocationCacheEnable = false
        // 设置是否只定位一次，默认为false
        mLocationOption.isOnceLocation = true
        // 给定位客户端对象设置定位参数
        mLocationClient.setLocationOption(mLocationOption)
        // 启动高德地图定位
        mLocationClient.startLocation()
    }

}

3、根据地址获取经纬度

fun getLatLngByAddress(context: Context,city:String,address:String,success:(GeocodeResult)->Unit){
//发起正地理编码搜索
        //构造 GeocodeSearch 对象，并设置监听。
        val geocodeSearch = GeocodeSearch(context)
        geocodeSearch.setOnGeocodeSearchListener(object :GeocodeSearch.OnGeocodeSearchListener{
            override fun onRegeocodeSearched(p0: RegeocodeResult?, position: Int) {
            }
            override fun onGeocodeSearched(geocodeResult: GeocodeResult?, position: Int) {
                if (position == AMapException.CODE_AMAP_SUCCESS) {
                    if (geocodeResult?.geocodeAddressList != null
                            && geocodeResult.geocodeAddressList.size > 0) {
                        success(geocodeResult)
                    }
                }
            }

        })
//通过GeocodeQuery设置查询参数,调用getFromLocationNameAsyn(GeocodeQuery geocodeQuery) 方法发起请求。
//address表示地址，第二个参数表示查询城市，中文或者中文全拼，citycode、adcode都ok
        val query =GeocodeQuery(address, city)
        geocodeSearch.getFromLocationNameAsyn(query)
}

应该够详细了，下次能直接拿着就用了，美滋滋，希望能有人用得到