expo-gaode-map 2.2.27-next.0 → 2.2.27

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

@@ -30,38 +30,12 @@ class ExpoGaodeMapModule : Module() {
   override fun definition() = ModuleDefinition {
     Name("ExpoGaodeMap")
 
-    // 在模块加载时尝试从本地缓存恢复隐私同意状态，避免每次启动都必须 JS 调用
-    try {
-      val context = appContext.reactContext!!
-      SDKInitializer.restorePrivacyState(context)
-
-      // 尝试从 AndroidManifest.xml 读取并设置 API Key
-      val apiKey = context.packageManager
-          .getApplicationInfo(context.packageName, android.content.pm.PackageManager.GET_META_DATA)
-          .metaData?.getString("com.amap.api.v2.apikey")
-
-      if (!apiKey.isNullOrEmpty()) {
-          try {
-            MapsInitializer.setApiKey(apiKey)
-            com.amap.api.location.AMapLocationClient.setApiKey(apiKey)
-
-
-            android.util.Log.i(
-              "ExpoGaodeMap",
-              "✅ Android API Key 已加载（core Android 已关闭自动预加载，避免隐藏 MapView 与实际 TextureMapView 并存）"
-            )
-          } catch (e: Exception) {
-            android.util.Log.w("ExpoGaodeMap", "设置 API Key 失败: ${e.message}")
-          }
-        } else {
-          android.util.Log.w("ExpoGaodeMap", "⚠️ AndroidManifest.xml 未找到 API Key")
-        }
-
-    } catch (e: Exception) {
-      android.util.Log.w("ExpoGaodeMap", "恢复隐私状态时出现问题: ${e.message}")
+    OnCreate {
+      appContext.reactContext?.let { context ->
+        SDKInitializer.restorePersistedState(context)
+      }
     }
- 
-  
+
     // ==================== SDK 初始化 ====================
     
     /**
@@ -70,24 +44,51 @@ class ExpoGaodeMapModule : Module() {
      */
     Function("initSDK") { config: Map<String, String> ->
       val androidKey = config["androidKey"]
-      if (androidKey != null) {
-        try {
-          SDKInitializer.initSDK(appContext.reactContext!!, androidKey)
-          getLocationManager() // 初始化定位管理器
-          
-          // 打印当前 SDK 版本信息，便于验证依赖来源
-          android.util.Log.i("ExpoGaodeMap", "✅ SDK 初始化完成 - Version: ${MapsInitializer.getVersion()}")
-
-        } catch (e: SecurityException) {
-          android.util.Log.e("ExpoGaodeMap", "隐私协议未同意: ${e.message}")
-          throw expo.modules.kotlin.exception.CodedException("PRIVACY_NOT_AGREED", e.message ?: "用户未同意隐私协议", e)
-        } catch (e: Exception) {
-          android.util.Log.e("ExpoGaodeMap", "SDK 初始化失败: ${e.message}")
-          throw expo.modules.kotlin.exception.CodedException("INIT_FAILED", e.message ?: "SDK 初始化失败", e)
+      try {
+        val context = appContext.reactContext!!
+        if (androidKey != null) {
+          SDKInitializer.initSDK(context, androidKey)
+        } else if (!SDKInitializer.isPrivacyReady()) {
+          throw expo.modules.kotlin.exception.CodedException(
+            "PRIVACY_NOT_AGREED",
+            "隐私协议未完成确认，请先调用 setPrivacyShow/setPrivacyAgree",
+            null
+          )
+        } else {
+          SDKInitializer.applyPrivacyState(context)
         }
+
+        getLocationManager()
+        android.util.Log.i("ExpoGaodeMap", "✅ SDK 初始化完成 - Version: ${MapsInitializer.getVersion()}")
+      } catch (e: SecurityException) {
+        android.util.Log.e("ExpoGaodeMap", "隐私协议未同意: ${e.message}")
+        throw expo.modules.kotlin.exception.CodedException("PRIVACY_NOT_AGREED", e.message ?: "用户未同意隐私协议", e)
+      } catch (e: Exception) {
+        android.util.Log.e("ExpoGaodeMap", "SDK 初始化失败: ${e.message}")
+        throw expo.modules.kotlin.exception.CodedException("INIT_FAILED", e.message ?: "SDK 初始化失败", e)
       }
     }
 
+    Function("setPrivacyShow") { hasShow: Boolean, hasContainsPrivacy: Boolean ->
+      SDKInitializer.setPrivacyShow(appContext.reactContext!!, hasShow, hasContainsPrivacy)
+    }
+
+    Function("setPrivacyAgree") { hasAgree: Boolean ->
+      SDKInitializer.setPrivacyAgree(appContext.reactContext!!, hasAgree)
+    }
+
+    Function("setPrivacyVersion") { version: String ->
+      SDKInitializer.setPrivacyVersion(appContext.reactContext!!, version)
+    }
+
+    Function("resetPrivacyConsent") {
+      SDKInitializer.resetPrivacyConsent(appContext.reactContext!!)
+    }
+
+    Function("getPrivacyStatus") {
+      SDKInitializer.getPrivacyStatus()
+    }
+
     /**
      * 设置是否加载世界向量地图
      * @param enable 是否开启
@@ -887,7 +888,6 @@ class ExpoGaodeMapModule : Module() {
     OnDestroy {
       locationManager?.destroy()
       locationManager = null
-      MapPreloadManager.cleanup()
     }
   }
 

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

@@ -7,6 +7,8 @@ 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.gaodemap.modules.SDKInitializer
+import expo.modules.kotlin.exception.CodedException
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 
@@ -21,6 +23,42 @@ class ExpoGaodeMapOfflineModule : Module() {
   
   // 线程安全锁
   private val lock = Any()
+
+  private fun createDownloadListener(): OfflineMapManager.OfflineMapDownloadListener {
+    return 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?) {
+      }
+    }
+  }
+
+  private fun getOfflineMapManager(): OfflineMapManager {
+    if (!SDKInitializer.isPrivacyReady()) {
+      throw CodedException(
+        "PRIVACY_NOT_AGREED",
+        "隐私协议未完成确认，请先调用 setPrivacyShow/setPrivacyAgree",
+        null
+      )
+    }
+
+    val reactContext = appContext.reactContext
+      ?: throw CodedException("NO_CONTEXT", "React context not available", null)
+
+    if (offlineMapManager == null) {
+      offlineMapManager = OfflineMapManager(
+        reactContext.applicationContext,
+        createDownloadListener()
+      )
+    }
+
+    return offlineMapManager!!
+  }
   
   override fun definition() = ModuleDefinition {
     Name("ExpoGaodeMapOffline")
@@ -36,25 +74,6 @@ class ExpoGaodeMapOfflineModule : Module() {
       "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
@@ -64,24 +83,24 @@ class ExpoGaodeMapOfflineModule : Module() {
     // ==================== 地图列表管理 ====================
     
     AsyncFunction("getAvailableCities") {
-      val cities = offlineMapManager?.offlineMapCityList ?: emptyList()
+      val cities = getOfflineMapManager().offlineMapCityList ?: emptyList()
       cities.map { city -> convertCityToMap(city) }
     }
     
     AsyncFunction("getAvailableProvinces") {
-      val provinces = offlineMapManager?.offlineMapProvinceList ?: emptyList()
+      val provinces = getOfflineMapManager().offlineMapProvinceList ?: emptyList()
       provinces.map { province -> convertProvinceToMap(province) }
     }
     
     AsyncFunction("getCitiesByProvince") { provinceCode: String ->
-      val province = offlineMapManager?.offlineMapProvinceList?.find { 
+      val province = getOfflineMapManager().offlineMapProvinceList?.find { 
         it.provinceCode == provinceCode 
       }
       province?.cityList?.map { city -> convertCityToMap(city) } ?: emptyList()
     }
     
     AsyncFunction("getDownloadedMaps") {
-      val cities = offlineMapManager?.downloadOfflineMapCityList ?: emptyList()
+      val cities = getOfflineMapManager().downloadOfflineMapCityList ?: emptyList()
       cities.map { city -> convertCityToMap(city) }
     }
     
@@ -95,11 +114,11 @@ class ExpoGaodeMapOfflineModule : Module() {
         downloadingCities.add(cityCode)
         pausedCities.remove(cityCode)
       }
-      offlineMapManager?.downloadByCityCode(cityCode)
+      getOfflineMapManager().downloadByCityCode(cityCode)
     }
     
     AsyncFunction("pauseDownload") { cityCode: String ->
-      val city = offlineMapManager?.getItemByCityCode(cityCode)
+      val city = getOfflineMapManager().getItemByCityCode(cityCode)
       
       synchronized(lock) {
         pausedCities.add(cityCode)
@@ -108,7 +127,7 @@ class ExpoGaodeMapOfflineModule : Module() {
       
       // 使用 pauseByName 暂停指定城市
       city?.city?.let { cityName ->
-        offlineMapManager?.pauseByName(cityName)
+        getOfflineMapManager().pauseByName(cityName)
       }
       
       if (city != null) {
@@ -126,11 +145,11 @@ class ExpoGaodeMapOfflineModule : Module() {
       }
       // Android SDK 没有针对单个城市的恢复方法
       // 需要重新调用 downloadByCityCode 来继续下载
-      offlineMapManager?.downloadByCityCode(cityCode)
+      getOfflineMapManager().downloadByCityCode(cityCode)
     }
     
     AsyncFunction("cancelDownload") { cityCode: String ->
-      val city = offlineMapManager?.getItemByCityCode(cityCode)
+      val city = getOfflineMapManager().getItemByCityCode(cityCode)
       
       synchronized(lock) {
         downloadingCities.remove(cityCode)
@@ -138,7 +157,7 @@ class ExpoGaodeMapOfflineModule : Module() {
       }
       
       // 使用 stop() 停止所有下载(包括队列)
-      offlineMapManager?.stop()
+      getOfflineMapManager().stop()
       
       if (city != null) {
         sendEvent("onDownloadCancelled", Bundle().apply {
@@ -149,11 +168,11 @@ class ExpoGaodeMapOfflineModule : Module() {
     }
     
     AsyncFunction("deleteMap") { cityCode: String ->
-      val city = offlineMapManager?.getItemByCityCode(cityCode)
+      val city = getOfflineMapManager().getItemByCityCode(cityCode)
         ?: throw IllegalArgumentException("City not found: $cityCode")
       
       // 官方文档:remove() 需要传入城市名称,不是城市代码
-      offlineMapManager?.remove(city.city)
+      getOfflineMapManager().remove(city.city)
       
       synchronized(lock) {
         downloadingCities.remove(cityCode)
@@ -165,29 +184,29 @@ class ExpoGaodeMapOfflineModule : Module() {
       synchronized(lock) {
         downloadingCities.add(cityCode)
       }
-      offlineMapManager?.updateOfflineCityByCode(cityCode)
+      getOfflineMapManager().updateOfflineCityByCode(cityCode)
     }
     
     AsyncFunction("checkUpdate") { cityCode: String ->
-      val city = offlineMapManager?.getItemByCityCode(cityCode)
+      val city = getOfflineMapManager().getItemByCityCode(cityCode)
       city?.state == OfflineMapStatus.NEW_VERSION
     }
     
     // ==================== 状态查询 ====================
     
     AsyncFunction("isMapDownloaded") { cityCode: String ->
-      val city = offlineMapManager?.getItemByCityCode(cityCode)
+      val city = getOfflineMapManager().getItemByCityCode(cityCode)
       city?.state == OfflineMapStatus.SUCCESS || 
       city?.state == OfflineMapStatus.CHECKUPDATES
     }
     
     AsyncFunction("getMapStatus") { cityCode: String ->
-      val city = offlineMapManager?.getItemByCityCode(cityCode)
+      val city = getOfflineMapManager().getItemByCityCode(cityCode)
       city?.let { convertCityToMap(it) } ?: Bundle()
     }
     
     AsyncFunction("getTotalProgress") {
-      val downloadedCities = offlineMapManager?.downloadOfflineMapCityList ?: emptyList()
+      val downloadedCities = getOfflineMapManager().downloadOfflineMapCityList ?: emptyList()
       if (downloadedCities.isEmpty()) {
         0.0
       } else {
@@ -204,12 +223,12 @@ class ExpoGaodeMapOfflineModule : Module() {
     
     AsyncFunction("getStorageSize") {
       // 计算所有已下载地图的大小
-      val cities = offlineMapManager?.downloadOfflineMapCityList ?: emptyList()
+      val cities = getOfflineMapManager().downloadOfflineMapCityList ?: emptyList()
       cities.sumOf { it.size }
     }
     
     AsyncFunction("getStorageInfo") {
-      val cities = offlineMapManager?.downloadOfflineMapCityList ?: emptyList()
+      val cities = getOfflineMapManager().downloadOfflineMapCityList ?: emptyList()
       val offlineMapSize = cities.sumOf { it.size }
       
       // 获取存储路径的统计信息
@@ -231,9 +250,9 @@ class ExpoGaodeMapOfflineModule : Module() {
     }
     
     AsyncFunction("clearAllMaps") {
-      offlineMapManager?.downloadOfflineMapCityList?.forEach { city ->
+      getOfflineMapManager().downloadOfflineMapCityList?.forEach { city ->
         // 使用城市名称删除
-        offlineMapManager?.remove(city.city)
+        getOfflineMapManager().remove(city.city)
       }
       synchronized(lock) {
         downloadingCities.clear()
@@ -260,16 +279,16 @@ class ExpoGaodeMapOfflineModule : Module() {
         }
       }
       cityCodes.forEach { cityCode ->
-        offlineMapManager?.downloadByCityCode(cityCode)
+        getOfflineMapManager().downloadByCityCode(cityCode)
       }
     }
     
     AsyncFunction("batchDelete") { cityCodes: List<String> ->
       cityCodes.forEach { cityCode ->
-        val city = offlineMapManager?.getItemByCityCode(cityCode)
+        val city = getOfflineMapManager().getItemByCityCode(cityCode)
         // 使用城市名称删除,不是城市代码
         city?.city?.let { cityName ->
-          offlineMapManager?.remove(cityName)
+          getOfflineMapManager().remove(cityName)
         }
       }
       synchronized(lock) {
@@ -287,18 +306,18 @@ class ExpoGaodeMapOfflineModule : Module() {
         }
       }
       cityCodes.forEach { cityCode ->
-        offlineMapManager?.updateOfflineCityByCode(cityCode)
+        getOfflineMapManager().updateOfflineCityByCode(cityCode)
       }
     }
     
     AsyncFunction("pauseAllDownloads") {
       // pause() 只暂停正在下载的,不包括队列
-      offlineMapManager?.pause()
+      getOfflineMapManager().pause()
       
       synchronized(lock) {
         pausedCities.addAll(downloadingCities)
         downloadingCities.forEach { cityCode ->
-          val city = offlineMapManager?.getItemByCityCode(cityCode)
+          val city = getOfflineMapManager().getItemByCityCode(cityCode)
           if (city != null) {
             sendEvent("onDownloadPaused", Bundle().apply {
               putString("cityCode", cityCode)
@@ -321,7 +340,7 @@ class ExpoGaodeMapOfflineModule : Module() {
           downloadingCities.add(cityCode)
           pausedCities.remove(cityCode)
         }
-        offlineMapManager?.downloadByCityCode(cityCode)
+        getOfflineMapManager().downloadByCityCode(cityCode)
       }
     }
   }
@@ -335,9 +354,10 @@ class ExpoGaodeMapOfflineModule : Module() {
     if (downName == null) return
     
     // downName 可能是城市代码或城市名称,尝试两种方式查找
-    var city = offlineMapManager?.getItemByCityCode(downName)
+    val manager = offlineMapManager ?: return
+    var city = manager.getItemByCityCode(downName)
     if (city == null) {
-      city = offlineMapManager?.offlineMapCityList?.find { it.city == downName }
+      city = manager.offlineMapCityList?.find { it.city == downName }
     }
     
     if (city == null) return
@@ -532,4 +552,4 @@ class ExpoGaodeMapOfflineModule : Module() {
       else -> "not_downloaded"
     }
   }
-}
+}

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

@@ -13,6 +13,7 @@ import expo.modules.kotlin.viewevent.EventDispatcher
 import expo.modules.kotlin.views.ExpoView
 import expo.modules.gaodemap.managers.CameraManager
 import expo.modules.gaodemap.managers.UIManager
+import expo.modules.gaodemap.modules.SDKInitializer
 import expo.modules.gaodemap.overlays.*
 import androidx.core.graphics.createBitmap
 import androidx.core.view.isVisible
@@ -81,9 +82,7 @@ class ExpoGaodeMapView(context: Context, appContext: AppContext) : ExpoView(cont
 
     init {
         try {
-            // 确保隐私合规已设置
-            MapsInitializer.updatePrivacyShow(context, true, true)
-            MapsInitializer.updatePrivacyAgree(context, true)
+            SDKInitializer.applyPrivacyState(context)
 
             // 创建地图视图 - 使用 TextureMapView 以支持截图
             mapView = TextureMapView(context)

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()
+    }
 }