expo-gaode-map 1.2.2 → 1.2.3

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

@@ -14,24 +14,115 @@ import com.amap.api.maps.MapsInitializer
  * - 获取 SDK 版本信息
  */
 object SDKInitializer {
-    
-    /** 隐私协议是否已同意（进程内缓存） */
-    private var privacyAgreed = true
+    private const val PREFS_NAME = "expo_gaodemap_privacy"
+    private const val KEY_PRIVACY_SHOWN = "privacy_shown"
+    private const val KEY_PRIVACY_CONTAINS = "privacy_contains"
+    private const val KEY_PRIVACY_AGREED = "privacy_agreed"
+    private const val KEY_PRIVACY_VERSION = "privacy_version"
+    private const val KEY_AGREED_PRIVACY_VERSION = "agreed_privacy_version"
 
+    private var privacyAgreed = false
+    private var privacyShown = false
+    private var privacyContains = false
+    private var privacyVersion: String? = null
+    private var agreedPrivacyVersion: String? = null
+    private var restoredFromStorage = false
 
-    
-    fun restorePrivacyState(context: Context) {
+    private fun resolveContext(context: Context): Context {
+        return context.applicationContext ?: context
+    }
+
+    private fun prefs(context: Context) =
+        resolveContext(context).getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+
+    fun restorePersistedState(context: Context) {
+        val appContext = resolveContext(context)
+        val preferences = prefs(appContext)
+
+        privacyShown = preferences.getBoolean(KEY_PRIVACY_SHOWN, false)
+        privacyContains = preferences.getBoolean(KEY_PRIVACY_CONTAINS, false)
+        privacyAgreed = preferences.getBoolean(KEY_PRIVACY_AGREED, false)
+        privacyVersion = preferences.getString(KEY_PRIVACY_VERSION, null)
+        agreedPrivacyVersion = preferences.getString(KEY_AGREED_PRIVACY_VERSION, null)
+        restoredFromStorage = true
+
+        if (!privacyVersion.isNullOrEmpty() &&
+            !agreedPrivacyVersion.isNullOrEmpty() &&
+            privacyVersion != agreedPrivacyVersion
+        ) {
+            clearConsentPersistedState(appContext, keepCurrentVersion = true)
+        }
+
+        applyPrivacyState(appContext)
+    }
+
+    fun setPrivacyShow(context: Context, hasShow: Boolean, hasContainsPrivacy: Boolean) {
+        privacyShown = hasShow
+        privacyContains = hasContainsPrivacy
+        val appContext = resolveContext(context)
+        persistState(appContext)
+        applyPrivacyState(appContext)
+    }
+
+    fun setPrivacyAgree(context: Context, hasAgree: Boolean) {
+        privacyAgreed = hasAgree
+        agreedPrivacyVersion = if (hasAgree) privacyVersion else null
+        val appContext = resolveContext(context)
+        persistState(appContext)
+        applyPrivacyState(appContext)
+    }
+
+    fun setPrivacyVersion(context: Context, version: String) {
+        val sanitizedVersion = version.trim().takeIf { it.isNotEmpty() }
+        privacyVersion = sanitizedVersion
+
+        val appContext = resolveContext(context)
+        if (!privacyVersion.isNullOrEmpty() &&
+            !agreedPrivacyVersion.isNullOrEmpty() &&
+            privacyVersion != agreedPrivacyVersion
+        ) {
+            clearConsentPersistedState(appContext, keepCurrentVersion = true)
+        } else {
+            persistState(appContext)
+        }
+
+        applyPrivacyState(appContext)
+    }
+
+    fun resetPrivacyConsent(context: Context) {
+        val appContext = resolveContext(context)
+        clearConsentPersistedState(appContext, keepCurrentVersion = false)
+        applyPrivacyState(appContext)
+    }
+
+    fun applyPrivacyState(context: Context) {
+        val appContext = resolveContext(context)
         try {
-            // 同步到 SDK
-            MapsInitializer.updatePrivacyShow(context, true, true)
-            AMapLocationClient.updatePrivacyShow(context, true, true)
-            MapsInitializer.updatePrivacyAgree(context, privacyAgreed)
-            AMapLocationClient.updatePrivacyAgree(context, privacyAgreed)
+            MapsInitializer.updatePrivacyShow(appContext, privacyShown, privacyContains)
+            AMapLocationClient.updatePrivacyShow(appContext, privacyShown, privacyContains)
+            MapsInitializer.updatePrivacyAgree(appContext, privacyAgreed)
+            AMapLocationClient.updatePrivacyAgree(appContext, privacyAgreed)
         } catch (e: Exception) {
-            android.util.Log.w("ExpoGaodeMap", "恢复隐私状态失败: ${e.message}")
+            android.util.Log.w("ExpoGaodeMap", "同步隐私状态失败: ${e.message}")
         }
     }
 
+    fun isPrivacyReady(): Boolean {
+        return privacyShown && privacyContains && privacyAgreed
+    }
+
+    fun getPrivacyStatus(): Map<String, Any?> {
+        return mapOf(
+            "hasShow" to privacyShown,
+            "hasContainsPrivacy" to privacyContains,
+            "hasAgree" to privacyAgreed,
+            "isReady" to isPrivacyReady(),
+            "privacyVersion" to privacyVersion,
+            "agreedPrivacyVersion" to agreedPrivacyVersion,
+            "restoredFromStorage" to restoredFromStorage,
+        )
+    }
+
     /**
      * 初始化高德地图和定位 SDK
      *
@@ -40,13 +131,19 @@ object SDKInitializer {
      * @throws Exception 初始化失败时抛出异常
      */
     fun initSDK(context: Context, androidKey: String) {
+        val appContext = resolveContext(context)
+        restorePersistedState(appContext)
         // 检查隐私协议状态
-        if (!privacyAgreed) {
-            // 使用 Kotlin 模块的 CodedException，让 JS 能收到标准化异常
-            throw expo.modules.kotlin.exception.CodedException("用户未同意隐私协议，无法初始化 SDK")
+        if (!isPrivacyReady()) {
+            throw expo.modules.kotlin.exception.CodedException(
+                "PRIVACY_NOT_AGREED",
+                "隐私协议未完成确认，请先调用 setPrivacyShow/setPrivacyAgree",
+                null
+            )
         }
         
         try {
+            applyPrivacyState(appContext)
             // 设置 API Key
             MapsInitializer.setApiKey(androidKey)
             AMapLocationClient.setApiKey(androidKey)
@@ -65,4 +162,36 @@ object SDKInitializer {
     fun getVersion(): String {
         return MapsInitializer.getVersion()
     }
+
+    private fun persistState(context: Context) {
+        prefs(context).edit()
+            .putBoolean(KEY_PRIVACY_SHOWN, privacyShown)
+            .putBoolean(KEY_PRIVACY_CONTAINS, privacyContains)
+            .putBoolean(KEY_PRIVACY_AGREED, privacyAgreed)
+            .putString(KEY_PRIVACY_VERSION, privacyVersion)
+            .putString(KEY_AGREED_PRIVACY_VERSION, agreedPrivacyVersion)
+            .apply()
+    }
+
+    private fun clearConsentPersistedState(context: Context, keepCurrentVersion: Boolean) {
+        privacyShown = false
+        privacyContains = false
+        privacyAgreed = false
+        agreedPrivacyVersion = null
+
+        val editor = prefs(context).edit()
+            .putBoolean(KEY_PRIVACY_SHOWN, false)
+            .putBoolean(KEY_PRIVACY_CONTAINS, false)
+            .putBoolean(KEY_PRIVACY_AGREED, false)
+            .remove(KEY_AGREED_PRIVACY_VERSION)
+
+        if (keepCurrentVersion) {
+            editor.putString(KEY_PRIVACY_VERSION, privacyVersion)
+        } else {
+            privacyVersion = null
+            editor.remove(KEY_PRIVACY_VERSION)
+        }
+
+        editor.apply()
+    }
 }

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

@@ -2,7 +2,6 @@ package expo.modules.gaodemap.overlays
 
 import android.annotation.SuppressLint
 import android.content.Context
-import android.util.Log
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
 import android.graphics.Canvas
@@ -64,7 +63,6 @@ class ClusterView(context: Context, appContext: AppContext) : ExpoView(context,
 
   }
   
-  private var rawPoints: List<Map<String, Any>> = emptyList()
   private var clusterItems: List<ClusterItem> = emptyList()
   private var clusters: List<Cluster> = emptyList()
   
@@ -91,6 +89,7 @@ class ClusterView(context: Context, appContext: AppContext) : ExpoView(context,
   private var currentIconDescriptor: BitmapDescriptor? = null
   private var customIconBitmap: Bitmap? = null
   private var pendingIconUri: String? = null
+  private var pendingRetryUpdate: Runnable? = null
   
   // 标记样式是否发生变化，用于强制更新图标
   private var styleChanged = false
@@ -117,7 +116,6 @@ class ClusterView(context: Context, appContext: AppContext) : ExpoView(context,
    * 设置聚合点
    */
   fun setPoints(points: List<Map<String, Any>>) {
-    rawPoints = points
     clusterItems = points.mapNotNull { pointData ->
       LatLngParser.parseLatLng(pointData)?.let { latLng ->
         ClusterItem(latLng, pointData)
@@ -141,7 +139,6 @@ class ClusterView(context: Context, appContext: AppContext) : ExpoView(context,
    * 设置最小聚合数量
    */
   fun setMinClusterSize(size: Int) {
-    Log.d("ClusterView", "setMinClusterSize: $size")
     minClusterSize = size
     updateClusters()
   }
@@ -227,8 +224,8 @@ class ClusterView(context: Context, appContext: AppContext) : ExpoView(context,
                     updateClusters()
                 }
             }
-        } catch (e: Exception) {
-            e.printStackTrace()
+        } catch (_: Exception) {
+            // 忽略异常，保留当前默认图标
         }
     }
   }
@@ -265,6 +262,8 @@ class ClusterView(context: Context, appContext: AppContext) : ExpoView(context,
     }
     currentMarkers.clear()
     bitmapCache.clear()
+    pendingRetryUpdate?.let { mainHandler.removeCallbacks(it) }
+    pendingRetryUpdate = null
   }
   
   /**
@@ -283,7 +282,12 @@ class ClusterView(context: Context, appContext: AppContext) : ExpoView(context,
     }
 
     calculationJob = scope.launch(Dispatchers.Default) {
-      if (clusterItems.isEmpty()) return@launch
+      if (clusterItems.isEmpty()) {
+        withContext(Dispatchers.Main) {
+          renderClusters(emptyList())
+        }
+        return@launch
+      }
       
       // 获取当前比例尺 (米/像素)
       val scalePerPixel = withContext(Dispatchers.Main) {
@@ -296,11 +300,7 @@ class ClusterView(context: Context, appContext: AppContext) : ExpoView(context,
       }
 
       if (scalePerPixel <= 0) {
-          // 比例尺无效，稍后重试
-          withContext(Dispatchers.Main) {
-              Log.w("ClusterView", "Invalid scalePerPixel: $scalePerPixel, retrying...")
-              mainHandler.postDelayed({ updateClusters() }, 500)
-          }
+          scheduleRetryUpdate()
           return@launch
       }
       
@@ -319,6 +319,18 @@ class ClusterView(context: Context, appContext: AppContext) : ExpoView(context,
     }
   }
 
+  private fun scheduleRetryUpdate(delayMs: Long = 500L) {
+    pendingRetryUpdate?.let { mainHandler.removeCallbacks(it) }
+    val retryTask = Runnable {
+      pendingRetryUpdate = null
+      if (aMap != null) {
+        updateClusters()
+      }
+    }
+    pendingRetryUpdate = retryTask
+    mainHandler.postDelayed(retryTask, delayMs)
+  }
+
   private fun buildClustersFromNative(radiusMeters: Double): List<Cluster>? {
     return try {
       val latitudes = DoubleArray(clusterItems.size)
@@ -396,7 +408,6 @@ class ClusterView(context: Context, appContext: AppContext) : ExpoView(context,
    * 使用 Diff 算法优化渲染，避免全量刷新导致的闪烁
    */
   private fun renderClusters(newClusters: List<Cluster>) {
-    Log.d("ClusterView", "renderClusters: count=${newClusters.size}, minClusterSize=$minClusterSize")
     val map = aMap ?: return
     clusters = newClusters
 

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

@@ -0,0 +1,351 @@
+package expo.modules.gaodemap.overlays
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Rect
+import android.os.Handler
+import android.os.Looper
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ImageView
+import android.widget.TextView
+import androidx.core.graphics.createBitmap
+import expo.modules.gaodemap.companion.IconBitmapCache
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import kotlin.text.StringBuilder
+
+internal data class MarkerBitmapSnapshot(
+    val keyPart: String,
+    val width: Int,
+    val height: Int,
+) {
+    val fullCacheKey: String
+        get() = "$keyPart|${width}x${height}"
+}
+
+internal object MarkerBitmapRenderer {
+    fun hasPendingAsyncImageContent(view: View?): Boolean {
+        view ?: return false
+        if (view.visibility != View.VISIBLE) return false
+
+        if (view is ImageView) {
+            val resolvedWidth = view.measuredWidth.takeIf { it > 0 } ?: view.width
+            val resolvedHeight = view.measuredHeight.takeIf { it > 0 } ?: view.height
+            if (resolvedWidth > 0 && resolvedHeight > 0 && view.drawable == null) {
+                return true
+            }
+        }
+
+        if (view is ViewGroup) {
+            for (index in 0 until view.childCount) {
+                if (hasPendingAsyncImageContent(view.getChildAt(index))) {
+                    return true
+                }
+            }
+        }
+
+        return false
+    }
+
+    fun resolveSnapshot(
+        container: ViewGroup,
+        customViewWidth: Int,
+        customViewHeight: Int,
+        cacheKey: String?,
+    ): MarkerBitmapSnapshot? {
+        if (container.childCount == 0) {
+            return null
+        }
+
+        val child = container.getChildAt(0) ?: return null
+        if (hasPendingAsyncImageContent(child)) {
+            return null
+        }
+        val contentView = resolveRenderableContentView(child)
+        val contentBounds = computeContentBounds(child)
+        val measuredWidth =
+            contentBounds?.width()
+                ?: contentView?.measuredWidth
+                ?: child.measuredWidth
+                ?: 0
+        val measuredHeight =
+            contentBounds?.height()
+                ?: contentView?.measuredHeight
+                ?: child.measuredHeight
+                ?: 0
+
+        val finalWidth = if (measuredWidth > 0) measuredWidth else customViewWidth
+        val finalHeight = if (measuredHeight > 0) measuredHeight else customViewHeight
+
+        if (finalWidth <= 0 || finalHeight <= 0) {
+            return null
+        }
+
+        val fingerprint = computeViewFingerprint(container)
+
+        return MarkerBitmapSnapshot(
+            keyPart = cacheKey?.let { "$it|$fingerprint" } ?: fingerprint,
+            width = finalWidth,
+            height = finalHeight,
+        )
+    }
+
+    fun createBitmap(
+        container: ViewGroup,
+        snapshot: MarkerBitmapSnapshot,
+        customViewWidth: Int,
+        customViewHeight: Int,
+        mainHandler: Handler,
+    ): Bitmap? {
+        IconBitmapCache.get(snapshot.fullCacheKey)?.let { return it }
+
+        val bitmap =
+            if (Looper.myLooper() == Looper.getMainLooper()) {
+                renderViewToBitmapInternal(
+                    container = container,
+                    finalWidth = snapshot.width,
+                    finalHeight = snapshot.height,
+                    customViewWidth = customViewWidth,
+                    customViewHeight = customViewHeight,
+                )
+            } else {
+                val latch = CountDownLatch(1)
+                var result: Bitmap? = null
+                mainHandler.post {
+                    try {
+                        result =
+                            renderViewToBitmapInternal(
+                                container = container,
+                                finalWidth = snapshot.width,
+                                finalHeight = snapshot.height,
+                                customViewWidth = customViewWidth,
+                                customViewHeight = customViewHeight,
+                            )
+                    } finally {
+                        latch.countDown()
+                    }
+                }
+                try {
+                    latch.await(200, TimeUnit.MILLISECONDS)
+                } catch (_: InterruptedException) {
+                }
+                result
+            }
+
+        bitmap?.let { IconBitmapCache.put(snapshot.fullCacheKey, it) }
+        return bitmap
+    }
+
+    fun computeContentBounds(view: View?): Rect? {
+        view ?: return null
+        if (view.visibility != View.VISIBLE) return null
+
+        var resolvedBounds: Rect? = null
+
+        if (view is ViewGroup && view.childCount > 0) {
+            for (i in 0 until view.childCount) {
+                val child = view.getChildAt(i) ?: continue
+                val childBounds = computeContentBounds(child) ?: continue
+                val shiftedBounds = Rect(childBounds)
+                shiftedBounds.offset(child.left, child.top)
+                resolvedBounds =
+                    if (resolvedBounds == null) {
+                        shiftedBounds
+                    } else {
+                        Rect(resolvedBounds).apply { union(shiftedBounds) }
+                    }
+            }
+        }
+
+        val hasOwnVisualBounds =
+            view.background != null ||
+                view.paddingLeft != 0 ||
+                view.paddingTop != 0 ||
+                view.paddingRight != 0 ||
+                view.paddingBottom != 0 ||
+                view !is ViewGroup
+
+        val ownWidth = view.measuredWidth.takeIf { it > 0 } ?: view.width
+        val ownHeight = view.measuredHeight.takeIf { it > 0 } ?: view.height
+
+        if (hasOwnVisualBounds && ownWidth > 0 && ownHeight > 0) {
+            val ownBounds = Rect(0, 0, ownWidth, ownHeight)
+            resolvedBounds =
+                if (resolvedBounds == null) {
+                    ownBounds
+                } else {
+                    Rect(resolvedBounds).apply { union(ownBounds) }
+                }
+        }
+
+        return resolvedBounds
+    }
+
+    fun resolveRenderableContentView(view: View?): View? {
+        var current = view ?: return null
+
+        while (current is ViewGroup && current.childCount == 1) {
+            val next = current.getChildAt(0) ?: break
+            current = next
+        }
+
+        return current
+    }
+
+    fun computeViewFingerprint(view: View?): String {
+        if (view == null) return "null"
+
+        val sb = StringBuilder()
+        val tag = view.tag
+        if (tag != null) {
+            sb.append("tag=").append(tag.toString()).append(";")
+            return sb.toString()
+        }
+
+        val contentDesc = view.contentDescription
+        if (!contentDesc.isNullOrEmpty()) {
+            sb.append("cdesc=").append(contentDesc.toString()).append(";")
+            return sb.toString()
+        }
+
+        fun appendFor(v: View) {
+            sb.append(v.javaClass.simpleName)
+            when (v) {
+                is TextView -> {
+                    val text = v.text?.toString() ?: ""
+                    if (text.isNotEmpty()) {
+                        sb.append("[text=").append(text).append("]")
+                    }
+                }
+
+                is ImageView -> {
+                    val resId = v.tag
+                    if (resId is Int && resId != 0) {
+                        sb.append("[imgRes=").append(resId).append("]")
+                    } else {
+                        val drawable = v.drawable
+                        if (drawable != null) {
+                            sb.append("[drawableHash=").append(drawable.hashCode()).append("]")
+                        }
+                    }
+                }
+            }
+            sb.append(";")
+            if (v is ViewGroup) {
+                for (i in 0 until v.childCount) {
+                    appendFor(v.getChildAt(i))
+                }
+            }
+        }
+
+        appendFor(view)
+        return sb.toString().take(1024)
+    }
+
+    private fun renderViewToBitmapInternal(
+        container: ViewGroup,
+        finalWidth: Int,
+        finalHeight: Int,
+        customViewWidth: Int,
+        customViewHeight: Int,
+    ): Bitmap? {
+        try {
+            val childView = container.getChildAt(0) ?: return null
+
+            if (childView.width != finalWidth || childView.height != finalHeight) {
+                if (childView.width == 0 || childView.height == 0) {
+                    return null
+                }
+
+                val widthSpec = View.MeasureSpec.makeMeasureSpec(finalWidth, View.MeasureSpec.EXACTLY)
+                val heightSpec = View.MeasureSpec.makeMeasureSpec(finalHeight, View.MeasureSpec.EXACTLY)
+                childView.measure(widthSpec, heightSpec)
+                childView.layout(0, 0, finalWidth, finalHeight)
+            } else if (childView.left != 0 || childView.top != 0) {
+                childView.layout(0, 0, finalWidth, finalHeight)
+            }
+
+            val bitmap = createBitmap(finalWidth, finalHeight)
+            val canvas = Canvas(bitmap)
+            childView.draw(canvas)
+
+            val shouldTrimTransparentPadding = customViewWidth <= 0 && customViewHeight <= 0
+            return if (shouldTrimTransparentPadding) trimTransparentPadding(bitmap) else bitmap
+        } catch (_: Exception) {
+            return null
+        }
+    }
+
+    private fun trimTransparentPadding(bitmap: Bitmap): Bitmap {
+        if (bitmap.width <= 1 || bitmap.height <= 1) {
+            return bitmap
+        }
+
+        if (hasOpaquePixelsOnAllBitmapEdges(bitmap)) {
+            return bitmap
+        }
+
+        var minX = bitmap.width
+        var minY = bitmap.height
+        var maxX = -1
+        var maxY = -1
+
+        for (y in 0 until bitmap.height) {
+            for (x in 0 until bitmap.width) {
+                if (Color.alpha(bitmap.getPixel(x, y)) != 0) {
+                    if (x < minX) minX = x
+                    if (y < minY) minY = y
+                    if (x > maxX) maxX = x
+                    if (y > maxY) maxY = y
+                }
+            }
+        }
+
+        if (maxX < minX || maxY < minY) {
+            return bitmap
+        }
+
+        val trimmedWidth = maxX - minX + 1
+        val trimmedHeight = maxY - minY + 1
+        if (trimmedWidth == bitmap.width && trimmedHeight == bitmap.height) {
+            return bitmap
+        }
+
+        return Bitmap.createBitmap(bitmap, minX, minY, trimmedWidth, trimmedHeight)
+    }
+
+    private fun hasOpaquePixelsOnAllBitmapEdges(bitmap: Bitmap): Boolean {
+        var topEdgeHasPixel = false
+        var bottomEdgeHasPixel = false
+        var leftEdgeHasPixel = false
+        var rightEdgeHasPixel = false
+
+        for (x in 0 until bitmap.width) {
+            if (!topEdgeHasPixel && Color.alpha(bitmap.getPixel(x, 0)) != 0) {
+                topEdgeHasPixel = true
+            }
+            if (!bottomEdgeHasPixel && Color.alpha(bitmap.getPixel(x, bitmap.height - 1)) != 0) {
+                bottomEdgeHasPixel = true
+            }
+            if (topEdgeHasPixel && bottomEdgeHasPixel) {
+                break
+            }
+        }
+
+        for (y in 0 until bitmap.height) {
+            if (!leftEdgeHasPixel && Color.alpha(bitmap.getPixel(0, y)) != 0) {
+                leftEdgeHasPixel = true
+            }
+            if (!rightEdgeHasPixel && Color.alpha(bitmap.getPixel(bitmap.width - 1, y)) != 0) {
+                rightEdgeHasPixel = true
+            }
+            if (leftEdgeHasPixel && rightEdgeHasPixel) {
+                break
+            }
+        }
+
+        return topEdgeHasPixel && bottomEdgeHasPixel && leftEdgeHasPixel && rightEdgeHasPixel
+    }
+}