expo-gaode-map 2.2.8-next.0 → 2.2.8-next.1

package/android/src/main/java/expo/modules/gaodemap/ExpoGaodeMapOfflineModule.kt

@@ -0,0 +1,493 @@
+package expo.modules.gaodemap
+
+import android.os.Bundle
+import android.os.StatFs
+import android.os.Environment
+import com.amap.api.maps.offlinemap.OfflineMapCity
+import com.amap.api.maps.offlinemap.OfflineMapManager
+import com.amap.api.maps.offlinemap.OfflineMapProvince
+import com.amap.api.maps.offlinemap.OfflineMapStatus
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+/**
+ * 高德地图离线地图模块 (Android)
+ */
+class ExpoGaodeMapOfflineModule : Module() {
+  
+  private var offlineMapManager: OfflineMapManager? = null
+  private val downloadingCities = mutableSetOf<String>()
+  private val pausedCities = mutableSetOf<String>()
+  
+  // 线程安全锁
+  private val lock = Any()
+  
+  override fun definition() = ModuleDefinition {
+    Name("ExpoGaodeMapOffline")
+    
+    // ==================== 事件定义 ====================
+    
+    Events(
+      "onDownloadProgress",
+      "onDownloadComplete",
+      "onDownloadError",
+      "onUnzipProgress",
+      "onDownloadPaused",
+      "onDownloadCancelled"
+    )
+    
+    // ==================== 模块生命周期 ====================
+    
+    OnCreate {
+      // 初始化离线地图管理器
+      offlineMapManager = OfflineMapManager(appContext.reactContext, object : OfflineMapManager.OfflineMapDownloadListener {
+        override fun onDownload(status: Int, completeCode: Int, downName: String?) {
+          handleDownloadStatus(status, completeCode, downName)
+        }
+        
+        override fun onCheckUpdate(hasNew: Boolean, name: String?) {
+          // 更新检查回调
+        }
+        
+        override fun onRemove(success: Boolean, name: String?, describe: String?) {
+          // 删除回调
+        }
+      })
+    }
+    
+    OnDestroy {
+      offlineMapManager?.destroy()
+      offlineMapManager = null
+      downloadingCities.clear()
+    }
+    
+    // ==================== 地图列表管理 ====================
+    
+    AsyncFunction("getAvailableCities") {
+      val cities = offlineMapManager?.offlineMapCityList ?: emptyList()
+      cities.map { city -> convertCityToMap(city) }
+    }
+    
+    AsyncFunction("getAvailableProvinces") {
+      val provinces = offlineMapManager?.offlineMapProvinceList ?: emptyList()
+      provinces.map { province -> convertProvinceToMap(province) }
+    }
+    
+    AsyncFunction("getCitiesByProvince") { provinceCode: String ->
+      val province = offlineMapManager?.offlineMapProvinceList?.find { 
+        it.provinceCode == provinceCode 
+      }
+      province?.cityList?.map { city -> convertCityToMap(city) } ?: emptyList()
+    }
+    
+    AsyncFunction("getDownloadedMaps") {
+      val cities = offlineMapManager?.downloadOfflineMapCityList ?: emptyList()
+      cities.map { city -> convertCityToMap(city) }
+    }
+    
+    // ==================== 下载管理 ====================
+    
+    AsyncFunction("startDownload") { config: Map<String, Any?> ->
+      val cityCode = config["cityCode"] as? String
+        ?: throw IllegalArgumentException("cityCode is required")
+      
+      synchronized(lock) {
+        downloadingCities.add(cityCode)
+        pausedCities.remove(cityCode)
+      }
+      offlineMapManager?.downloadByCityCode(cityCode)
+    }
+    
+    AsyncFunction("pauseDownload") { cityCode: String ->
+      val city = offlineMapManager?.getItemByCityCode(cityCode)
+      
+      synchronized(lock) {
+        pausedCities.add(cityCode)
+        downloadingCities.remove(cityCode)
+      }
+      
+      // 使用 pauseByName 暂停指定城市
+      city?.city?.let { cityName ->
+        offlineMapManager?.pauseByName(cityName)
+      }
+      
+      if (city != null) {
+        sendEvent("onDownloadPaused", Bundle().apply {
+          putString("cityCode", cityCode)
+          putString("cityName", city.city)
+        })
+      }
+    }
+    
+    AsyncFunction("resumeDownload") { cityCode: String ->
+      synchronized(lock) {
+        downloadingCities.add(cityCode)
+        pausedCities.remove(cityCode)
+      }
+      // Android SDK 没有针对单个城市的恢复方法
+      // 需要重新调用 downloadByCityCode 来继续下载
+      offlineMapManager?.downloadByCityCode(cityCode)
+    }
+    
+    AsyncFunction("cancelDownload") { cityCode: String ->
+      val city = offlineMapManager?.getItemByCityCode(cityCode)
+      
+      synchronized(lock) {
+        downloadingCities.remove(cityCode)
+        pausedCities.remove(cityCode)
+      }
+      
+      // 使用 stop() 停止所有下载(包括队列)
+      offlineMapManager?.stop()
+      
+      if (city != null) {
+        sendEvent("onDownloadCancelled", Bundle().apply {
+          putString("cityCode", cityCode)
+          putString("cityName", city.city)
+        })
+      }
+    }
+    
+    AsyncFunction("deleteMap") { cityCode: String ->
+      val city = offlineMapManager?.getItemByCityCode(cityCode)
+        ?: throw IllegalArgumentException("City not found: $cityCode")
+      
+      // 官方文档:remove() 需要传入城市名称,不是城市代码
+      offlineMapManager?.remove(city.city)
+      
+      synchronized(lock) {
+        downloadingCities.remove(cityCode)
+        pausedCities.remove(cityCode)
+      }
+    }
+    
+    AsyncFunction("updateMap") { cityCode: String ->
+      synchronized(lock) {
+        downloadingCities.add(cityCode)
+      }
+      offlineMapManager?.updateOfflineCityByCode(cityCode)
+    }
+    
+    AsyncFunction("checkUpdate") { cityCode: String ->
+      val city = offlineMapManager?.getItemByCityCode(cityCode)
+      city?.state == OfflineMapStatus.NEW_VERSION
+    }
+    
+    // ==================== 状态查询 ====================
+    
+    AsyncFunction("isMapDownloaded") { cityCode: String ->
+      val city = offlineMapManager?.getItemByCityCode(cityCode)
+      city?.state == OfflineMapStatus.SUCCESS || 
+      city?.state == OfflineMapStatus.CHECKUPDATES
+    }
+    
+    AsyncFunction("getMapStatus") { cityCode: String ->
+      val city = offlineMapManager?.getItemByCityCode(cityCode)
+      city?.let { convertCityToMap(it) } ?: Bundle()
+    }
+    
+    AsyncFunction("getTotalProgress") {
+      val downloadedCities = offlineMapManager?.downloadOfflineMapCityList ?: emptyList()
+      if (downloadedCities.isEmpty()) {
+        0.0
+      } else {
+        val totalProgress = downloadedCities.sumOf { it.getcompleteCode().toDouble() }
+        totalProgress / downloadedCities.size
+      }
+    }
+    
+    AsyncFunction("getDownloadingCities") {
+      downloadingCities.toList()
+    }
+    
+    // ==================== 存储管理 ====================
+    
+    AsyncFunction("getStorageSize") {
+      // 计算所有已下载地图的大小
+      val cities = offlineMapManager?.downloadOfflineMapCityList ?: emptyList()
+      cities.sumOf { it.size }
+    }
+    
+    AsyncFunction("getStorageInfo") {
+      val cities = offlineMapManager?.downloadOfflineMapCityList ?: emptyList()
+      val offlineMapSize = cities.sumOf { it.size }
+      
+      // 获取存储路径的统计信息
+      val stat = StatFs(Environment.getDataDirectory().path)
+      val blockSize = stat.blockSizeLong
+      val totalBlocks = stat.blockCountLong
+      val availableBlocks = stat.availableBlocksLong
+      
+      val totalSpace = totalBlocks * blockSize
+      val availableSpace = availableBlocks * blockSize
+      val usedSpace = totalSpace - availableSpace
+      
+      Bundle().apply {
+        putLong("totalSpace", totalSpace)
+        putLong("usedSpace", usedSpace)
+        putLong("availableSpace", availableSpace)
+        putLong("offlineMapSize", offlineMapSize)
+      }
+    }
+    
+    AsyncFunction("clearAllMaps") {
+      offlineMapManager?.downloadOfflineMapCityList?.forEach { city ->
+        // 使用城市名称删除
+        offlineMapManager?.remove(city.city)
+      }
+      synchronized(lock) {
+        downloadingCities.clear()
+        pausedCities.clear()
+      }
+    }
+    
+    Function("setStoragePath") { path: String ->
+      // Android 离线地图路径由系统管理，此方法不可用
+    }
+    
+    AsyncFunction("getStoragePath") {
+      // Android 离线地图路径由系统管理
+      ""
+    }
+    
+    // ==================== 批量操作 ====================
+    
+    AsyncFunction("batchDownload") { cityCodes: List<String>, allowCellular: Boolean? ->
+      synchronized(lock) {
+        cityCodes.forEach { cityCode ->
+          downloadingCities.add(cityCode)
+          pausedCities.remove(cityCode)
+        }
+      }
+      cityCodes.forEach { cityCode ->
+        offlineMapManager?.downloadByCityCode(cityCode)
+      }
+    }
+    
+    AsyncFunction("batchDelete") { cityCodes: List<String> ->
+      cityCodes.forEach { cityCode ->
+        val city = offlineMapManager?.getItemByCityCode(cityCode)
+        // 使用城市名称删除,不是城市代码
+        city?.city?.let { cityName ->
+          offlineMapManager?.remove(cityName)
+        }
+      }
+      synchronized(lock) {
+        cityCodes.forEach { cityCode ->
+          downloadingCities.remove(cityCode)
+          pausedCities.remove(cityCode)
+        }
+      }
+    }
+    
+    AsyncFunction("batchUpdate") { cityCodes: List<String> ->
+      synchronized(lock) {
+        cityCodes.forEach { cityCode ->
+          downloadingCities.add(cityCode)
+        }
+      }
+      cityCodes.forEach { cityCode ->
+        offlineMapManager?.updateOfflineCityByCode(cityCode)
+      }
+    }
+    
+    AsyncFunction("pauseAllDownloads") {
+      // pause() 只暂停正在下载的,不包括队列
+      offlineMapManager?.pause()
+      
+      synchronized(lock) {
+        pausedCities.addAll(downloadingCities)
+        downloadingCities.forEach { cityCode ->
+          val city = offlineMapManager?.getItemByCityCode(cityCode)
+          if (city != null) {
+            sendEvent("onDownloadPaused", Bundle().apply {
+              putString("cityCode", cityCode)
+              putString("cityName", city.city)
+            })
+          }
+        }
+        downloadingCities.clear()
+      }
+    }
+    
+    AsyncFunction("resumeAllDownloads") {
+      val pausedList = synchronized(lock) {
+        pausedCities.toList()
+      }
+      
+      // 重新下载所有暂停的城市
+      pausedList.forEach { cityCode ->
+        synchronized(lock) {
+          downloadingCities.add(cityCode)
+          pausedCities.remove(cityCode)
+        }
+        offlineMapManager?.downloadByCityCode(cityCode)
+      }
+    }
+  }
+  
+  // ==================== 辅助方法 ====================
+  
+  /**
+   * 处理下载状态回调
+   */
+  private fun handleDownloadStatus(status: Int, completeCode: Int, downName: String?) {
+    if (downName == null) return
+    
+    // downName 可能是城市代码或城市名称,尝试两种方式查找
+    var city = offlineMapManager?.getItemByCityCode(downName)
+    if (city == null) {
+      city = offlineMapManager?.offlineMapCityList?.find { it.city == downName }
+    }
+    
+    if (city == null) return
+    
+    val cityCode = city.code
+    val cityName = city.city
+    
+    when (status) {
+      OfflineMapStatus.SUCCESS -> {
+        synchronized(lock) {
+          downloadingCities.remove(cityCode)
+          pausedCities.remove(cityCode)
+        }
+        sendEvent("onDownloadComplete", Bundle().apply {
+          putString("cityCode", cityCode)
+          putString("cityName", cityName)
+        })
+      }
+      
+      OfflineMapStatus.LOADING -> {
+        sendEvent("onDownloadProgress", Bundle().apply {
+          putString("cityCode", cityCode)
+          putString("cityName", cityName)
+          putInt("progress", completeCode)
+          putLong("receivedSize", (city.size * completeCode / 100))
+          putLong("expectedSize", city.size)
+        })
+      }
+      
+      OfflineMapStatus.UNZIP -> {
+        sendEvent("onUnzipProgress", Bundle().apply {
+          putString("cityCode", cityCode)
+          putString("cityName", cityName)
+        })
+      }
+      
+      OfflineMapStatus.ERROR -> {
+        synchronized(lock) {
+          downloadingCities.remove(cityCode)
+        }
+        sendEvent("onDownloadError", Bundle().apply {
+          putString("cityCode", cityCode)
+          putString("cityName", cityName)
+          putString("error", "解压失败,数据可能有问题")
+        })
+      }
+      
+      OfflineMapStatus.EXCEPTION_NETWORK_LOADING -> {
+        sendEvent("onDownloadError", Bundle().apply {
+          putString("cityCode", cityCode)
+          putString("cityName", cityName)
+          putString("error", "网络异常")
+        })
+      }
+      
+      OfflineMapStatus.EXCEPTION_AMAP -> {
+        synchronized(lock) {
+          downloadingCities.remove(cityCode)
+        }
+        sendEvent("onDownloadError", Bundle().apply {
+          putString("cityCode", cityCode)
+          putString("cityName", cityName)
+          putString("error", "认证异常,请检查Key")
+        })
+      }
+      
+      OfflineMapStatus.EXCEPTION_SDCARD -> {
+        synchronized(lock) {
+          downloadingCities.remove(cityCode)
+        }
+        sendEvent("onDownloadError", Bundle().apply {
+          putString("cityCode", cityCode)
+          putString("cityName", cityName)
+          putString("error", "SD卡读写异常")
+        })
+      }
+      
+      OfflineMapStatus.PAUSE -> {
+        // 检查是否是用户主动暂停
+        val isPaused = synchronized(lock) { pausedCities.contains(cityCode) }
+        if (isPaused) {
+          sendEvent("onDownloadPaused", Bundle().apply {
+            putString("cityCode", cityCode)
+            putString("cityName", cityName)
+          })
+        }
+      }
+    }
+  }
+  
+  /**
+   * 转换城市对象为 Map
+   */
+  private fun convertCityToMap(city: OfflineMapCity): Bundle {
+    val isPaused = synchronized(lock) { pausedCities.contains(city.code) }
+    val isDownloading = synchronized(lock) { downloadingCities.contains(city.code) }
+    
+    val status = when {
+      isPaused -> "paused"
+      isDownloading -> "downloading"
+      else -> getStatusString(city.state)
+    }
+    
+    return Bundle().apply {
+      putString("cityCode", city.code)
+      putString("cityName", city.city)
+      putLong("size", city.size)
+      putString("status", status)
+      putInt("progress", city.getcompleteCode())
+      putString("version", city.version)
+      putLong("downloadedSize", (city.size * city.getcompleteCode() / 100))
+    }
+  }
+  
+  /**
+   * 转换省份对象为 Map
+   */
+  private fun convertProvinceToMap(province: OfflineMapProvince): Bundle {
+    return Bundle().apply {
+      putString("cityCode", province.provinceCode)
+      putString("cityName", province.provinceName)
+      putLong("size", province.size)
+      putString("status", getStatusString(province.state))
+      putInt("progress", province.getcompleteCode())
+      putString("version", province.version)
+      putString("provinceName", province.provinceName)
+      putString("provinceCode", province.provinceCode)
+    }
+  }
+  
+  /**
+   * 获取状态字符串
+   * 注意：只有 SUCCESS 状态才表示真正下载完成
+   */
+  private fun getStatusString(state: Int): String {
+    return when (state) {
+      OfflineMapStatus.SUCCESS -> "downloaded"
+      OfflineMapStatus.LOADING -> "downloading"
+      OfflineMapStatus.UNZIP -> "unzipping"
+      OfflineMapStatus.WAITING -> "downloading"
+      OfflineMapStatus.PAUSE -> "paused"
+      OfflineMapStatus.STOP -> "paused"
+      OfflineMapStatus.ERROR -> "failed"
+      OfflineMapStatus.EXCEPTION_NETWORK_LOADING -> "downloading"  // 网络问题,可继续
+      OfflineMapStatus.EXCEPTION_AMAP -> "failed"  // 认证异常
+      OfflineMapStatus.EXCEPTION_SDCARD -> "failed"  // SD卡异常
+      OfflineMapStatus.START_DOWNLOAD_FAILD -> "failed"  // 开始下载失败
+      OfflineMapStatus.CHECKUPDATES -> "not_downloaded"
+      OfflineMapStatus.NEW_VERSION -> "not_downloaded"
+      else -> "not_downloaded"
+    }
+  }
+}

package/android/src/main/java/expo/modules/gaodemap/ExpoGaodeMapView.kt

@@ -24,6 +24,7 @@ import expo.modules.gaodemap.overlays.*
  * - 生命周期管理
  */
 
+@SuppressLint("ViewConstructor")
 class ExpoGaodeMapView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
 
     /**
@@ -45,6 +46,8 @@ class ExpoGaodeMapView(context: Context, appContext: AppContext) : ExpoView(cont
     internal var initialCameraPosition: Map<String, Any?>? = null
     /** 是否跟随用户位置 */
     internal var followUserLocation: Boolean = false
+    /** 自定义地图样式配置（缓存） */
+    private var customMapStyleData: Map<String, Any>? = null
 
     /** 主线程 Handler */
     private val mainHandler = android.os.Handler(android.os.Looper.getMainLooper())
@@ -57,6 +60,21 @@ class ExpoGaodeMapView(context: Context, appContext: AppContext) : ExpoView(cont
     private val onCameraMove by EventDispatcher()
     private val onCameraIdle by EventDispatcher()
 
+    // 事件节流控制
+    /** 相机移动事件节流间隔(毫秒) */
+    private val CAMERA_MOVE_THROTTLE_MS = 100L
+    /** 上次触发相机移动事件的时间戳 */
+    private var lastCameraMoveTime = 0L
+    /** 缓存的相机移动事件数据 */
+    private var pendingCameraMoveData: Map<String, Any>? = null
+    /** 节流定时器 Runnable */
+    private val throttleRunnable = Runnable {
+        pendingCameraMoveData?.let { data ->
+            onCameraMove(data)
+            pendingCameraMoveData = null
+        }
+    }
+
     // 高德地图视图
     private lateinit var mapView: MapView
     private lateinit var aMap: AMap
@@ -115,6 +133,11 @@ class ExpoGaodeMapView(context: Context, appContext: AppContext) : ExpoView(cont
                     pendingCameraPosition = null
                 }
 
+                // 应用缓存的自定义地图样式
+                customMapStyleData?.let { styleData ->
+                    uiManager.setCustomMapStyle(styleData)
+                }
+
                 onLoad(mapOf("loaded" to true))
             }
         } catch (_: Exception) {
@@ -129,10 +152,11 @@ class ExpoGaodeMapView(context: Context, appContext: AppContext) : ExpoView(cont
         // 设置相机移动监听器
         aMap.setOnCameraChangeListener(object : AMap.OnCameraChangeListener {
             override fun onCameraChange(cameraPosition: com.amap.api.maps.model.CameraPosition?) {
-                // 相机移动中
+                // 相机移动中 - 应用节流优化
                 cameraPosition?.let {
+                    val currentTime = System.currentTimeMillis()
                     val visibleRegion = aMap.projection.visibleRegion
-                    onCameraMove(mapOf(
+                    val eventData = mapOf(
                         "cameraPosition" to mapOf(
                             "target" to mapOf(
                                 "latitude" to it.target.latitude,
@@ -152,7 +176,25 @@ class ExpoGaodeMapView(context: Context, appContext: AppContext) : ExpoView(cont
                                 "longitude" to visibleRegion.nearLeft.longitude
                             )
                         )
-                    ))
+                    )
+                    
+                    // 节流逻辑：100ms 内只触发一次
+                    if (currentTime - lastCameraMoveTime >= CAMERA_MOVE_THROTTLE_MS) {
+                        // 超过节流时间，立即触发事件
+                        lastCameraMoveTime = currentTime
+                        onCameraMove(eventData)
+                        // 清除待处理的事件和定时器
+                        mainHandler.removeCallbacks(throttleRunnable)
+                        pendingCameraMoveData = null
+                    } else {
+                        // 在节流时间内，缓存事件数据，使用定时器延迟触发
+                        pendingCameraMoveData = eventData
+                        mainHandler.removeCallbacks(throttleRunnable)
+                        mainHandler.postDelayed(
+                            throttleRunnable,
+                            CAMERA_MOVE_THROTTLE_MS - (currentTime - lastCameraMoveTime)
+                        )
+                    }
                 }
             }
 
@@ -331,6 +373,18 @@ class ExpoGaodeMapView(context: Context, appContext: AppContext) : ExpoView(cont
     fun setShowsBuildings(show: Boolean) = uiManager.setShowsBuildings(show)
     /** 设置是否显示室内地图 */
     fun setShowsIndoorMap(show: Boolean) = uiManager.setShowsIndoorMap(show)
+    
+    /**
+     * 设置自定义地图样式
+     * @param styleData 样式配置
+     */
+    fun setCustomMapStyle(styleData: Map<String, Any>) {
+        customMapStyleData = styleData
+        // 如果地图已加载，立即应用样式
+        if (isMapLoaded) {
+            uiManager.setCustomMapStyle(styleData)
+        }
+    }
 
     // ==================== 相机控制方法 ====================
 
@@ -397,8 +451,12 @@ class ExpoGaodeMapView(context: Context, appContext: AppContext) : ExpoView(cont
     @Suppress("unused")
     fun onDestroy() {
                try {
-            // 清理 Handler 回调,防止内存泄露
-            mainHandler.removeCallbacksAndMessages(null)
+                   // 清理节流定时器
+                   mainHandler.removeCallbacks(throttleRunnable)
+                   pendingCameraMoveData = null
+                   
+                   // 清理 Handler 回调,防止内存泄露
+                   mainHandler.removeCallbacksAndMessages(null)
 
             // 清理所有地图监听器
             aMap.setOnMapClickListener(null)
@@ -543,4 +601,24 @@ class ExpoGaodeMapView(context: Context, appContext: AppContext) : ExpoView(cont
         super.onLayout(changed, left, top, right, bottom)
     }
 
+    /**
+     * 析构函数 - 当视图被垃圾回收时调用
+     * 
+     * 类似于 iOS 的 deinit，在视图真正被释放时才销毁地图
+     * 这样可以避免页面退出动画未完成时地图就变成白屏的问题
+     */
+    protected fun finalize() {
+        try {
+            onDestroy()
+        } catch (e: Exception) {
+            // 静默处理 finalize 中的异常
+            android.util.Log.e("ExpoGaodeMapView", "Error in finalize", e)
+        }
+        try {
+            super.finalize()
+        } catch (e: Exception) {
+            // 静默处理异常
+        }
+    }
+
 }

package/android/src/main/java/expo/modules/gaodemap/ExpoGaodeMapViewModule.kt

@@ -14,11 +14,10 @@ class ExpoGaodeMapViewModule : Module() {
       Events("onMapPress", "onMapLongPress", "onLoad", "onLocation", "onCameraMove", "onCameraIdle")
       
       // ✅ 关键修复：拦截 React Native 的视图操作异常
-   
-      OnViewDestroys { view: ExpoGaodeMapView ->
-        // 销毁地图实例,释放资源
-        view.onDestroy()
-      }
+      
+      // 移除 OnViewDestroys 回调，让地图在视图真正释放时才销毁
+      // 这样可以避免页面退出动画未完成时地图就变成白屏的问题
+      // 地图会在 finalize() 或 GC 时通过 finalize() 方法自动清理
 
 
       Prop<Int>("mapType") { view, type ->
@@ -51,6 +50,10 @@ class ExpoGaodeMapViewModule : Module() {
       Prop<Boolean>("trafficEnabled") { view, show -> view.setShowsTraffic(show) }
       Prop<Boolean>("buildingsEnabled") { view, show -> view.setShowsBuildings(show) }
       Prop<Boolean>("indoorViewEnabled") { view, show -> view.setShowsIndoorMap(show) }
+      
+      Prop<Map<String, Any>?>("customMapStyle") { view, styleData ->
+        styleData?.let { view.setCustomMapStyle(it) }
+      }
 
       OnViewDidUpdateProps { view: ExpoGaodeMapView ->
         if (view.mapType != 0) {
@@ -83,4 +86,4 @@ class ExpoGaodeMapViewModule : Module() {
       }
     }
   }
-}
+}