expo-gaode-map-navigation 1.1.5-next.1 → 1.1.5-next.3

package/android/src/main/java/expo/modules/gaodemap/map/overlays/ClusterViewModule.kt

@@ -8,7 +8,7 @@ import expo.modules.kotlin.modules.ModuleDefinition
  */
 class ClusterViewModule : Module() {
   override fun definition() = ModuleDefinition {
-    Name("NaviClusterView")
+    Name("ClusterView")
 
     View(ClusterView::class) {
       Events("onPress", "onClusterPress")
@@ -24,6 +24,22 @@ class ClusterViewModule : Module() {
       Prop<Int>("minClusterSize") { view: ClusterView, size ->
         view.setMinClusterSize(size)
       }
+      
+      Prop<Map<String, Any>>("clusterStyle") { view: ClusterView, style ->
+        view.setClusterStyle(style)
+      }
+
+      Prop<List<Map<String, Any>>>("clusterBuckets") { view: ClusterView, buckets ->
+        view.setClusterBuckets(buckets)
+      }
+      
+      Prop<Map<String, Any>>("clusterTextStyle") { view: ClusterView, style ->
+        view.setClusterTextStyle(style)
+      }
+
+      Prop<String>("icon") { view: ClusterView, icon ->
+        view.setIcon(icon)
+      }
     }
   }
 }

package/android/src/main/java/expo/modules/gaodemap/map/overlays/HeatMapView.kt

@@ -1,16 +1,28 @@
 package expo.modules.gaodemap.map.overlays
 
 import android.content.Context
+import android.os.Looper
+import android.util.Log
 import com.amap.api.maps.AMap
 import com.amap.api.maps.model.LatLng
 import com.amap.api.maps.model.TileOverlay
 import com.amap.api.maps.model.TileOverlayOptions
 import com.amap.api.maps.model.HeatmapTileProvider
+import com.amap.api.maps.CameraUpdateFactory
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.views.ExpoView
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import expo.modules.gaodemap.map.utils.LatLngParser
 
 class HeatMapView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
   
+  private val executor: ExecutorService = Executors.newSingleThreadExecutor()
+  private val applyUpdateRunnable = Runnable { applyUpdateOnMain() }
+  @Volatile private var updateToken: Int = 0
+  @Volatile private var needsRebuild: Boolean = true
+  private var visible: Boolean = true
+
   private var heatmapOverlay: TileOverlay? = null
   private var aMap: AMap? = null
   private var dataList: MutableList<LatLng> = mutableListOf()
@@ -23,23 +35,20 @@ class HeatMapView(context: Context, appContext: AppContext) : ExpoView(context,
   @Suppress("unused")
   fun setMap(map: AMap) {
     aMap = map
-    createOrUpdateHeatMap()
+    needsRebuild = true
+    scheduleUpdate()
   }
   
+ 
+
   /**
    * 设置热力图数据
    */
-  fun setData(data: List<Map<String, Any>>) {
+  fun setData(data: List<Any>?) {
     dataList.clear()
-    data.forEach { point ->
-      val lat = (point["latitude"] as? Number)?.toDouble()
-      val lng = (point["longitude"] as? Number)?.toDouble()
-      // 坐标验证
-      if (lat != null && lng != null && lat >= -90 && lat <= 90 && lng >= -180 && lng <= 180) {
-        dataList.add(LatLng(lat, lng))
-      }
-    }
-    createOrUpdateHeatMap()
+    dataList.addAll(LatLngParser.parseLatLngList(data))
+    needsRebuild = true
+    scheduleUpdate()
   }
   
   /**
@@ -47,7 +56,8 @@ class HeatMapView(context: Context, appContext: AppContext) : ExpoView(context,
    */
   fun setRadius(radiusValue: Int) {
     radius = radiusValue
-    createOrUpdateHeatMap()
+    needsRebuild = true
+    scheduleUpdate()
   }
   
   /**
@@ -55,41 +65,162 @@ class HeatMapView(context: Context, appContext: AppContext) : ExpoView(context,
    */
   fun setOpacity(opacityValue: Double) {
     opacity = opacityValue
-    createOrUpdateHeatMap()
+    applyOverlayOpacity()
   }
-  
+
+  fun setVisible(visibleValue: Boolean) {
+    if (!visibleValue) {
+      visible = false
+      updateToken += 1
+      removeCallbacks(applyUpdateRunnable)
+      applyOverlayVisibility()
+      return
+    }
+
+    visible = true
+    applyOverlayVisibility()
+
+    if (dataList.isEmpty()) {
+      return
+    }
+
+    if (heatmapOverlay == null || needsRebuild) {
+      scheduleUpdate()
+    } else {
+      applyOverlayOpacity()
+      forceRefresh()
+    }
+  }
+
+  private fun scheduleUpdate() {
+    updateToken += 1
+    removeCallbacks(applyUpdateRunnable)
+    postDelayed(applyUpdateRunnable, 32)
+  }
+
+  private fun applyOverlayVisibility() {
+    if (Looper.myLooper() != Looper.getMainLooper()) {
+      post { applyOverlayVisibility() }
+      return
+    }
+    val overlay = heatmapOverlay ?: return
+    runCatching {
+      overlay.javaClass.getMethod("setVisible", Boolean::class.javaPrimitiveType)
+        .invoke(overlay, visible)
+    }.onFailure {
+      if (!visible) {
+        overlay.remove()
+        heatmapOverlay = null
+        needsRebuild = true
+      }
+    }
+  }
+
+  private fun applyOverlayOpacity() {
+    if (Looper.myLooper() != Looper.getMainLooper()) {
+      post { applyOverlayOpacity() }
+      return
+    }
+    val overlay = heatmapOverlay ?: return
+    val opacityValue = opacity.coerceIn(0.0, 1.0)
+    val transparency = (1.0 - opacityValue).toFloat()
+    runCatching {
+      overlay.javaClass.getMethod("setTransparency", Float::class.javaPrimitiveType)
+        .invoke(overlay, transparency)
+    }
+  }
+
   /**
-   * 创建或更新热力图
+   * 在主线程应用更新（构建 TileProvider 在后台线程）
    */
-  private fun createOrUpdateHeatMap() {
-    aMap?.let { map ->
-      if (dataList.isNotEmpty()) {
-        // 移除旧的热力图
-        heatmapOverlay?.remove()
-        
-        // 创建热力图提供者
-        val builder = HeatmapTileProvider.Builder()
-        builder.data(dataList)
-        builder.radius(radius)
-        
-        // 创建热力图图层
-        val heatmapTileProvider = builder.build()
-        val tileOverlayOptions = TileOverlayOptions()
-          .tileProvider(heatmapTileProvider)
-        
-        heatmapOverlay = map.addTileOverlay(tileOverlayOptions)
-        // 注意：TileOverlay 不支持 transparency 属性，透明度通过 HeatmapTileProvider 控制
+  private fun applyUpdateOnMain() {
+    if (Looper.myLooper() != Looper.getMainLooper()) {
+      post { applyUpdateOnMain() }
+      return
+    }
+
+    val map = aMap ?: return
+    val token = updateToken
+    val pointsSnapshot = ArrayList(dataList)
+    val radiusValue = radius.coerceIn(10, 200)
+    val opacityValue = opacity.coerceIn(0.0, 1.0)
+
+    if (!visible) {
+      applyOverlayVisibility()
+      return
+    }
+
+    if (pointsSnapshot.isEmpty()) {
+      heatmapOverlay?.remove()
+      heatmapOverlay = null
+      return
+    }
+
+    if (heatmapOverlay != null && !needsRebuild) {
+      applyOverlayVisibility()
+      applyOverlayOpacity()
+      return
+    }
+
+    executor.execute {
+      try {
+        val provider = HeatmapTileProvider.Builder()
+          .data(pointsSnapshot)
+          .radius(radiusValue)
+          .build()
+
+        post {
+          if (token != updateToken) {
+            return@post
+          }
+          if (aMap !== map) {
+            return@post
+          }
+          if (!visible) {
+            return@post
+          }
+
+          heatmapOverlay?.remove()
+
+          val options = TileOverlayOptions().tileProvider(provider)
+
+          runCatching {
+            options.javaClass.getMethod("zIndex", Float::class.javaPrimitiveType)
+              .invoke(options, 1f)
+          }
+
+          runCatching {
+            options.javaClass.getMethod("transparency", Float::class.javaPrimitiveType)
+              .invoke(options, (1.0 - opacityValue).toFloat())
+          }
+
+          heatmapOverlay = map.addTileOverlay(options)
+          needsRebuild = false
+          runCatching { heatmapOverlay?.clearTileCache() }
+          applyOverlayVisibility()
+          applyOverlayOpacity()
+          forceRefresh()
+        }
+      } catch (t: Throwable) {
+        Log.e("HeatMapView", "Failed to build heatmap", t)
       }
     }
   }
   
+  private fun forceRefresh() {
+    runCatching { aMap?.moveCamera(CameraUpdateFactory.zoomBy(0f)) }
+  }
+
   /**
    * 移除热力图
    */
   fun removeHeatMap() {
+    updateToken += 1
+    removeCallbacks(applyUpdateRunnable)
     heatmapOverlay?.remove()
     heatmapOverlay = null
     dataList.clear()
+    needsRebuild = true
   }
   
   override fun onDetachedFromWindow() {
@@ -99,6 +230,7 @@ class HeatMapView(context: Context, appContext: AppContext) : ExpoView(context,
       if (parent == null) {
         removeHeatMap()
         aMap = null
+        runCatching { executor.shutdownNow() }
       }
     }
   }

package/android/src/main/java/expo/modules/gaodemap/map/overlays/HeatMapViewModule.kt

@@ -8,12 +8,16 @@ import expo.modules.kotlin.modules.ModuleDefinition
  */
 class HeatMapViewModule : Module() {
   override fun definition() = ModuleDefinition {
-    Name("NaviHeatMapView")
+    Name("HeatMapView")
 
     View(HeatMapView::class) {
-      Prop<List<Map<String, Any>>>("data") { view: HeatMapView, data ->
+      Prop<List<Any>?>("data") { view: HeatMapView, data ->
         view.setData(data)
       }
+
+      Prop<Boolean>("visible") { view: HeatMapView, visible ->
+        view.setVisible(visible)
+      }
       
       Prop<Int>("radius") { view: HeatMapView, radius ->
         view.setRadius(radius)
@@ -22,6 +26,14 @@ class HeatMapViewModule : Module() {
       Prop<Double>("opacity") { view: HeatMapView, opacity ->
         view.setOpacity(opacity)
       }
+
+      Prop<Map<String, Any>?>("gradient") { _: HeatMapView, _ ->
+          // iOS only, ignore on Android
+      }
+
+      Prop<Boolean>("allowRetinaAdapting") { _: HeatMapView, _ ->
+        // iOS only, ignore on Android
+      }
     }
   }
-}
+}