capacitor-baidu-location 0.0.6 → 1.0.0

package/README.md

@@ -1,6 +1,6 @@
 # Capacitor Baidu Location Plugin
 
-一个支持 Capacitor 7 的百度地图定位插件，提供全平台百度定位的功能。
+一个支持 Capacitor 7 的百度地图定位插件，iOS 使用 cocoapods 集成，Android 使用 gradle 集成。
 
 ## 功能特性
 
@@ -20,6 +20,7 @@ npx cap sync
 ## 开发依赖
 
 ### Android 开发依赖
+
 - Java版本 : 21
 - Kotlin版本 : 1.9.25
 - Gradle版本 : 8.7.2
@@ -27,11 +28,13 @@ npx cap sync
 - 第三方库 : OkHttp3 3.14.9
 
 ### iOS 开发依赖
+
 - Xcode 16 +
-- Swift 5.9 +
+- Swift 5.1 +
 - iOS 14 +
 
 ### Capacitor
+
 - TypeScript 5.1+
 - Capacitor 7.+
 - NodeJS 20+
@@ -43,6 +46,7 @@ npx cap sync
 插件支持读取配置，这是推荐的配置方式，便于集中管理和构建时配置。web端则直接通过api设置，因为无法在web端读取capacitor配置的内容。
 
 **capacitor.config.ts**
+
 ```typescript
 import { CapacitorConfig } from '@capacitor/cli';
 
@@ -66,6 +70,7 @@ export default config;
      - **方式二：配置文件设置**：在 `capacitor.config.ts` 中配置 `androidAK` ，之后一样要调用 `setAK` 方法，只是不需要传参.
 
 **注意：AndroidManifest.xml 需要配置占位值**：
+
 ```xml
 <application>
     <meta-data
@@ -74,8 +79,9 @@ export default config;
 </application>
 ```
 
-2. **权限配置**
-使用定位SDK，需在AndroidManifest.xml文件中Application标签中声明service组件，每个App拥有自己单独的定位service，代码如下：
+1. **权限配置**
+   使用定位SDK，需在AndroidManifest.xml文件中Application标签中声明service组件，每个App拥有自己单独的定位service，代码如下：
+
 ```xml
 <application>
     <service android:name="com.baidu.location.f"
@@ -85,6 +91,7 @@ export default config;
 ```
 
 除添加service组件外，使用定位SDK还需添加如下权限：
+
 ```xml
 <!-- 这个权限用于进行网络定位-->
 <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"></uses-permission>
@@ -108,9 +115,9 @@ export default config;
    - 百度地图 API Key 可以通过2种方式配置（优先级从高到低）：
      - **方式一：动态设置**：在应用代码中调用 `setAK` 方法设置
      - **方式二：配置文件设置**：在 `capacitor.config.ts` 中配置 `iOSAK` ，之后一样要调用 `setAK` 方法，只是不需要传参.
-
 2. **权限配置**
-在 `Info.plist` 文件中添加以下权限描述：
+   在 `Info.plist` 文件中添加以下权限描述：
+
 ```xml
 <key>NSLocationWhenInUseUsageDescription</key>
 <string>需要获取您的位置信息</string>
@@ -132,17 +139,20 @@ export default config;
 设置百度地图 API Key。可以覆盖配置文件中的设置，优先级最高。
 
 **参数**
-| 参数 | 类型 | 描述 |
-|------|------|------|
+
+| 参数   | 类型       | 描述               |
+| ---- | -------- | ---------------- |
 | `ak` | `string` | 百度定位的各平台 API Key |
 
 **返回值**
-| 字段 | 类型 | 描述 |
-|------|------|------|
-| `success` | `boolean` | 设置是否成功 |
-| `errorMessage` | `string` | 错误信息（如果失败） |
+
+| 字段             | 类型        | 描述         |
+| -------------- | --------- | ---------- |
+| `success`      | `boolean` | 设置是否成功     |
+| `errorMessage` | `string`  | 错误信息（如果失败） |
 
 **说明**
+
 - 调用此方法会覆盖配置文件中的 AK 设置
 - 可以在应用运行时动态切换 AK
 
@@ -151,18 +161,20 @@ export default config;
 检查 API Key 验证状态。
 
 **返回值**
-| 字段 | 类型 | 描述 |
-|------|------|------|
-| `valid` | `boolean` | AK 是否有效 |
-| `errorMessage` | `string` | 错误信息（如果无效） |
+
+| 字段             | 类型        | 描述         |
+| -------------- | --------- | ---------- |
+| `valid`        | `boolean` | AK 是否有效    |
+| `errorMessage` | `string`  | 错误信息（如果无效） |
 
 ### `checkPermission()`
 
 检查定位权限状态。
 
 **返回值**
-| 字段 | 类型 | 描述 |
-|------|------|------|
+
+| 字段        | 类型        | 描述      |
+| --------- | --------- | ------- |
 | `granted` | `boolean` | 权限是否已授予 |
 
 ### `requestPermission()`
@@ -170,8 +182,9 @@ export default config;
 请求定位权限。
 
 **返回值**
-| 字段 | 类型 | 描述 |
-|------|------|------|
+
+| 字段        | 类型        | 描述      |
+| --------- | --------- | ------- |
 | `granted` | `boolean` | 权限是否已授予 |
 
 ### `setCoordinateType(options)`
@@ -179,13 +192,15 @@ export default config;
 设置坐标类型。
 
 **参数**
-| 参数 | 类型 | 描述 |
-|------|------|------|
+
+| 参数     | 类型               | 描述   |
+| ------ | ---------------- | ---- |
 | `type` | `CoordinateType` | 坐标类型 |
 
 **返回值**
-| 字段 | 类型 | 描述 |
-|------|------|------|
+
+| 字段        | 类型        | 描述     |
+| --------- | --------- | ------ |
 | `success` | `boolean` | 设置是否成功 |
 
 ### `getCoordinateType()`
@@ -193,8 +208,9 @@ export default config;
 获取当前坐标类型。
 
 **返回值**
-| 字段 | 类型 | 描述 |
-|------|------|------|
+
+| 字段     | 类型               | 描述     |
+| ------ | ---------------- | ------ |
 | `type` | `CoordinateType` | 当前坐标类型 |
 
 ### `getCurrentPosition(options?)`
@@ -202,37 +218,39 @@ export default config;
 获取当前位置信息。
 
 **参数**
-| 参数 | 类型 | 描述 | 默认值 |
-|------|------|------|--------|
-| `needAddress` | `boolean` | 是否获取地址信息 | `false` |
+
+| 参数                     | 类型        | 描述       | 默认值     |
+| ---------------------- | --------- | -------- | ------- |
+| `needAddress`          | `boolean` | 是否获取地址信息 | `false` |
 | `needLocationDescribe` | `boolean` | 是否获取位置描述 | `false` |
 
 **返回值**
-| 字段 | 类型 | 描述 |
-|------|------|------|
-| `latitude` | `number` | 纬度 |
-| `longitude` | `number` | 经度 |
-| `accuracy` | `number` | 定位精度（米） |
-| `address` | `string` | 完整地址 |
-| `country` | `string` | 国家 |
-| `province` | `string` | 省份 |
-| `city` | `string` | 城市 |
-| `district` | `string` | 区县 |
-| `street` | `string` | 街道 |
-| `adcode` | `string` | 行政区划代码 |
-| `town` | `string` | 乡镇 |
-| `locationDescribe` | `string` | 位置描述 |
-| `errorCode` | `number` | 错误码 |
-| `errorMessage` | `string` | 错误信息 |
+
+| 字段                 | 类型       | 描述      |
+| ------------------ | -------- | ------- |
+| `latitude`         | `number` | 纬度      |
+| `longitude`        | `number` | 经度      |
+| `accuracy`         | `number` | 定位精度（米） |
+| `address`          | `string` | 完整地址    |
+| `country`          | `string` | 国家      |
+| `province`         | `string` | 省份      |
+| `city`             | `string` | 城市      |
+| `district`         | `string` | 区县      |
+| `street`           | `string` | 街道      |
+| `adcode`           | `string` | 行政区划代码  |
+| `town`             | `string` | 乡镇      |
+| `locationDescribe` | `string` | 位置描述    |
+| `errorCode`        | `number` | 错误码     |
+| `errorMessage`     | `string` | 错误信息    |
 
 ### `CoordinateType` 枚举
 
-| 枚举值 | 描述 |
-|--------|------|
-| `BD09LL` | 百度经纬度坐标 |
+| 枚举值      | 描述        |
+| -------- | --------- |
+| `BD09LL` | 百度经纬度坐标   |
 | `BD09MC` | 百度墨卡托米制坐标 |
-| `GCJ02` | 国测局坐标 |
-| `WGS84` | WGS84坐标 |
+| `GCJ02`  | 国测局坐标     |
+| `WGS84`  | WGS84坐标   |
 
 ## 使用示例
 
@@ -330,11 +348,9 @@ const getCurrentCoordinateType = async () => {
    - 请确保在 [百度地图开放平台](https://lbs.baidu.com/) 申请了正确的 API Key
    - Android、iOS、web 端需要分别申请不同的 API Key
    - 确保 API Key 已启用定位服务
-
 2. **权限管理**：
    - 定位功能需要用户授权
    - 请在适当的时机检查和请求权限
-
 3. **网络连接**：
    - 获取地址信息和位置描述需要网络连接
    - 基础定位功能可以在离线状态下使用
@@ -352,15 +368,19 @@ const getCurrentCoordinateType = async () => {
 ## 故障排除
 
 ### API Key 设置失败
+
 **问题**：调用 `setAK` 方法返回失败
 **解决方案**：
+
 - 检查 API Key 是否正确
 - 检查网络连接是否正常
 - 确保 API Key 已在百度地图开放平台启用
 
 ### 权限请求失败
+
 **问题**：用户拒绝了定位权限
 **解决方案**：
+
 - 提示用户定位权限的重要性
 - 引导用户在系统设置中手动开启权限
 - 优雅处理无权限的情况
@@ -371,3 +391,4 @@ const getCurrentCoordinateType = async () => {
 - [百度地图 Android 定位 SDK 文档](https://lbs.baidu.com/faq/api?title=android-locsdk/guide/get-location/latlng)
 - [百度地图 iOS 定位 SDK 文档](https://lbs.baidu.com/faq/api?title=ios-locsdk/guide/get-location/once)
 - [Capacitor 插件开发指南](https://capacitorjs.com/docs/plugins)
+

package/android/build.gradle

@@ -14,6 +14,8 @@ buildscript {
     repositories {
         google()
         mavenCentral()
+        maven { url "https://maven.aliyun.com/repository/google" }
+        maven { url "https://maven.aliyun.com/repository/jcenter" }
     }
     dependencies {
         classpath 'com.android.tools.build:gradle:8.7.2'
@@ -21,6 +23,16 @@ buildscript {
     }
 }
 
+// 配置所有项目的仓库
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+        maven { url "https://maven.aliyun.com/repository/google" }
+        maven { url "https://maven.aliyun.com/repository/jcenter" }
+    }
+}
+
 apply plugin: 'com.android.library'
 apply plugin: 'org.jetbrains.kotlin.android'
 
@@ -54,16 +66,11 @@ android {
     kotlinOptions {
         jvmTarget = "21"
     }
-    sourceSets {
-        main {
-            jniLibs.srcDirs = ['libs']
-        }
-    }
 }
 
 dependencies {
-    // 本地AAR依赖（必须用implementation，确保传递到宿主）
-    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    // 百度定位SDK - 通过Gradle集成
+    implementation 'com.baidu.lbsyun:BaiduMapSDK_Location_All:9.6.4'
     implementation project(':capacitor-android')
     implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
     testImplementation "junit:junit:$junitVersion"

package/android/src/main/kotlin/com/hybrid/baidu/location/CPBaiduLocation.kt

@@ -1,6 +1,8 @@
 package com.hybrid.baidu.location
 
 import android.content.Context
+import android.os.Handler
+import android.os.Looper
 import android.util.Log
 import androidx.annotation.NonNull
 import com.baidu.location.BDAbstractLocationListener
@@ -8,8 +10,6 @@ import com.baidu.location.BDLocation
 import com.baidu.location.LocationClient
 import com.baidu.location.LocationClientOption
 import com.getcapacitor.Logger
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.TimeUnit
 
 /**
  * 百度地图定位插件Android端实现类
@@ -33,11 +33,6 @@ class CPBaiduLocation(private val context: Context, private val config: CPBaiduL
      */
     private var mLocation: BDLocation? = null
 
-    /**
-     * 用于等待定位结果的同步锁
-     */
-    private var latch: CountDownLatch? = null
-
     /**
      * 坐标类型
      */
@@ -61,6 +56,24 @@ class CPBaiduLocation(private val context: Context, private val config: CPBaiduL
         fun onValidationResult(success: Boolean, errorCode: Int, errorMessage: String)
     }
 
+    /**
+     * 定位结果回调接口
+     */
+    interface LocationCallback {
+        /**
+         * 定位成功回调
+         * @param location 定位结果
+         */
+        fun onSuccess(location: BDLocation)
+        
+        /**
+         * 定位失败回调
+         * @param errorCode 错误码
+         * @param errorMessage 错误信息
+         */
+        fun onError(errorCode: Int, errorMessage: String)
+    }
+
     init {
         Log.i(TAG, "getLocationClient: " + getLocationClient())
     }
@@ -85,8 +98,6 @@ class CPBaiduLocation(private val context: Context, private val config: CPBaiduL
         }
         // 存储API Key
         this.ak = realAk
-        // 自动设置同意隐私协议
-        LocationClient.setAgreePrivacy(true)
         // 设置AK
         LocationClient.setKey(realAk)
         isAKValidated = true
@@ -129,8 +140,12 @@ class CPBaiduLocation(private val context: Context, private val config: CPBaiduL
         if (mLocationClient == null) {
             // 初始化定位客户端
             try {
+                // 必须在实例化之前同意隐私
+                LocationClient.setAgreePrivacy(true);
                 mLocationClient = LocationClient(mContext)
-                mLocationClient?.let { it.locOption = getLocationClientOption() }
+                mLocationClient?.let {
+                    it.locOption = getLocationClientOption()
+                }
             } catch (e: Exception) {
                 Logger.error(TAG, "Error initializing LocationClient", e)
                 return null
@@ -143,68 +158,52 @@ class CPBaiduLocation(private val context: Context, private val config: CPBaiduL
      * 获取当前位置信息
      * @param needAddress 是否需要地址信息
      * @param needLocationDescribe 是否需要位置描述
-     * @return 定位结果，包含经纬度、精度、地址信息等
+     * @param callback 定位结果回调
      */
-    fun getCurrentPosition(needAddress: Boolean, needLocationDescribe: Boolean): BDLocation? {
-        // 重置定位结果
-        mLocation = null
-        // 创建用于等待定位结果的同步锁
-        latch = CountDownLatch(1)
+    fun getCurrentPosition(
+        needAddress: Boolean, 
+        needLocationDescribe: Boolean, 
+        callback: LocationCallback
+    ) {
+        // 检查AK是否已验证
+        if (!isAKValidated) {
+            Log.e(TAG, "AK not validated")
+            callback.onError(-1, "AK not validated")
+            return
+        }
 
-        try {
-            // 检查AK是否已验证
-            if (!isAKValidated) {
-                Log.e(TAG, "AK not validated")
-                return null
-            }
+        // 获取定位客户端（懒加载）
+        val locationClient = getLocationClient() ?: run {
+            Log.e(TAG, "Failed to get location client")
+            callback.onError(-2, "Failed to get location client")
+            return
+        }
 
-            // 获取定位客户端（懒加载）
-            val locationClient = getLocationClient() ?: run {
-                Log.e(TAG, "Failed to get location client")
-                return null
+        try {
+            // 10秒超时检查
+            val handler = Handler(Looper.getMainLooper())
+            val timeoutRunnable = Runnable {
+                callback.onError(-3, "Location timeout")
             }
+            handler.postDelayed(timeoutRunnable, 10000)
 
-            // 创建定位监听器实例
-            val myListener = MyLocationListener()
-            // 注册定位监听器
-            locationClient.registerLocationListener(myListener)
+            // 注册新监听器
+            val listener = LocationListener(handler, timeoutRunnable, callback, locationClient)
             
-            // 配置定位选项
-            val options = locationClient.locOption
-            options.setIsNeedAddress(needAddress) // 设置是否需要地址信息
-            options.setIsNeedLocationDescribe(needLocationDescribe) // 设置是否需要位置描述
-            locationClient.locOption = options
+            // 注册监听器
+            locationClient.registerLocationListener(listener)
             
             // 开始定位
-            locationClient.start()
-
-            // 等待定位结果，最多10秒
-            try {
-                latch?.await(10, TimeUnit.SECONDS)
-            } catch (e: InterruptedException) {
-                Logger.error(TAG, "Interrupted while waiting for location", e)
-                // 确保定位客户端被正确关闭
-                if (locationClient.isStarted) {
-                    locationClient.stop()
-                    locationClient.unRegisterLocationListener(myListener)
-                }
-                return null
-            }
-
-            // 定位完成后停止定位客户端，释放资源
             if (locationClient.isStarted) {
-                locationClient.stop()
-                locationClient.unRegisterLocationListener(myListener)
+                locationClient.requestLocation()
+            } else {
+                locationClient.start()
             }
+            
         } catch (e: Exception) {
             Logger.error(TAG, "Error getting location", e)
-            // 确保定位客户端被正确关闭，释放资源
-            if (mLocationClient?.isStarted == true) {
-                mLocationClient?.stop()
-            }
+            callback.onError(-5, "Error: ${e.message}")
         }
-
-        return mLocation
     }
 
     @NonNull
@@ -216,31 +215,54 @@ class CPBaiduLocation(private val context: Context, private val config: CPBaiduL
         option.scanSpan = 0 // 单次定位
         option.isOpenGnss = true // 启用GPS
         option.isLocationNotify = true // 当位置变化时通知
-        option.setIgnoreKillProcess(false) // 定位服务不被杀死
-        option.SetIgnoreCacheException(false) // 不忽略缓存异常
+        option.setIgnoreKillProcess(true) // 定位服务不被杀死
+        option.SetIgnoreCacheException(true) // 忽略缓存异常
         option.wifiCacheTimeOut = 5 * 60 * 1000 // WiFi缓存超时时间
         option.enableSimulateGps = false // 不启用模拟GPS
+        option.setIsNeedAddress(true) // 设置是否需要地址信息
+        option.setIsNeedLocationDescribe(true) // 设置是否需要位置描述
         option.isNeedNewVersionRgc = true // 使用新版本的逆地理编码
         return option
     }
 
     /**
-     * 百度定位监听器
+     * 定位监听器
      */
-    private inner class MyLocationListener : BDAbstractLocationListener() {
-
-        /**
-         * 接收定位结果
-         * @param location 定位结果
-         */
+    private inner class LocationListener(
+        private val handler: Handler,
+        private val timeoutRunnable: Runnable,
+        private val callback: LocationCallback,
+        private val locationClient: LocationClient
+    ) : BDAbstractLocationListener() {
         override fun onReceiveLocation(location: BDLocation?) {
+            // 取消超时检查
+            handler.removeCallbacks(timeoutRunnable)
+            
             if (location != null) {
                 mLocation = location
                 Log.i(TAG, "坐标类型 = " + location.coorType)
                 Log.i(TAG, "经纬度(lng, lat) = " + location.longitude.toString() + "," + location.latitude)
+                
+                // 检查定位类型
+                if (location.locType == BDLocation.TypeGpsLocation ||
+                    location.locType == BDLocation.TypeNetWorkLocation ||
+                    location.locType == BDLocation.TypeOffLineLocation) {
+                    // 定位成功
+                    callback.onSuccess(location)
+                } else {
+                    // 定位失败
+                    callback.onError(location.locType, location.locTypeDescription ?: "定位失败")
+                }
+            } else {
+                // 定位失败
+                callback.onError(-4, "定位结果为空")
+            }
+            
+            // 停止定位
+            if (locationClient.isStarted) {
+                locationClient.stop()
             }
-            // 通知等待线程定位完成
-            latch?.countDown()
+            locationClient.unRegisterLocationListener(this)
         }
     }
 }

package/android/src/main/kotlin/com/hybrid/baidu/location/CPBaiduLocationPlugin.kt

@@ -64,54 +64,61 @@ class CPBaiduLocationPlugin : Plugin() {
         val needAddress = call.getBoolean("needAddress", false) ?: false
         val needLocationDescribe = call.getBoolean("needLocationDescribe", false) ?: false
 
-        // 调用实现类获取定位结果
-        val location = implementation.getCurrentPosition(needAddress, needLocationDescribe)
+        // 调用实现类获取定位结果（异步）
+        implementation.getCurrentPosition(needAddress, needLocationDescribe, object : CPBaiduLocation.LocationCallback {
+            override fun onSuccess(location: BDLocation) {
+                // 构建返回结果
+                val ret = JSObject()
+                
+                // 添加经纬度和精度
+                ret.put("latitude", location.latitude)
+                ret.put("longitude", location.longitude)
+                ret.put("accuracy", location.radius)
+
+                // 地址信息（如果需要且可用）
+                if (needAddress && location.addrStr != null) {
+                    ret.put("address", location.addrStr)
+                    ret.put("country", location.country)
+                    ret.put("province", location.province)
+                    ret.put("city", location.city)
+                    ret.put("district", location.district)
+                    ret.put("street", location.street)
+                    ret.put("adcode", location.adCode)
+                    ret.put("town", location.town)
+                }
 
-        // 构建返回结果
-        val ret = JSObject()
+                // 位置描述（如果需要且可用）
+                if (needLocationDescribe && location.locationDescribe != null) {
+                    ret.put("locationDescribe", location.locationDescribe)
+                }
 
-        if (location != null) {
-            // 添加经纬度和精度
-            ret.put("latitude", location.latitude)
-            ret.put("longitude", location.longitude)
-            ret.put("accuracy", location.radius)
-
-            // 地址信息（如果需要且可用）
-            if (needAddress && location.addrStr != null) {
-                ret.put("address", location.addrStr)
-                ret.put("country", location.country)
-                ret.put("province", location.province)
-                ret.put("city", location.city)
-                ret.put("district", location.district)
-                ret.put("street", location.street)
-                ret.put("adcode", location.adCode)
-                ret.put("town", location.town)
-            }
+                // 错误信息（如果定位类型不是GPS、网络或离线定位）
+                if (
+                    location.locType != BDLocation.TypeGpsLocation &&
+                    location.locType != BDLocation.TypeNetWorkLocation &&
+                    location.locType != BDLocation.TypeOffLineLocation
+                ) {
+                    ret.put("errorCode", location.locType)
+                    ret.put("errorMessage", location.locTypeDescription)
+                }
 
-            // 位置描述（如果需要且可用）
-            if (needLocationDescribe && location.locationDescribe != null) {
-                ret.put("locationDescribe", location.locationDescribe)
+                // 返回结果
+                call.resolve(ret)
             }
 
-            // 错误信息（如果定位类型不是GPS、网络或离线定位）
-            if (
-                location.locType != BDLocation.TypeGpsLocation &&
-                location.locType != BDLocation.TypeNetWorkLocation &&
-                location.locType != BDLocation.TypeOffLineLocation
-            ) {
-                ret.put("errorCode", location.locType)
-                ret.put("errorMessage", location.locTypeDescription)
+            override fun onError(errorCode: Int, errorMessage: String) {
+                // 构建错误结果
+                val ret = JSObject()
+                ret.put("latitude", 0)
+                ret.put("longitude", 0)
+                ret.put("accuracy", 0)
+                ret.put("errorCode", errorCode)
+                ret.put("errorMessage", errorMessage)
+                
+                // 返回错误结果
+                call.resolve(ret)
             }
-        } else {
-            // 定位失败
-            ret.put("latitude", 0)
-            ret.put("longitude", 0)
-            ret.put("errorCode", -1)
-            ret.put("errorMessage", "Failed to get location")
-        }
-
-        // 返回结果
-        call.resolve(ret)
+        })
     }
 
     /**