expo-gaode-map 2.2.24-next.1 → 2.2.24

package/README.md

@@ -162,9 +162,46 @@ try {
   }
 }
 ```
+### 5. 地图在模拟器上显示异常(可能会出现黑屏或闪退)
+
+建议：
+- 确保在真机上测试，模拟器可能不支持地图功能
+- 检查是否正确配置了 API Key
 
 **完整错误处理指南**：[ERROR_HANDLING_GUIDE.md](./ERROR_HANDLING_GUIDE.md)
 
+### 6. Google Play 版本支持
+
+如果你的应用需要上架 Google Play，需要使用高德地图 Google Play 版本的 SDK（通过了 Google Play 的合规审核）。
+
+#### 步骤 1：下载 SDK
+前往 [高德开放平台](https://lbs.amap.com/api/android-sdk/download) 下载包含 Google Play 版本的 SDK（通常是合包，包含地图、搜索、定位功能）。
+
+#### 步骤 2：放入项目
+将下载的 `.aar` 或 `.jar` 文件放入你的 Expo 项目根目录下的 `libs` 文件夹中（如果没有则创建），例如 `libs/AMap_3DMap_GooglePlay.aar`。
+
+#### 步骤 3：配置插件
+在 `app.json` 中配置 `customMapSdkPath`：
+
+```json
+{
+  "expo": {
+    "plugins": [
+      [
+        "expo-gaode-map",
+        {
+          "androidKey": "your-android-key",
+          "iosKey": "your-ios-key",
+          "customMapSdkPath": "./libs/AMap_3DMap_GooglePlay.aar" 
+        }
+      ]
+    ]
+  }
+}
+```
+
+> **注意**：Google Play 版本的 SDK 通常是合包（包含地图+搜索+定位）。如果你的项目中引入了其他高德相关依赖（如 `expo-gaode-map-search`），可能会导致类冲突。插件会自动处理大部分冲突，但如果依然遇到 `Duplicate class` 错误，请检查是否引入了多余的依赖。
+
 支持的错误类型：
 - `SDK_NOT_INITIALIZED` - SDK 未初始化
 - `INVALID_API_KEY` - API Key 配置错误

package/android/build.gradle

@@ -54,5 +54,29 @@ android {
 
 dependencies {
     // 高德地图 3D SDK
-    implementation ('com.amap.api:3dmap:latest.integration')
+    def customSdkPath = null
+    println "ExpoGaodeMap: Checking for custom SDK property in rootProject: ${rootProject.name}"
+    if (rootProject.hasProperty("EXPO_GAODE_MAP_CUSTOM_SDK_PATH")) {
+        customSdkPath = rootProject.property("EXPO_GAODE_MAP_CUSTOM_SDK_PATH")
+        println "ExpoGaodeMap: Found custom SDK path property: ${customSdkPath}"
+    } else {
+        println "ExpoGaodeMap: No custom SDK path property found."
+    }
+
+    if (customSdkPath) {
+        def sdkFile = rootProject.file(customSdkPath)
+        if (!sdkFile.exists()) {
+            // Try to find the file relative to the project root (parent of android folder)
+            sdkFile = new File(rootProject.projectDir.parentFile, customSdkPath)
+        }
+
+        if (sdkFile.exists()) {
+            println "ExpoGaodeMap: Using custom Map SDK from ${sdkFile.absolutePath}"
+            implementation files(sdkFile)
+        } else {
+            throw new FileNotFoundException("ExpoGaodeMap: Could not find custom SDK at ${customSdkPath}. Please check your customMapSdkPath configuration.")
+        }
+    } else {
+        implementation ('com.amap.api:3dmap:latest.integration')
+    }
 }

package/android/src/main/cpp/cluster_jni.cpp

@@ -11,6 +11,7 @@ typedef void* jstring;
 typedef double jdouble;
 typedef int jint;
 typedef int jsize;
+typedef void* jobjectArray;
 typedef unsigned char jboolean;
 #ifndef JNI_TRUE
 #define JNI_TRUE 1
@@ -232,6 +233,55 @@ Java_expo_modules_gaodemap_utils_GeometryUtils_nativeIsPointInPolygon(
 #endif
 }
 
+extern "C" JNIEXPORT jint JNICALL
+Java_expo_modules_gaodemap_utils_GeometryUtils_nativeFindPointInPolygons(
+    JNIEnv* env,
+    jclass,
+    jdouble pointLat,
+    jdouble pointLon,
+    jobjectArray polygonsLat,
+    jobjectArray polygonsLon
+) {
+#if GAODE_HAVE_JNI
+    if (!polygonsLat || !polygonsLon) return -1;
+
+    const jsize polygonCount = env->GetArrayLength(polygonsLat);
+    if (polygonCount == 0) return -1;
+
+    std::vector<std::vector<gaodemap::GeoPoint>> polygons;
+    polygons.reserve(static_cast<size_t>(polygonCount));
+
+    for (jsize i = 0; i < polygonCount; ++i) {
+        jdoubleArray latArray = (jdoubleArray)env->GetObjectArrayElement(polygonsLat, i);
+        jdoubleArray lonArray = (jdoubleArray)env->GetObjectArrayElement(polygonsLon, i);
+        
+        if (!latArray || !lonArray) continue;
+
+        const jsize pointCount = env->GetArrayLength(latArray);
+        jdouble* latValues = env->GetDoubleArrayElements(latArray, nullptr);
+        jdouble* lonValues = env->GetDoubleArrayElements(lonArray, nullptr);
+
+        std::vector<gaodemap::GeoPoint> polygon;
+        polygon.reserve(static_cast<size_t>(pointCount));
+        for (jsize j = 0; j < pointCount; ++j) {
+            polygon.push_back({latValues[j], lonValues[j]});
+        }
+
+        polygons.push_back(std::move(polygon));
+
+        env->ReleaseDoubleArrayElements(latArray, latValues, JNI_ABORT);
+        env->ReleaseDoubleArrayElements(lonArray, lonValues, JNI_ABORT);
+        env->DeleteLocalRef(latArray);
+        env->DeleteLocalRef(lonArray);
+    }
+
+    return gaodemap::findPointInPolygons(pointLat, pointLon, polygons);
+#else
+    (void)env; (void)pointLat; (void)pointLon; (void)polygonsLat; (void)polygonsLon;
+    return -1;
+#endif
+}
+
 extern "C" JNIEXPORT jdouble JNICALL
 Java_expo_modules_gaodemap_utils_GeometryUtils_nativeCalculatePolygonArea(
     JNIEnv* env,
@@ -668,3 +718,131 @@ Java_expo_modules_gaodemap_utils_GeometryUtils_nativeParsePolyline(
     return nullptr;
 #endif
 }
+
+extern "C" JNIEXPORT jintArray JNICALL
+Java_expo_modules_gaodemap_utils_GeometryUtils_nativeLatLngToTile(
+    JNIEnv* env,
+    jclass,
+    jdouble lat,
+    jdouble lon,
+    jint zoom
+) {
+#if GAODE_HAVE_JNI
+    gaodemap::TileResult result = gaodemap::latLngToTile(lat, lon, zoom);
+    jintArray array = env->NewIntArray(3);
+    jint buffer[3] = {result.x, result.y, result.z};
+    env->SetIntArrayRegion(array, 0, 3, buffer);
+    return array;
+#else
+    (void)env; (void)lat; (void)lon; (void)zoom;
+    return nullptr;
+#endif
+}
+
+extern "C" JNIEXPORT jdoubleArray JNICALL
+Java_expo_modules_gaodemap_utils_GeometryUtils_nativeTileToLatLng(
+    JNIEnv* env,
+    jclass,
+    jint x,
+    jint y,
+    jint zoom
+) {
+#if GAODE_HAVE_JNI
+    gaodemap::GeoPoint result = gaodemap::tileToLatLng(x, y, zoom);
+    jdoubleArray array = env->NewDoubleArray(2);
+    jdouble buffer[2] = {result.lat, result.lon};
+    env->SetDoubleArrayRegion(array, 0, 2, buffer);
+    return array;
+#else
+    (void)env; (void)x; (void)y; (void)zoom;
+    return nullptr;
+#endif
+}
+
+extern "C" JNIEXPORT jdoubleArray JNICALL
+Java_expo_modules_gaodemap_utils_GeometryUtils_nativeLatLngToPixel(
+    JNIEnv* env,
+    jclass,
+    jdouble lat,
+    jdouble lon,
+    jint zoom
+) {
+#if GAODE_HAVE_JNI
+    gaodemap::PixelResult result = gaodemap::latLngToPixel(lat, lon, zoom);
+    jdoubleArray array = env->NewDoubleArray(2);
+    jdouble buffer[2] = {result.x, result.y};
+    env->SetDoubleArrayRegion(array, 0, 2, buffer);
+    return array;
+#else
+    (void)env; (void)lat; (void)lon; (void)zoom;
+    return nullptr;
+#endif
+}
+
+extern "C" JNIEXPORT jdoubleArray JNICALL
+Java_expo_modules_gaodemap_utils_GeometryUtils_nativePixelToLatLng(
+    JNIEnv* env,
+    jclass,
+    jdouble x,
+    jdouble y,
+    jint zoom
+) {
+#if GAODE_HAVE_JNI
+    gaodemap::GeoPoint result = gaodemap::pixelToLatLng(x, y, zoom);
+    jdoubleArray array = env->NewDoubleArray(2);
+    jdouble buffer[2] = {result.lat, result.lon};
+    env->SetDoubleArrayRegion(array, 0, 2, buffer);
+    return array;
+#else
+    (void)env; (void)x; (void)y; (void)zoom;
+    return nullptr;
+#endif
+}
+
+extern "C" JNIEXPORT jdoubleArray JNICALL
+Java_expo_modules_gaodemap_utils_GeometryUtils_nativeGenerateHeatmapGrid(
+    JNIEnv* env,
+    jclass,
+    jdoubleArray latitudes,
+    jdoubleArray longitudes,
+    jdoubleArray weights,
+    jdouble gridSizeMeters
+) {
+#if GAODE_HAVE_JNI
+    if (!latitudes || !longitudes || !weights) return nullptr;
+    const jsize count = env->GetArrayLength(latitudes);
+    if (count == 0 || count != env->GetArrayLength(longitudes) || count != env->GetArrayLength(weights)) {
+        return nullptr;
+    }
+
+    jdouble* latVals = env->GetDoubleArrayElements(latitudes, nullptr);
+    jdouble* lonVals = env->GetDoubleArrayElements(longitudes, nullptr);
+    jdouble* weightVals = env->GetDoubleArrayElements(weights, nullptr);
+
+    std::vector<gaodemap::HeatmapPoint> points;
+    points.reserve(count);
+    for (jsize i = 0; i < count; ++i) {
+        points.push_back({latVals[i], lonVals[i], weightVals[i]});
+    }
+
+    env->ReleaseDoubleArrayElements(latitudes, latVals, JNI_ABORT);
+    env->ReleaseDoubleArrayElements(longitudes, lonVals, JNI_ABORT);
+    env->ReleaseDoubleArrayElements(weights, weightVals, JNI_ABORT);
+
+    auto cells = gaodemap::generateHeatmapGrid(points, gridSizeMeters);
+    
+    jdoubleArray result = env->NewDoubleArray(static_cast<jsize>(cells.size() * 3));
+    std::vector<double> buffer;
+    buffer.reserve(cells.size() * 3);
+    for (const auto& c : cells) {
+        buffer.push_back(c.lat);
+        buffer.push_back(c.lon);
+        buffer.push_back(c.intensity);
+    }
+    env->SetDoubleArrayRegion(result, 0, static_cast<jsize>(buffer.size()), buffer.data());
+    return result;
+#else
+    (void)env; (void)latitudes; (void)longitudes; (void)weights; (void)gridSizeMeters;
+    return nullptr;
+#endif
+}

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

@@ -79,6 +79,9 @@ class ExpoGaodeMapModule : Module() {
           SDKInitializer.initSDK(appContext.reactContext!!, androidKey)
           getLocationManager() // 初始化定位管理器
           
+          // 打印当前 SDK 版本信息，便于验证依赖来源
+          android.util.Log.i("ExpoGaodeMap", "✅ SDK 初始化完成 - Version: ${MapsInitializer.getVersion()}")
+
           // 初始化成功后自动触发一次预加载
           MapPreloadManager.startPreload(appContext.reactContext!!, poolSize = 1)
         } catch (e: SecurityException) {
@@ -451,6 +454,121 @@ class ExpoGaodeMapModule : Module() {
       }
     }
 
+    /**
+     * 经纬度转瓦片坐标
+     * @param coordinate 坐标
+     * @param zoom 缩放级别
+     * @return 瓦片坐标 [x, y]
+     */
+    Function("latLngToTile") { coordinate: Map<String, Any>?, zoom: Int ->
+      val latLng = LatLngParser.parseLatLng(coordinate)
+      if (latLng != null) {
+        val result = GeometryUtils.latLngToTile(latLng, zoom)
+        if (result != null && result.size >= 2) {
+          mapOf("x" to result[0], "y" to result[1])
+        } else {
+          null
+        }
+      } else {
+        null
+      }
+    }
+
+    /**
+     * 瓦片坐标转经纬度
+     * @param tile 瓦片坐标 {x, y, z}
+     * @return 坐标
+     */
+    Function("tileToLatLng") { tile: Map<String, Any>? ->
+      val x = (tile?.get("x") as? Number)?.toInt() ?: 0
+      val y = (tile?.get("y") as? Number)?.toInt() ?: 0
+      val zoom = (tile?.get("z") as? Number)?.toInt() ?: (tile?.get("zoom") as? Number)?.toInt() ?: 0
+      val result = GeometryUtils.tileToLatLng(x, y, zoom)
+      result?.let {
+        mapOf("latitude" to it.latitude, "longitude" to it.longitude)
+      }
+    }
+
+    /**
+     * 经纬度转像素坐标
+     * @param coordinate 坐标
+     * @param zoom 缩放级别
+     * @return 像素坐标 [x, y]
+     */
+    Function("latLngToPixel") { coordinate: Map<String, Any>?, zoom: Int ->
+      val latLng = LatLngParser.parseLatLng(coordinate)
+      if (latLng != null) {
+        val result = GeometryUtils.latLngToPixel(latLng, zoom)
+        if (result != null && result.size >= 2) {
+          mapOf("x" to result[0], "y" to result[1])
+        } else {
+          null
+        }
+      } else {
+        null
+      }
+    }
+
+    /**
+     * 像素坐标转经纬度
+     * @param pixel 像素坐标 {x, y}
+     * @param zoom 缩放级别
+     * @return 坐标
+     */
+    Function("pixelToLatLng") { pixel: Map<String, Any>?, zoom: Int ->
+      val x = (pixel?.get("x") as? Number)?.toDouble() ?: 0.0
+      val y = (pixel?.get("y") as? Number)?.toDouble() ?: 0.0
+      val result = GeometryUtils.pixelToLatLng(x, y, zoom)
+      result?.let {
+        mapOf("latitude" to it.latitude, "longitude" to it.longitude)
+      }
+    }
+
+    /**
+     * 批量判断点在哪个多边形内
+     * @param point 待判断点
+     * @param polygons 多边形列表
+     * @return 所在多边形的索引，不在任何多边形内返回 -1
+     */
+    Function("findPointInPolygons") { point: Map<String, Any>?, polygons: List<List<Any>>? ->
+      val pt = LatLngParser.parseLatLng(point)
+      val polys = polygons?.map { LatLngParser.parseLatLngList(it) }
+      if (pt != null && polys != null) {
+        GeometryUtils.findPointInPolygons(pt, polys)
+      } else {
+        -1
+      }
+    }
+
+    /**
+     * 生成网格聚合数据 (常用于展示网格聚合图或大规模点数据处理)
+     * @param points 包含经纬度和权重的点数组
+     * @param gridSizeMeters 网格大小（米）
+     */
+    Function("generateHeatmapGrid") { points: List<Map<String, Any>>?, gridSizeMeters: Double ->
+      if (points == null || points.isEmpty()) return@Function emptyList<Map<String, Any>>()
+      
+      val count = points.size
+      val latitudes = DoubleArray(count)
+      val longitudes = DoubleArray(count)
+      val weights = DoubleArray(count)
+      
+      points.forEachIndexed { index, map ->
+        latitudes[index] = (map["latitude"] as? Number)?.toDouble() ?: 0.0
+        longitudes[index] = (map["longitude"] as? Number)?.toDouble() ?: 0.0
+        weights[index] = (map["weight"] as? Number)?.toDouble() ?: 1.0
+      }
+      
+      val result = GeometryUtils.generateHeatmapGrid(latitudes, longitudes, weights, gridSizeMeters)
+      result.map {
+        mapOf(
+          "latitude" to it.latitude,
+          "longitude" to it.longitude,
+          "intensity" to it.intensity
+        )
+      }
+    }
+
     // ==================== 定位配置 ====================
 
     /**

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

@@ -446,9 +446,9 @@ class ExpoGaodeMapOfflineModule : Module() {
       putString("cityName", city.city)
       putLong("size", city.size)
       putString("status", status)
-      putInt("progress", city.getcompleteCode())
+      putInt("progress", getDownloadProgress(city))
       putString("version", city.version)
-      putLong("downloadedSize", (city.size * city.getcompleteCode() / 100))
+      putLong("downloadedSize", (city.size * getDownloadProgress(city) / 100))
     }
   }
   
@@ -461,12 +461,54 @@ class ExpoGaodeMapOfflineModule : Module() {
       putString("cityName", province.provinceName)
       putLong("size", province.size)
       putString("status", getStatusString(province.state))
-      putInt("progress", province.getcompleteCode())
+      putInt("progress", getDownloadProgress(province))
       putString("version", province.version)
       putString("provinceName", province.provinceName)
       putString("provinceCode", province.provinceCode)
     }
   }
+
+  /**
+   * 兼容获取 START_DOWNLOAD_FAILED 状态码
+   * 国内版拼写为 START_DOWNLOAD_FAILD，Google Play 版修正为 START_DOWNLOAD_FAILED
+   */
+  private val startDownloadFailedCode: Int by lazy {
+    try {
+      OfflineMapStatus::class.java.getField("START_DOWNLOAD_FAILED").getInt(null)
+    } catch (e: Exception) {
+      try {
+        OfflineMapStatus::class.java.getField("START_DOWNLOAD_FAILD").getInt(null)
+      } catch (e2: Exception) {
+        -1
+      }
+    }
+  }
+
+  /**
+   * 兼容获取下载进度
+   * Google Play 版本 SDK 可能修复了 getcompleteCode 的命名或使用了不同的 API
+   */
+  private fun getDownloadProgress(obj: Any): Int {
+    try {
+      // 尝试标准版的命名 (getcompleteCode)
+      val method = obj.javaClass.getMethod("getcompleteCode")
+      return method.invoke(obj) as Int
+    } catch (e: Exception) {
+      try {
+        // 尝试修正后的命名 (getCompleteCode) - Google Play 版本可能使用此命名
+        val method = obj.javaClass.getMethod("getCompleteCode")
+        return method.invoke(obj) as Int
+      } catch (e2: Exception) {
+        // 如果都失败了，尝试直接访问 completeCode 字段
+         try {
+             val field = obj.javaClass.getField("completeCode")
+             return field.getInt(obj)
+         } catch (e3: Exception) {
+             return 0
+         }
+      }
+    }
+  }
   
   /**
    * 获取状态字符串
@@ -484,7 +526,7 @@ class ExpoGaodeMapOfflineModule : Module() {
       OfflineMapStatus.EXCEPTION_NETWORK_LOADING -> "downloading"  // 网络问题,可继续
       OfflineMapStatus.EXCEPTION_AMAP -> "failed"  // 认证异常
       OfflineMapStatus.EXCEPTION_SDCARD -> "failed"  // SD卡异常
-      OfflineMapStatus.START_DOWNLOAD_FAILD -> "failed"  // 开始下载失败
+      startDownloadFailedCode -> "failed"  // 兼容两种拼写的开始下载失败
       OfflineMapStatus.CHECKUPDATES -> "not_downloaded"
       OfflineMapStatus.NEW_VERSION -> "not_downloaded"
       else -> "not_downloaded"

package/android/src/main/java/expo/modules/gaodemap/utils/GeometryUtils.kt

@@ -89,6 +89,44 @@ object GeometryUtils {
         precision: Int
     ): String
 
+    private external fun nativeLatLngToTile(
+        lat: Double,
+        lon: Double,
+        zoom: Int
+    ): IntArray
+
+    private external fun nativeTileToLatLng(
+        x: Int,
+        y: Int,
+        zoom: Int
+    ): DoubleArray
+
+    private external fun nativeLatLngToPixel(
+        lat: Double,
+        lon: Double,
+        zoom: Int
+    ): DoubleArray
+
+    private external fun nativePixelToLatLng(
+        x: Double,
+        y: Double,
+        zoom: Int
+    ): DoubleArray
+
+    private external fun nativeFindPointInPolygons(
+        pointLat: Double,
+        pointLon: Double,
+        polygons: Array<DoubleArray>,
+        polygonsLon: Array<DoubleArray>
+    ): Int
+
+    private external fun nativeGenerateHeatmapGrid(
+        latitudes: DoubleArray,
+        longitudes: DoubleArray,
+        weights: DoubleArray,
+        gridSizeMeters: Double
+    ): DoubleArray
+
     /**
      * 判断点是否在圆内
      * @param point 要判断的点
@@ -396,4 +434,82 @@ object GeometryUtils {
     private external fun nativeParsePolyline(
         polylineStr: String
     ): DoubleArray?
+
+    fun latLngToTile(latLng: LatLng, zoom: Int): IntArray? {
+        return try {
+            nativeLatLngToTile(latLng.latitude, latLng.longitude, zoom)
+        } catch (_: Throwable) {
+            null
+        }
+    }
+
+    fun tileToLatLng(x: Int, y: Int, zoom: Int): LatLng? {
+        return try {
+            val result = nativeTileToLatLng(x, y, zoom)
+            if (result != null && result.size >= 2) {
+                LatLng(result[0], result[1])
+            } else {
+                null
+            }
+        } catch (_: Throwable) {
+            null
+        }
+    }
+
+    fun latLngToPixel(latLng: LatLng, zoom: Int): DoubleArray? {
+        return try {
+            nativeLatLngToPixel(latLng.latitude, latLng.longitude, zoom)
+        } catch (_: Throwable) {
+            null
+        }
+    }
+
+    fun pixelToLatLng(x: Double, y: Double, zoom: Int): LatLng? {
+        return try {
+            val result = nativePixelToLatLng(x, y, zoom)
+            if (result != null && result.size >= 2) {
+                LatLng(result[0], result[1])
+            } else {
+                null
+            }
+        } catch (_: Throwable) {
+            null
+        }
+    }
+
+    fun findPointInPolygons(point: LatLng, polygons: List<List<LatLng>>): Int {
+        if (polygons.isEmpty()) return -1
+        return try {
+            val polygonsLat = Array(polygons.size) { i ->
+                DoubleArray(polygons[i].size) { j -> polygons[i][j].latitude }
+            }
+            val polygonsLon = Array(polygons.size) { i ->
+                DoubleArray(polygons[i].size) { j -> polygons[i][j].longitude }
+            }
+            nativeFindPointInPolygons(point.latitude, point.longitude, polygonsLat, polygonsLon)
+        } catch (_: Throwable) {
+            -1
+        }
+    }
+
+    data class HeatmapGridCell(val latitude: Double, val longitude: Double, val intensity: Double)
+
+    fun generateHeatmapGrid(
+        latitudes: DoubleArray,
+        longitudes: DoubleArray,
+        weights: DoubleArray,
+        gridSizeMeters: Double
+    ): List<HeatmapGridCell> {
+        if (latitudes.isEmpty() || latitudes.size != longitudes.size || latitudes.size != weights.size) return emptyList()
+        return try {
+            val result = nativeGenerateHeatmapGrid(latitudes, longitudes, weights, gridSizeMeters)
+            val cells = mutableListOf<HeatmapGridCell>()
+            for (i in result.indices step 3) {
+                cells.add(HeatmapGridCell(result[i], result[i+1], result[i+2]))
+            }
+            cells
+        } catch (_: Throwable) {
+            emptyList()
+        }
+    }
 }

package/build/ExpoGaodeMapModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoGaodeMapModule.d.ts","sourceRoot":"","sources":["../src/ExpoGaodeMapModule.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEtE,OAAO,EAAE,SAAS,EAAoB,MAAM,sBAAsB,CAAC;AAwhBnE;;EAEE;AACF,wBAAgB,YAAY,IAAI,SAAS,GAAG,IAAI,CAE/C;AAED;;EAEE;AACF,wBAAgB,SAAS,IAAI,MAAM,GAAG,SAAS,CAE9C;wBAE0D,kBAAkB;AAA7E,wBAA8E"}
+{"version":3,"file":"ExpoGaodeMapModule.d.ts","sourceRoot":"","sources":["../src/ExpoGaodeMapModule.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEtE,OAAO,EAAE,SAAS,EAAoB,MAAM,sBAAsB,CAAC;AAopBnE;;EAEE;AACF,wBAAgB,YAAY,IAAI,SAAS,GAAG,IAAI,CAE/C;AAED;;EAEE;AACF,wBAAgB,SAAS,IAAI,MAAM,GAAG,SAAS,CAE9C;wBAE0D,kBAAkB;AAA7E,wBAA8E"}