对照代码写文档

gradle.properties

@@ -21,4 +21,7 @@ kotlin.code.style=official
 # resources declared in the library itself and none from the library's dependencies,
 # thereby reducing the size of the R class for that library
 android.nonTransitiveRClass=true
-#android.defaults.buildfeatures.databinding=true
+#android.defaults.buildfeatures.databinding=true
\ No newline at end of file
+#????gradle??????????DGP v2:
+org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled
+#org.jetbrains.dokka.experimental.gradle.pluginMode.noWarn=true
\ No newline at end of file

maplibrary/build.gradle.kts

@@ -2,8 +2,8 @@ plugins {
     alias(libs.plugins.android.library)
     alias(libs.plugins.kotlin.android)
     id("kotlin-kapt")
-//    kotlin("jvm") version "2.0.21" // 替换x.y.z为你的Kotlin版本
-    id("org.jetbrains.dokka") // version("2.0.0") // 确保使用正确的Dokka版本
+//    kotlin("jvm") version "2.1.10"
+    id("org.jetbrains.dokka") version "2.0.0"
 }
 
 
@@ -74,7 +74,8 @@ dependencies {
     testImplementation(libs.junit)
     androidTestImplementation(libs.androidx.junit)
     androidTestImplementation(libs.androidx.espresso.core)
-
+//文档插件库
+//    implementation(libs.android.documentation.plugin)
     //高德
 //    implementation("com.amap.api:navi-3dmap:latest.integration")
 //    implementation("com.amap.api:search:latest.integration")

maplibrary/src/main/AndroidManifest.xml

@@ -35,13 +35,13 @@
                     android:name="org.apache.http.legacy"
                     android:required="false" />
 
-                <meta-data
-                    android:name="com.minedata.minenavi.apikey"
-                    android:value="57ac7a0d56494912a0c28e651fa4a40a" />
+<!--                <meta-data-->
+<!--                    android:name="com.minedata.minenavi.apikey"-->
+<!--                    android:value="57ac7a0d56494912a0c28e651fa4a40a" />-->
 
-                <meta-data
-                    android:name="com.amap.api.v2.apikey"
-                    android:value="3b7d009011b97dcc3815a93e8ddfcd77" />
+<!--                <meta-data-->
+<!--                    android:name="com.amap.api.v2.apikey"-->
+<!--                    android:value="3b7d009011b97dcc3815a93e8ddfcd77" />-->
 
                 <!-- 定位需要的服务 使用2.0的定位需要加上这个 -->
                 <service android:name="com.amap.api.location.APSService" />

maplibrary/src/main/java/com/sd/maplibrary/MSDKInitializer.kt

@@ -12,16 +12,17 @@ import com.minedata.minenavi.poiquery.SearchUrlType
 import com.permissionx.guolindev.PermissionX
 
 
-/**AMAP = 高德
- * MINE =四维
- * ***/
+/**
+ * AMAP 高德在线地图
+ * MINE 四维在线地图
+ */
 enum class MAP_TYPE {
     MINE,
     AMAP
 }
 
-/**用户传入上下文***/
-private class UserCtx {
+/**用户传入上下文*/
+class UserCtx {
     var mContext: Context? = null
     var map_type: MAP_TYPE = MAP_TYPE.MINE
 
@@ -32,36 +33,57 @@ private class UserCtx {
 
 
 interface OnSdkInitCb {
-    /***初始化成功**/
+    /**初始化成功*/
     fun onInitSuccess()
 
-    /***初始化成失败**/
+    /**初始化成失败*/
     fun onInitFailed(msg: String)
 }
 
-
+/**SDK初始化类*/
 object MSDKInitializer {
 
+    /**SDK初始化成功（失败）回调*/
     private var onSdkInitCb: OnSdkInitCb? = null
 
+    /**
+     * 初始化地图SDK
+     *
+     * @param context 应用上下文，用于SDK初始化
+     * @param map_type 地图类型，指定要初始化的地图类型
+     * @param onSdkInitCb SDK初始化回调接口，用于通知初始化结果
+     */
     fun initializeMap(context: Context, map_type: MAP_TYPE, onSdkInitCb: OnSdkInitCb) {
+        // 保存初始化回调接口
         this.onSdkInitCb = onSdkInitCb
+        // 设置用户上下文信息
         UserCtx.instance.mContext = context
         UserCtx.instance.map_type = map_type
+        // 请求必要的权限
         requestPers()
     }
 
+    /**
+     * 获取当前用户的地图类型设置
+     *
+     * @return 返回当前用户设置的地图类型枚举值
+     */
     fun getMapType(): MAP_TYPE {
         return UserCtx.instance.map_type
     }
 
-    /**使用API初始化地图**/
+
+    /**
+     * 初始化地图类型相关配置
+     */
     private fun mapTypeInit() {
         val ctx = UserCtx.instance.mContext
         when (UserCtx.instance.map_type) {
             MAP_TYPE.AMAP -> {
+                // 高德地图隐私合规设置
                 MapsInitializer.updatePrivacyShow(ctx, true, true)
                 MapsInitializer.updatePrivacyAgree(ctx, true)
+                // 高德地图不支持API初始化，直接回调失败
                 onSdkInitCb?.onInitFailed("高德不支持api初始化")
             }
 
@@ -71,6 +93,7 @@ object MSDKInitializer {
                 //设置地图坐标系
                 SDKInitializer.setCoordType(CoordType.GCJ02)
                 SDKInitializer.setSearchUrlType(SearchUrlType.v1)
+                // 执行SDK初始化
                 SDKInitializer.initialize(ctx, object : InitListener {
                     override fun onInitSuccess() {
                         onSdkInitCb?.onInitSuccess()
@@ -89,6 +112,7 @@ object MSDKInitializer {
         }
     }
 
+    // 请求权限
     private fun requestPers() {
         if (UserCtx.instance.mContext is FragmentActivity) {
             var pers = mutableListOf(
@@ -130,5 +154,4 @@ object MSDKInitializer {
     }
 
 
-
 }
\ No newline at end of file

maplibrary/src/main/java/com/sd/maplibrary/bean/DriverRouteBean.kt

@@ -5,7 +5,7 @@ import com.minedata.minenavi.map.Route
 import com.minedata.minenavi.navi.RouteBase
 import com.minedata.minenavi.navi.RouteCollection
 
-/****驾车路径规划返回***/
+/**驾车路径规划返回*/
 class DriverRouteBean {
 
     companion object {
@@ -16,13 +16,14 @@ class DriverRouteBean {
     var routeCollection: RouteCollection? = null
 
     //高德
-   var aMapCalcRouteResult: AMapCalcRouteResult?=null
+    var aMapCalcRouteResult: AMapCalcRouteResult?=null
 //    var driveRouteResult: DriveRouteResult? = null
 }
 
-/***路径规划图层对象
+/**
+ * 路径规划图层对象
  * 只哟四维有
- * **/
+ */
 class RouteOver {
     companion object {
         val instance: RouteOver by lazy { RouteOver() }

maplibrary/src/main/java/com/sd/maplibrary/bean/MSLatLng.kt

 package com.sd.maplibrary.bean
 
-/**整合四维和高德的经纬度**/
+/**经纬度*/
 class MSLatLng {
 
     constructor(lat: Double, lng: Double) {
@@ -8,6 +8,9 @@ class MSLatLng {
         this.lng = lng
     }
 
-    var lat=0.0
-    var lng=0.0
+    // 纬度
+    var lat = 0.0
+
+    // 经度
+    var lng = 0.0
 }
\ No newline at end of file

maplibrary/src/main/java/com/sd/maplibrary/bean/MSLocBean.kt

 package com.sd.maplibrary.bean
 
-/***定位数据回调**/
+/**定位数据回调*/
 class MSLocBean {
 
     companion object {
@@ -10,15 +10,13 @@ class MSLocBean {
     //当前经纬度
     var lat = 0.0
     var lng = 0.0
-    //速度
+    /**速度 m/s*/
     var speed = 0f
-    //航向角
+    /**航向角*/
     var bearing = 0f
-    //精度
+    /**精度*/
     var accuracy = 0f
-    //高程
+    /**高程*/
     var altitude = 0.0
 
-
-
 }
\ No newline at end of file

maplibrary/src/main/java/com/sd/maplibrary/bean/PoiSearchRes.kt

 package com.sd.maplibrary.bean
 
-/****POI 搜索返回**/
+/**POI搜索返回*/
 class PoiSearchRes {
     var lat = 0.0
     var lng = 0.0
     var cityName = ""
-    //行政去编码
+    /**行政区编码*/
     var adCode = ""
-    //POI的名称
+    /**POI的名称*/
     var title = ""
-    //POI的地址
+    /**POI的地址*/
     var snippet = ""
-    //POI距离中心点的距离。范围搜索才有
+    /**POI距离中心点的距离。范围搜索才有*/
     var distance = 0
 }
\ No newline at end of file

maplibrary/src/main/java/com/sd/maplibrary/bean/RegeocodeRes.kt

@@ -2,18 +2,18 @@ package com.sd.maplibrary.bean
 
 /***逆地理编码返回**/
 class RegeocodeRes {
-    //    逆地理编码返回的所在省名称
+    /**逆地理编码返回的所在省名称*/
     var province = ""
 //    var provinceCode = ""
 
-    //逆地理编码返回的所在城市名称
+    /**逆地理编码返回的所在城市名称*/
     var city = ""
     var cityCode = ""
 
-    //逆地理编码返回的所在区（县）名称。
+    /**逆地理编码返回的所在区（县）名称。*/
     var district = ""
 
-    //逆地理编码返回的所在乡镇/街道。
+    /**逆地理编码返回的所在乡镇/街道。*/
     var town = ""
 
     //逆地理编码返回的所在村镇。

maplibrary/src/main/java/com/sd/maplibrary/bean/WayPoi.kt

 package com.sd.maplibrary.bean
 
-/***途经点Poi***/
+/**途经点Poi***/
 class WayPoi {
-    //途经点名坐标
+    /**途经点名坐标*/
     var passPoint: MSLatLng? = null
-    //途经点名字
+    /**经点名字*/
     var passName = ""
 }
\ No newline at end of file

maplibrary/src/main/java/com/sd/maplibrary/core/MSMapUtil.kt → maplibrary/src/main/java/com/sd/maplibrary/core/MSCalcuMapUtil.kt

@@ -8,21 +8,25 @@ import com.sd.maplibrary.bean.MSLatLng
 import com.amap.api.maps.model.LatLng as ALatLng
 
 
-/****
- * 地图工具
- * ***/
-object MSMapUtil {
+/**
+ * 地图计算工具
+ */
+object MSCalcuMapUtil {
 
-    /***计算俩点距离
-     * @return 返回单位（米）
-     * ***/
+    /**
+     * 计算两点之间的直线距离
+     * @param latLng1 第一个坐标点
+     * @param latLng2 第二个坐标点
+     * @return 返回两点间距离，单位为米
+     */
     fun calculateLineDistance(
-        mapReadView: MapReadyView?,
         latLng1: MSLatLng,
         latLng2: MSLatLng
     ): Float {
+        // 根据不同的地图类型选择相应的距离计算方法
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
+                // 使用Android原生Location类计算两点间距离
                 var results = FloatArray(1)
                 Location.distanceBetween(
                     latLng1.lat,
@@ -35,6 +39,7 @@ object MSMapUtil {
             }
 
             MAP_TYPE.AMAP -> {
+                // 使用高德地图工具类计算两点间距离
                 val latlngA = ALatLng(latLng1.lat, latLng1.lng)
                 val latlngB = ALatLng(latLng2.lat, latLng2.lng)
                 val distance = AMapUtils.calculateLineDistance(latlngA, latlngB)
@@ -44,15 +49,17 @@ object MSMapUtil {
     }
 
 
-    /*****计算矩形面具
-     * @param latLng1 = 左上角
-     * @param latLng2 = 右下角
-     * **/
+    /**
+     * 计算矩形面积
+     * @param latLng1 矩形左上角坐标
+     * @param latLng2 矩形右下角坐标
+     * @return 矩形面积，单位为平方米
+     */
     fun calculateArea(
-        mapReadView: MapReadyView?,
         latLng1: MSLatLng,
         latLng2: MSLatLng
     ): Float {
+        // 根据不同地图类型进行面积计算
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
                 return 0f
@@ -66,4 +73,5 @@ object MSMapUtil {
             }
         }
     }
+
 }
\ No newline at end of file

maplibrary/src/main/java/com/sd/maplibrary/core/MSCanvesInMap.kt

 package com.sd.maplibrary.core
 
-import android.content.Context
 import android.graphics.BitmapFactory
 import androidx.core.graphics.toColorInt
 import com.amap.api.maps.model.BitmapDescriptorFactory
@@ -17,6 +16,7 @@ import com.minedata.minenavi.mapdal.LatLng
 import com.sd.maplibrary.MAP_TYPE
 import com.sd.maplibrary.MSDKInitializer
 import com.sd.maplibrary.R
+import com.sd.maplibrary.UserCtx
 import com.sd.maplibrary.bean.MSLatLng
 import com.amap.api.maps.model.CircleOptions as ACircleOptions
 import com.amap.api.maps.model.LatLng as ALatLng
@@ -25,7 +25,7 @@ import com.amap.api.maps.model.MarkerOptions as AMarkerOptions
 import com.amap.api.maps.model.PolygonOptions as APolygonOptions
 import com.amap.api.maps.model.PolylineOptions as APolylineOptions
 
-/****返回的mark**/
+/**返回的mark*/
 object MSMarker {
     //四维mark
     var maker: Marker? = null
@@ -34,10 +34,16 @@ object MSMarker {
     var amaker: AMarker? = null
 }
 
-/****返回的图层**/
+/**返回的图层*/
 object MSOverlay {
-    //四维mark
-    var overlay: Overlay? = null
+    //四维线图层
+    var polyline: Overlay? = null
+
+    //四维面图层
+    var polygon: Overlay? = null
+
+    //四维圆形图层
+    var circle: Overlay? = null
 
     //高德圆形
     var aCircle: Circle? = null
@@ -51,23 +57,31 @@ object MSOverlay {
 }
 
 
-/*****在地图上绘制**/
+/**
+ * 在地图上绘制
+ */
 object MSCanvesInMap {
 
-    /***绘制Market 点标记
-     * @param lat 纬度
-     * @param lng 经度
-     * @return Marker对象 用于删掉
-     * ***/
+
+    /**
+     * 绘制 marker 点
+     * @param mapReadView 地图准备就绪的视图对象
+     * @param lat 纬度坐标
+     * @param lng 经度坐标
+     * @return MSMarker 标记点对象
+     */
     fun drawMarket(
-        context: Context,
         mapReadView: MapReadyView?,
         lat: Double,
         lng: Double
     ): MSMarker {
+        var context = UserCtx.instance.mContext
+
+        // 根据不同的地图类型绘制标记点
         when (MSDKInitializer.getMapType()) {
+            // 处理自定义地图类型的标记点绘制
             MAP_TYPE.MINE -> {
-                val icon = BitmapFactory.decodeResource(context.resources, R.drawable.market_loc)
+                val icon = BitmapFactory.decodeResource(context?.resources, R.drawable.market_loc)
                 val latLng = LatLng(lat, lng)
                 var options = MarkerOptions()
                     .zLevel(7)
@@ -79,6 +93,7 @@ object MSCanvesInMap {
                 return MSMarker
             }
 
+            // 处理高德地图类型的标记点绘制
             MAP_TYPE.AMAP -> {
                 val aLatLng = ALatLng(lat, lng)
                 val aMarkerOption = AMarkerOptions().apply {
@@ -86,7 +101,7 @@ object MSCanvesInMap {
                     icon(
                         BitmapDescriptorFactory.fromBitmap(
                             BitmapFactory
-                                .decodeResource(context.resources, R.drawable.market_loc)
+                                .decodeResource(context?.resources, R.drawable.market_loc)
                         )
                     )
                 }
@@ -98,12 +113,15 @@ object MSCanvesInMap {
     }
 
 
-    /***绘制线
-     *@param mapReadView 地图加载返回
-     *@param width = 宽度
-     *@param fcolor = 填充颜色
-     *@param isDotted = 是否虚线
-     * ***/
+    /**
+     * 绘制线
+     * @param mapReadView 地图加载返回
+     * @param msLatLng 坐标点集合
+     * @param width 线宽度，默认为10f
+     * @param fcolor 线颜色，默认为"#FF00FF"对应的int值
+     * @param isDotted 是否为虚线，默认为false
+     * @return MSOverlay 覆盖物对象
+     */
     fun drawPolyline(
         mapReadView: MapReadyView?,
         msLatLng: List<MSLatLng>,
@@ -111,7 +129,9 @@ object MSCanvesInMap {
         fcolor: Int = "#FF00FF".toColorInt(),
         isDotted: Boolean = false
     ): MSOverlay {
+        // 根据地图类型绘制不同平台的线
         when (MSDKInitializer.getMapType()) {
+            // 绘制自定义地图的线
             MAP_TYPE.MINE -> {
                 var latLngs = msLatLng.map {
                     LatLng(it.lat, it.lng)
@@ -123,10 +143,11 @@ object MSCanvesInMap {
                     .color(fcolor)
                     .setDottedLine(isDotted)
                 var polyline = mapReadView?.mMineMap?.addPolyline(options)
-                MSOverlay.overlay = polyline
+                MSOverlay.polyline = polyline
                 return MSOverlay
             }
 
+            // 绘制高德地图的线
             MAP_TYPE.AMAP -> {
                 var latLngs = msLatLng.map {
                     ALatLng(it.lat, it.lng)
@@ -142,13 +163,17 @@ object MSCanvesInMap {
         }
     }
 
-    /***绘制圆形
+
+    /**绘制圆形
+     * @param mapReadView 地图准备就绪视图对象
      * @param lat 维度
      * @param lng 经度
      * @param radius 半径（米）
-     * @param fillColor 填充颜色
-     * @param 边框颜色
-     * ****/
+     * @param fillColor 填充颜色，默认为半透明红色
+     * @param strokeColor 边框颜色，默认为半透明蓝色
+     * @param strokeWidth 边框宽度，默认为15f
+     * @return MSOverlay 返回覆盖物对象
+     */
     fun drawCircle(
         mapReadView: MapReadyView?,
         lat: Double,
@@ -158,6 +183,7 @@ object MSCanvesInMap {
         strokeColor: Int = "#500000FF".toColorInt(),
         strokeWidth: Float = 15f
     ): MSOverlay {
+        // 根据地图类型绘制不同类型的圆形
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
                 var latLng = LatLng(lat, lng)
@@ -168,7 +194,7 @@ object MSCanvesInMap {
                     .strokeColor(strokeColor)
                     .strokeWidth(strokeWidth)
                 var circle = mapReadView?.mMineMap?.addCircle(options)
-                MSOverlay.overlay = circle
+                MSOverlay.circle = circle
                 return MSOverlay
             }
 
@@ -190,9 +216,9 @@ object MSCanvesInMap {
 
     /***
      * 绘制多边形
-     *@param msLatLng   添加多边形顶点坐标集合
+     * @param msLatLng   添加多边形顶点坐标集合
      * @param dLine 是否虚线
-     *@param fillColor 填充颜色
+     * @param fillColor 填充颜色
      * @param strokeWidth 边框宽度
      * @param strokeColor 边框颜色
      * ****/
@@ -218,7 +244,7 @@ object MSCanvesInMap {
                     dottedLine(dLine)
                 }
                 var polygon = mapReadView?.mMineMap?.addPolygon(polygonOptions)
-                MSOverlay.overlay = polygon
+                MSOverlay.polygon = polygon
                 return MSOverlay
             }
 
@@ -240,29 +266,44 @@ object MSCanvesInMap {
     }
 
 
-    /****删除Marker**/
+    /**
+     * 删除地图上的标记点
+     * @param mapReadView 地图准备就绪的视图对象，可能为null
+     * @param mSMarker 要删除的标记点对象，可能为null
+     */
     fun deleteMarker(mapReadView: MapReadyView?, mSMarker: MSMarker?) {
         if (mSMarker == null)
             return
+
+        // 根据不同的地图类型执行相应的删除操作
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
+                // 从自定义地图中移除指定的标记点
                 mapReadView?.mMineMap?.removeMarker(mSMarker.maker)
             }
 
             MAP_TYPE.AMAP -> {
-//                清空地图上所有已经标注的marker
-                mapReadView?.aMap?.clear()
+                //移除指定的标记点
+                MSMarker.amaker?.remove()
+                // 清空高德地图上所有已经标注的marker
+//            mapReadView?.aMap?.clear()
             }
         }
     }
 
-    /****删除线**/
+
+    /**
+     * 删除地图上的线
+     * @param mapReadView 地图准备就绪的视图对象，可能为null
+     * @param mSOverlay 包含折线信息的覆盖物对象，可能为null
+     */
     fun deletePolyline(mapReadView: MapReadyView?, mSOverlay: MSOverlay?) {
         if (mSOverlay == null)
             return
+        // 根据不同的地图类型删除对应的折线
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
-                mapReadView?.mMineMap?.removeOverlay(mSOverlay.overlay)
+                mapReadView?.mMineMap?.removeOverlay(mSOverlay.polyline)
             }
 
             MAP_TYPE.AMAP -> {
@@ -272,14 +313,19 @@ object MSCanvesInMap {
     }
 
 
-    /****删除圆形**/
+    /**
+     * 删除圆形覆盖物
+     * @param mapReadView 地图准备视图对象，可能为null
+     * @param mSOverlay 圆形覆盖物对象，可能为null
+     */
     fun deleteCircle(mapReadView: MapReadyView?, mSOverlay: MSOverlay?) {
         if (mSOverlay == null) {
             return
         }
+        // 根据不同的地图类型执行对应的圆形删除操作
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
-                mapReadView?.mMineMap?.removeOverlay(mSOverlay.overlay)
+                mapReadView?.mMineMap?.removeOverlay(mSOverlay.circle)
             }
 
             MAP_TYPE.AMAP -> {
@@ -288,14 +334,19 @@ object MSCanvesInMap {
         }
     }
 
-    /****删除面**/
+    /**
+     * 删除地图上的面
+     * @param mapReadView 地图准备就绪的视图对象，可能为null
+     * @param mSOverlay 面覆盖物对象，可能为null
+     */
     fun deletePolygon(mapReadView: MapReadyView?, mSOverlay: MSOverlay?) {
         if (mSOverlay == null) {
             return
         }
+        // 根据不同的地图类型执行对应的删除操作
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
-                mapReadView?.mMineMap?.removeOverlay(mSOverlay.overlay)
+                mapReadView?.mMineMap?.removeOverlay(mSOverlay.polygon)
             }
 
             MAP_TYPE.AMAP -> {

maplibrary/src/main/java/com/sd/maplibrary/core/MSGestures.kt

@@ -3,10 +3,10 @@ package com.sd.maplibrary.core
 
 import com.sd.maplibrary.MAP_TYPE
 import com.sd.maplibrary.MSDKInitializer
-import com.sd.maplibrary.ui.MapMultiView
 
-
-/***手势交互**/
+/**
+ * 手势交互
+ */
 object MSGestures {
 
 //
@@ -24,11 +24,13 @@ object MSGestures {
 //    }
 
 
-    /***旋转开关
-     * @param mapReadView 从addMapRenderCallback(object : OnMapReadyLis 里拿
-     *  @param enable 是否可用
-     * **/
-    fun setRotateGesturesEnabled(mapReadView: MapReadyView?,enable: Boolean) {
+    /**
+     * 设置地图旋转手势是否可用
+     * @param mapReadView 地图准备就绪视图对象
+     * @param enable 是否启用旋转手势功能
+     */
+    fun setRotateGesturesEnabled(mapReadView: MapReadyView?, enable: Boolean) {
+        // 根据不同的地图类型设置对应的旋转手势可用状态
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
                 mapReadView?.fMapView?.uiSettings?.isRotateGesturesEnabled = enable
@@ -41,11 +43,13 @@ object MSGestures {
     }
 
 
-    /***倾斜开关
-     * @param mapReadView 从addMapRenderCallback(object : OnMapReadyLis 里拿
-     * @param enable 是否可用
-     * **/
+    /**
+     * 设置地图倾斜手势功能的启用状态
+     * @param mapReadView 地图准备就绪视图对象
+     * @param enable 是否启用倾斜手势功能，true为启用，false为禁用
+     * */
     fun setTiltGesturesEnabled(mapReadView: MapReadyView, enable: Boolean) {
+        // 根据不同的地图类型设置对应的倾斜手势功能
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
                 mapReadView.fMapView?.uiSettings?.isTiltGesturesEnabled = enable
@@ -57,4 +61,5 @@ object MSGestures {
         }
     }
 
+
 }
\ No newline at end of file

maplibrary/src/main/java/com/sd/maplibrary/core/MSGpsLocation.kt

 package com.sd.maplibrary.core
 
 import android.annotation.SuppressLint
-import android.content.Context
 import android.os.Bundle
 import com.amap.api.location.AMapLocation
 import com.amap.api.location.AMapLocationClient
@@ -16,10 +15,10 @@ import com.minedata.minenavi.location.MineLocationOptions
 import com.minedata.minenavi.mapdal.CoordType
 import com.sd.maplibrary.MAP_TYPE
 import com.sd.maplibrary.MSDKInitializer
+import com.sd.maplibrary.UserCtx
 import com.sd.maplibrary.bean.MSLocBean
 
-
-/******/
+/**GPS定位类*/
 object MSGpsLocation {
 
 
@@ -51,14 +50,17 @@ object MSGpsLocation {
         return@lazy mOption
     }
 
+    // 高德定位实例
+    @SuppressLint("StaticFieldLeak")
+    private var alocationClient: AMapLocationClient? = null
 
-    private var locationClient: AMapLocationClient? = null
-
-    /****业务层Gps定位回调**/
+    /**业务层Gps定位回调**/
     private var onMsGpsLoc: OnMsGpsLoc? = null
 
-    /***初始化监听定位**/
-    fun initLoc(context: Context) {
+    /**初始化定位*/
+    fun initLoc() {
+        var context = UserCtx.instance.mContext
+
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
                 MineLocationManager.getInstance()
@@ -69,23 +71,25 @@ object MSGpsLocation {
             }
 
             MAP_TYPE.AMAP -> {
-                locationClient = AMapLocationClient(context)
+                alocationClient = AMapLocationClient(context)
                 //设置定位参数
-                locationClient!!.setLocationOption(locationOption)
+                alocationClient!!.setLocationOption(locationOption)
                 // 设置定位监听
-                locationClient!!.setLocationListener(locationListener)
+                alocationClient!!.setLocationListener(locationListener)
             }
         }
     }
 
+    /**
+     * 设置GPS定位回调监听器
+     * @param onMsGpsLoc GPS定位回调监听器实例
+     */
     fun setOnMsGpsLoc(onMsGpsLoc: OnMsGpsLoc) {
         this.onMsGpsLoc = onMsGpsLoc
     }
 
 
-    /***
-     * 开启定位
-     */
+    /**开启定位*/
     fun starLoc() {
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
@@ -98,12 +102,12 @@ object MSGpsLocation {
 // 在定位结束后，在合适的生命周期调用onDestroy()方法
 // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
 //启动定位
-                locationClient?.startLocation()
+                alocationClient?.startLocation()
             }
         }
     }
 
-    /****停止定位***/
+    /**停止定位*/
     fun stopLoc() {
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
@@ -112,28 +116,29 @@ object MSGpsLocation {
             }
 
             MAP_TYPE.AMAP -> {
-                locationClient?.stopLocation()
+                alocationClient?.stopLocation()
 
             }
         }
     }
 
-    /****清理资源***/
-    fun cleans() {
+    /**清理定位资源**/
+    fun cleansLoc() {
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
                 MineLocationManager.getInstance().cleanup()
             }
 
             MAP_TYPE.AMAP -> {
-                locationClient?.onDestroy()
-                locationClient = null
+                alocationClient?.onDestroy()
+                alocationClient = null
             }
         }
     }
 
 
     //----------------自定义回调---------
+    /**业务层Gps定位回调接口**/
     interface OnMsGpsLoc {
         fun onMsGpsLoc(mSLocBean: MSLocBean)
     }

maplibrary/src/main/java/com/sd/maplibrary/core/MSLayers.kt

@@ -6,12 +6,18 @@ import com.minedata.minenavi.mapdal.CoordType
 import com.sd.maplibrary.MAP_TYPE
 import com.sd.maplibrary.MSDKInitializer
 
-
+/**
+ * 地图图层切换
+ *
+ */
 object MSLayers {
 
-    /****切换地图图层
-     * @param type =1 普通 2=卫星
-     * ***/
+
+    /**
+     * 切换地图图层
+     * @param mapReadView 地图准备就绪视图对象
+     * @param type 1=普通 2=卫星
+     */
     fun changeLayers(mapReadView: MapReadyView?, type: Int) {
         if (MSDKInitializer.getMapType() == MAP_TYPE.MINE) {
             when (type) {

maplibrary/src/main/java/com/sd/maplibrary/core/MSLocationStyle.kt

@@ -5,28 +5,31 @@ import com.sd.maplibrary.MAP_TYPE
 import com.sd.maplibrary.MSDKInitializer
 import com.amap.api.maps.model.MyLocationStyle as aMapMyLocationStyle
 
-/***显示定位小圆点**/
+
+/**
+ * 显示定位小圆点
+ */
 object MSLocationStyle {
 
     //    const val LOCATION_TYPE_EXTERNAL: Int = 0
 //    const val LOCATION_TYPE_SHOW: Int = 1
-    /***定位一次，且将视角移动到地图中心点**/
+    /**定位一次，且将视角移动到地图中心点**/
     const val LOCATION_TYPE_LOCATE: Int = 2
-
     /**连续定位、且将视角移动到地图中心点，定位蓝点跟随设备移动**/
     const val LOCATION_TYPE_FOLLOW: Int = 3
-    /***连续定位、且将视角移动到地图中心点，地图依照设备方向旋转，定位点会跟随设备移动**/
+    /**连续定位、且将视角移动到地图中心点，地图依照设备方向旋转，定位点会跟随设备移动**/
     const val LOCATION_TYPE_MAP_ROTATE: Int = 4
-    /***连续定位、且将视角移动到地图中心点，定位点依照设备方向旋转，并且会跟随设备移动**/
+    /**连续定位、且将视角移动到地图中心点，定位点依照设备方向旋转，并且会跟随设备移动**/
     const val LOCATION_TYPE_LOCATION_ROTATE: Int = 5
-    /***连续定位、蓝点不会移动到地图中心点，定位点依照设备方向旋转，并且蓝点会跟随设备移动**/
+    /**连续定位、蓝点不会移动到地图中心点，定位点依照设备方向旋转，并且蓝点会跟随设备移动**/
     const val LOCATION_TYPE_LOCATION_ROTATE_NO_CENTER: Int = 6
-    /***连续定位、蓝点不会移动到地图中心点，并且蓝点会跟随设备移动**/
+    /**连续定位、蓝点不会移动到地图中心点，并且蓝点会跟随设备移动**/
     const val LOCATION_TYPE_FOLLOW_NO_CENTER: Int = 7
-    /***连续定位、蓝点不会移动到地图中心点，地图依照设备方向旋转，并且蓝点会跟随设备移动**/
+    /**连续定位、蓝点不会移动到地图中心点，地图依照设备方向旋转，并且蓝点会跟随设备移动**/
     const val LOCATION_TYPE_MAP_ROTATE_NO_CENTER: Int = 8
 
-    private var styleMap = mapOf(
+    // 高德定位类型
+    private var styleAMap = mapOf(
         LOCATION_TYPE_LOCATE to aMapMyLocationStyle.LOCATION_TYPE_LOCATE,
         LOCATION_TYPE_FOLLOW to aMapMyLocationStyle.LOCATION_TYPE_FOLLOW,
         LOCATION_TYPE_MAP_ROTATE to aMapMyLocationStyle.LOCATION_TYPE_MAP_ROTATE,
@@ -42,6 +45,11 @@ object MSLocationStyle {
     //高德初始化定位蓝点样式类
     private val aMyLocationStyle by lazy { aMapMyLocationStyle() }
 
+    /**
+     * 设置定位蓝点样式
+     * @param mapReadView 地图准备就绪视图对象
+     * @param type 定位类型，默认为LOCATION_TYPE_LOCATION_ROTATE，表示连续定位并旋转视角
+     */
     fun setLocationStyle(mapReadView: MapReadyView?, type: Int = LOCATION_TYPE_LOCATION_ROTATE) {
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
@@ -59,7 +67,7 @@ object MSLocationStyle {
 
             MAP_TYPE.AMAP -> {
                 var aMap = mapReadView?.aMap
-                aMyLocationStyle.myLocationType(styleMap.get(type)!!)
+                aMyLocationStyle.myLocationType(styleAMap.get(type)!!)
                 aMyLocationStyle.interval(2000) //设置连续定位模式下的定位间隔，只在连续定位模式下生效，单次定位模式下不会生效。单位为毫秒。
 //aMap.getUiSettings().setMyLocationButtonEnabled(true);设置默认定位按钮是否显示，非必需设置。
                 aMap?.setMyLocationEnabled(true) // 设置为true表示启动显示定位蓝点，false表示隐藏定位蓝点并不进行定位，默认是false。

maplibrary/src/main/java/com/sd/maplibrary/core/MSMethodAdv.kt

@@ -9,12 +9,16 @@ import com.sd.maplibrary.MSDKInitializer
 import com.amap.api.maps.model.LatLng as ALatLng
 
 
-/****地图方法交互**/
+/**
+ * 地图方法交互
+ */
 object MSMethodAdv {
 
-    /****改变地图中心点
-     * @param lat 维度
-     * @param lng 经度
+    /****
+     * 改变地图中心点
+     * @param mapReadView 地图准备就绪的视图对象，可能为null
+     * @param lat 纬度，默认值为39.977290
+     * @param lng 经度，默认值为116.337000
      * **/
     fun setMapCenter(
         mapReadView: MapReadyView?,
@@ -22,11 +26,13 @@ object MSMethodAdv {
         lng: Double = 116.337000
     ) {
         when (MSDKInitializer.getMapType()) {
+            // 处理自定义地图类型
             MAP_TYPE.MINE -> {
                 val point = Tools.latLngToPoint(LatLng(lat, lng))
                 mapReadView?.mMineMap?.setPointToCenter(point.x, point.y)
             }
 
+            // 处理高德地图类型
             MAP_TYPE.AMAP -> {
                 //参数依次是：视角调整区域的中心点坐标、希望调整到的缩放级别、俯仰角0°~45°（垂直与地图时为0）、偏航角 0~360° (正北方为0)
                 val mCameraUpdate = CameraUpdateFactory.newCameraPosition(
@@ -37,10 +43,14 @@ object MSMethodAdv {
         }
     }
 
-    /****改变地图缩放级别
-     * @param zoom 越小站得越高
-     * **/
+
+    /**
+     * 改变地图缩放级别
+     * @param mapReadView 地图准备就绪的视图对象
+     * @param zoom 缩放级别，值越小站得越高，默认值为13f
+     * */
     fun setMapZoom(mapReadView: MapReadyView?, zoom: Float = 13f) {
+        // 根据不同的地图类型设置对应的缩放级别
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
                 mapReadView?.mMineMap?.setZoomLevel(zoom)
@@ -53,8 +63,14 @@ object MSMethodAdv {
         }
     }
 
-    /***获取地图缩放级别**/
+
+    /**
+     * 获取地图缩放级别
+     * @param mapReadView 地图准备就绪视图对象
+     * @return 返回当前地图的缩放级别，如果地图未初始化则返回0f
+     */
     fun getMapZoom(mapReadView: MapReadyView?): Float {
+        // 根据不同的地图类型获取对应的缩放级别
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
               return  mapReadView?.mMineMap?.zoomLevel?:0f
@@ -68,6 +84,7 @@ object MSMethodAdv {
     }
 
 
+
     /***设置地图显示区域**/
 //    fun setMapBoundArea(mapReadView: MapReadyView?) {
 //        when (MSDKInitializer.getMapType()) {

maplibrary/src/main/java/com/sd/maplibrary/core/MSPoiSearch.kt

@@ -15,6 +15,7 @@ import com.amap.api.services.core.LatLonPoint as ALatLonPoint
 import com.amap.api.services.poisearch.PoiResult as APoiResult
 import com.amap.api.services.poisearch.PoiSearch as APoiSearch
 import com.amap.api.services.poisearch.PoiSearch.SearchBound
+import com.sd.maplibrary.UserCtx
 
 /****Poi  搜索相关**/
 object MSPoiSearch : PoiSearch.OnPoiSearchListener, APoiSearch.OnPoiSearchListener {
@@ -22,46 +23,33 @@ object MSPoiSearch : PoiSearch.OnPoiSearchListener, APoiSearch.OnPoiSearchListen
 
     private var onMSPoiSearchLis: OnMSPoiSearchLis? = null
 
-//    //四维搜索对象
+    //四维搜索对象
 //    private var poiSearch: PoiSearch? = null
-//    //
 
+    //搜索接口回调
     interface OnMSPoiSearchLis {
-        /***
+        /**
          * 搜索返回
          * @param poiList 返回列表
-         * @param resCode 1=成功 0=失败
-         * ***/
-        fun onPoiLis(poiList: List<PoiSearchRes>, resCode: Int)
+         */
+        fun onPoiLis(poiList: List<PoiSearchRes>)
     }
 
-    /***搜索初始化**/
-   private fun initSearch(context: Context) {
-        when (MSDKInitializer.getMapType()) {
-            MAP_TYPE.MINE -> {
-//                poiSearch = PoiSearch(context)
-            }
 
-            MAP_TYPE.AMAP -> {
-
-            }
-        }
-    }
-
-    /***关键字搜索
+    /**关键字搜索
      * @param keyWord 关键字
      * @param lat 当期维度
      * @param lng 当期经度
-     * @param onMSPoiSearchLis 回调
-     * ***/
+     * @param onMSPoiSearchLis 搜索回调
+     */
     fun startPoiSearch(
-        context: Context,
         keyWord: String,
         lat: Double = 41.80196,
         lng: Double = 123.43326,
         onMSPoiSearchLis: OnMSPoiSearchLis
     ) {
         this.onMSPoiSearchLis = onMSPoiSearchLis
+        var context = UserCtx.instance.mContext
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
                 val poiSearch = PoiSearch(context)
@@ -98,16 +86,14 @@ object MSPoiSearch : PoiSearch.OnPoiSearchListener, APoiSearch.OnPoiSearchListen
         }
     }
 
-    /****周边搜索
+    /**周边搜索
      * @param keyWord 关键字
-     * @param lat 当期维度
-     * @param lng 当期经度
+     * @param lat 当前维度
+     * @param lng 当前经度
      * @param radios 搜索半径(单位 米)
      * @param onMSPoiSearchLis 回调
-
-     * **/
+     */
     fun startPoiSearchBound(
-        context: Context,
         keyWord: String,
         lat: Double,
         lng: Double,
@@ -115,6 +101,7 @@ object MSPoiSearch : PoiSearch.OnPoiSearchListener, APoiSearch.OnPoiSearchListen
         onMSPoiSearchLis: OnMSPoiSearchLis
     ) {
         this.onMSPoiSearchLis = onMSPoiSearchLis
+        var context = UserCtx.instance.mContext
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
                 val poiSearch = PoiSearch(context)
@@ -182,9 +169,9 @@ object MSPoiSearch : PoiSearch.OnPoiSearchListener, APoiSearch.OnPoiSearchListen
                     adCode = pos.adCode
                 }
             }
-            onMSPoiSearchLis?.onPoiLis(poiList, 1)
+            onMSPoiSearchLis?.onPoiLis(poiList)
         } else {
-            onMSPoiSearchLis?.onPoiLis(listOf(), 0)
+            onMSPoiSearchLis?.onPoiLis(listOf())
         }
     }
 
@@ -207,10 +194,10 @@ object MSPoiSearch : PoiSearch.OnPoiSearchListener, APoiSearch.OnPoiSearchListen
                         adCode = pos.adCode
                     }
                 }
-                onMSPoiSearchLis?.onPoiLis(poiList, 1)
+                onMSPoiSearchLis?.onPoiLis(poiList)
             }
         } else {
-            onMSPoiSearchLis?.onPoiLis(listOf(), 0)
+            onMSPoiSearchLis?.onPoiLis(listOf())
         }
     }
 

maplibrary/src/main/java/com/sd/maplibrary/core/MSRegeoCode.kt

 package com.sd.maplibrary.core
 
-import android.content.Context
+import com.amap.api.services.core.AMapException
 import com.minedata.minenavi.poiquery.GeocodeResult
 import com.minedata.minenavi.poiquery.GeocodeSearch
 import com.minedata.minenavi.poiquery.LatLonPoint
@@ -8,29 +8,29 @@ import com.minedata.minenavi.poiquery.RegeocodeQuery
 import com.minedata.minenavi.poiquery.RegeocodeResult
 import com.sd.maplibrary.MAP_TYPE
 import com.sd.maplibrary.MSDKInitializer
+import com.sd.maplibrary.UserCtx
 import com.sd.maplibrary.bean.RegeocodeRes
-import com.amap.api.services.geocoder.RegeocodeQuery as ARegeocodeQuery
 import com.amap.api.services.core.LatLonPoint as ALatLonPoint
 import com.amap.api.services.geocoder.GeocodeSearch as AGeocodeSearch
+import com.amap.api.services.geocoder.RegeocodeQuery as ARegeocodeQuery
 import com.amap.api.services.geocoder.RegeocodeResult as ARegeocodeResult
-import com.amap.api.services.core.AMapException
 
-/***逆地理编码**/
+/**逆地理编码*/
 object MSRegeoCode : GeocodeSearch.OnGeocodeSearchListener, AGeocodeSearch.OnGeocodeSearchListener {
 
     private var mSOnRegeo: MSOnRegeo? = null
 
+    /**逆地理编码信息回调*/
     interface MSOnRegeo {
         fun onRegeo(regeocodeRes: RegeocodeRes?)
     }
 
-    /****逆地理编码
+    /**逆地理编码
      * @param lat 维度
      * @param lng 经度
      * @param msOnRegeo 信息回调
-     * ***/
+     */
     fun geoCoder(
-        context: Context,
         lat: Double,
         lng: Double,
         msOnRegeo: MSOnRegeo
@@ -38,6 +38,7 @@ object MSRegeoCode : GeocodeSearch.OnGeocodeSearchListener, AGeocodeSearch.OnGeo
         if (lat == 0.0 || lng == 0.0)
             return
         this.mSOnRegeo = msOnRegeo
+        var context= UserCtx.instance.mContext
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
                 val geocoderSearch = GeocodeSearch(context)

maplibrary/src/main/java/com/sd/maplibrary/core/MSRoutePlans.kt

@@ -9,8 +9,10 @@ import com.amap.api.navi.AmapNaviPage
 import com.amap.api.navi.AmapNaviParams
 import com.amap.api.navi.AmapNaviType
 import com.amap.api.navi.AmapPageType
+import com.amap.api.navi.enums.PathPlanningStrategy
 import com.amap.api.navi.model.AMapCalcRouteResult
 import com.amap.api.navi.model.AMapNaviPath
+import com.amap.api.navi.model.NaviLatLng
 import com.amap.api.navi.view.RouteOverLay
 import com.minedata.minenavi.map.Route
 import com.minedata.minenavi.map.RouteOptions
@@ -26,6 +28,7 @@ import com.minedata.minenavi.navi.RouterErrorInfo
 import com.minedata.minenavi.util.Tools
 import com.sd.maplibrary.MAP_TYPE
 import com.sd.maplibrary.MSDKInitializer
+import com.sd.maplibrary.UserCtx
 import com.sd.maplibrary.bean.DriverRouteBean
 import com.sd.maplibrary.bean.MSLatLng
 import com.sd.maplibrary.bean.WayPoi
@@ -61,19 +64,20 @@ object MSRoutePlans {
      */
     private var mRoute: Route? = null
 
-    /**
-     * 高德保存当前算好的路线
-     */
+    //高德保存当前算好的路线
     private var routeOverlay: RouteOverLay? = null
 //    private val routeOverlays: SparseArray<RouteOverLay> = SparseArray<RouteOverLay>()
 
 
-    /****设置监听
-     * @param context
-     * @param 接口
-     * **/
-    fun addPlanLis(context: Context, onDriveRoute: OnDriveRoute) {
+    /**
+     * 添加导航路线规划监听
+     * @param onDriveRoute 导航路线回调接口
+     */
+    fun addPlanLis(onDriveRoute: OnDriveRoute) {
+        var context= UserCtx.instance.mContext
         this.onDriveRoute = onDriveRoute
+
+        // 根据地图类型初始化不同的导航引擎
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
                 mNaviSession = NaviSession.getInstance()
@@ -100,20 +104,22 @@ object MSRoutePlans {
         }
     }
 
-    /***驾车路径规划,直接跳转到 导航页面
-     *@param starPoint 起点坐标
+
+    /**驾车路径规划
+     * @param starPoint 起点坐标
      * @param endPoint 终点坐标
      * @param ways     途经点集合
      * @param endName 终点名称（高德可不传）
-     * ***/
+     * @param startName 起点名称
+     */
     fun drivingPathPlanning(
-        context: Context,
         starPoint: MSLatLng,
         endPoint: MSLatLng,
         ways: List<WayPoi>,
         endName: String = "",
         startName: String = "当前位置"
     ) {
+        var context = UserCtx.instance.mContext
         when (MSDKInitializer.getMapType()) {
             MAP_TYPE.MINE -> {
                 val starPoint = Tools.latLngToPoint(LatLng(starPoint.lat, starPoint.lng))
@@ -143,95 +149,106 @@ object MSRoutePlans {
 
             MAP_TYPE.AMAP -> {
                 //这是路径规划
-//                var startLatlng = NaviLatLng(starPoint.lat, starPoint.lng)
-//                var startList = listOf<NaviLatLng>(startLatlng)
-//
-//                var endLatlng = NaviLatLng(endPoint.lat, endPoint.lng)
-//                var endList = listOf<NaviLatLng>(endLatlng)
-//                var wayPoints = listOf<NaviLatLng>()
-//
-//                mAMapNavi?.calculateDriveRoute(
-//                    startList,
-//                    endList,
-//                    wayPoints,
-//                    PathPlanningStrategy.DRIVING_MULTIPLE_ROUTES_DEFAULT
-//                )
-
+                var startLatlng = NaviLatLng(starPoint.lat, starPoint.lng)
+                var startList = listOf<NaviLatLng>(startLatlng)
 
+                var endLatlng = NaviLatLng(endPoint.lat, endPoint.lng)
+                var endList = listOf<NaviLatLng>(endLatlng)
                 //途经点
-                var poiList = mutableListOf<Poi>()
+                var wayPoints = mutableListOf<NaviLatLng>()
                 if (ways.count() > 0) {
                     ways.forEach { wpoi ->
-                        poiList.add(Poi("鸟巢", ALatLng(wpoi.passPoint!!.lat, wpoi.passPoint!!.lng), ""))
+                        wayPoints.add(NaviLatLng(wpoi.passPoint!!.lat, wpoi.passPoint!!.lng))
                     }
                 }
 
-                //这是导航，直接到高德内置组件
-                val params = AmapNaviParams(
-                    Poi(startName, ALatLng(starPoint.lat, starPoint.lng), ""),
-                    poiList,
-                    Poi(endName, ALatLng(endPoint.lat, endPoint.lng), ""),
-                    AmapNaviType.DRIVER, AmapPageType.ROUTE
+                mAMapNavi?.calculateDriveRoute(
+                    startList,
+                    endList,
+                    wayPoints,
+                    PathPlanningStrategy.DRIVING_MULTIPLE_ROUTES_DEFAULT
                 )
-                params.setUseInnerVoice(true)
-                AmapNaviPage.getInstance()
-                    .showRouteActivity(context, params, null)
+
+                //这是导航，直接到高德内置组件
+                //途经点
+                /*     var poiList = mutableListOf<Poi>()
+                     if (ways.count() > 0) {
+                         ways.forEach { wpoi ->
+                             poiList.add(Poi("鸟巢", ALatLng(wpoi.passPoint!!.lat, wpoi.passPoint!!.lng), ""))
+                         }
+                     }*/
+
+                /*                val params = AmapNaviParams(
+                                    Poi(startName, ALatLng(starPoint.lat, starPoint.lng), ""),
+                                    poiList,
+                                    Poi(endName, ALatLng(endPoint.lat, endPoint.lng), ""),
+                                    AmapNaviType.DRIVER, AmapPageType.ROUTE
+                                )
+                                params.setUseInnerVoice(true)
+                                AmapNaviPage.getInstance()
+                                    .showRouteActivity(context, params, null)*/
             }
         }
     }
 
-    //自定义驾车路线返回
+    /**自定义驾车路线返回*/
     interface OnDriveRoute {
         fun onDriverRoute(driverRouteBean: DriverRouteBean)
     }
 
-    /***绘制路径规划
-     * @param driverRB 算路结果回调
-     * ***/
-    fun drawPlanPath(
-        mapReadView: MapReadyView?,
-        driverRB: DriverRouteBean,
-        context: Context
-    ) {
-        when (MSDKInitializer.getMapType()) {
-            MAP_TYPE.MINE -> {
-                if (mRoute != null) {
-                    mapReadView?.mMineMap?.removeOverlay(mRoute)
-                    mRoute = null
-                }
-                var routeBase = driverRB.routeCollection?.routes?.get(0)
-                val options = RouteOptions()
-                    .routeBase(routeBase)
-                    .colorType(Route.RouteColorType.enrouteTi)
-//            .colorType(Route.RouteColorType.none)
-                    .styleClass("DEFAULT")
-
-                mRoute = mapReadView?.mMineMap?.addRoute(options)
-                setRouteOverlayStyle(mRoute, false)
-                navEndFitWorldAreaToRect(mapReadView, routeBase)
+
+/**
+ * 绘制规划的路线路径。
+ * @param mapReadView 地图视图容器，用于获取当前地图实例。
+ * @param driverRB 包含路线信息的数据对象。
+ */
+fun drawPlanPath(
+    mapReadView: MapReadyView?,
+    driverRB: DriverRouteBean
+) {
+    var context = UserCtx.instance.mContext
+    when (MSDKInitializer.getMapType()) {
+        MAP_TYPE.MINE -> {
+            // 移除旧的路线覆盖物
+            if (mRoute != null) {
+                mapReadView?.mMineMap?.removeOverlay(mRoute)
+                mRoute = null
             }
 
-            MAP_TYPE.AMAP -> {
-//                mapReadView?.aMap?.clear()
-                //清空上次计算的路径列表。
-                if (routeOverlay != null) {
-                    routeOverlay?.removeFromMap()
-                    routeOverlay = null
-                }
-//                routeOverlays.clear()
-                val routeIds = driverRB.aMapCalcRouteResult!!.getRouteid()
-                val paths: HashMap<Int, AMapNaviPath> = mAMapNavi!!.getNaviPaths()
-                val path: AMapNaviPath? = paths.get(routeIds[0])
-                if (path != null) {
-//                        drawRoutes(routeIds[i], path, mapReadView,context)
-                    mapReadView?.aMap?.moveCamera(CameraUpdateFactory.changeTilt(0f))
-                    routeOverlay = RouteOverLay(mapReadView?.aMap, path, context)
-                    routeOverlay?.setTrafficLine(false)
-                    routeOverlay?.addToMap()
-                }
+            // 获取第一条路线数据并设置路线绘制选项
+            var routeBase = driverRB.routeCollection?.routes?.get(0)
+            val options = RouteOptions()
+                .routeBase(routeBase)
+                .colorType(Route.RouteColorType.enrouteTi)
+                .styleClass("DEFAULT")
+
+            // 添加新的路线到地图上，并设置样式和视角适配
+            mRoute = mapReadView?.mMineMap?.addRoute(options)
+            setRouteOverlayStyle(mRoute, false)
+            navEndFitWorldAreaToRect(mapReadView, routeBase)
+        }
+
+        MAP_TYPE.AMAP -> {
+            // 清除之前的路线覆盖物
+            if (routeOverlay != null) {
+                routeOverlay?.removeFromMap()
+                routeOverlay = null
+            }
+
+            // 从导航结果中获取路径信息并在高德地图上绘制
+            val routeIds = driverRB.aMapCalcRouteResult!!.getRouteid()
+            val paths: HashMap<Int, AMapNaviPath> = mAMapNavi!!.getNaviPaths()
+            val path: AMapNaviPath? = paths.get(routeIds[0])
+            if (path != null) {
+                mapReadView?.aMap?.moveCamera(CameraUpdateFactory.changeTilt(0f))
+                routeOverlay = RouteOverLay(mapReadView?.aMap, path, context)
+                routeOverlay?.setTrafficLine(false)
+                routeOverlay?.addToMap()
             }
         }
     }
+}
+
 
 //    private fun drawRoutes(
 //        routeId: Int,