react-native-beidou 1.0.7 → 1.1.1

package/android/src/main/java/com/{cmcc_rn_module → fxzs.rnbeidou}/BeiDouBluetoothPackage.java

@@ -1,8 +1,8 @@
-package com.cmcc_rn_module;
+package com.fxzs.rnbeidou;
 
 import androidx.annotation.NonNull;
 
-import com.cmcc_rn_module.view.CompassManager;
+import com.fxzs.rnbeidou.view.CompassManager;
 import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;

package/android/src/main/java/com/fxzs.rnbeidou/BeidouAidlHelper.java

@@ -0,0 +1,643 @@
+package com.fxzs.rnbeidou;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeArray;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.satnav.beidouservice.BDAuthResponse;
+import com.satnav.beidouservice.BDMsgDecryptResponse;
+import com.satnav.beidouservice.BDMsgEncryptResponse;
+import com.satnav.beidouservice.BDMsgEphemerisFileDLResponse;
+import com.satnav.beidouservice.BDStatusResponse;
+import com.satnav.beidouservice.IBeidouMsgAidlInterface;
+import com.satnav.beidouservice.IBeidouServiceCallback;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BeidouAidlHelper {
+
+    @Nullable
+    private final ReactApplicationContext reactContext;
+    @Nullable
+    private IBeidouMsgAidlInterface beidouService;
+    private boolean isBeidouServiceBound = false;
+
+    @Nullable
+    private Promise pendingAuthPromise;
+    @Nullable
+    private Promise pendingStatusPromise;
+    @Nullable
+    private Promise pendingEphemerisPromise;
+
+    private final Object authLock = new Object();
+    private final Object statusLock = new Object();
+    private final Object ephemerisLock = new Object();
+
+    private final IBeidouServiceCallback.Stub beidouServiceCallback = new IBeidouServiceCallback.Stub() {
+        @Override
+        public void onAuthResult(int slotId, BDAuthResponse response) {
+            handleAuthResult(slotId, response);
+        }
+
+        @Override
+        public void onStatusResult(int slotId, BDStatusResponse response) {
+            handleStatusResult(slotId, response);
+        }
+
+        @Override
+        public void onEphemerisFileResult(int slotId, BDMsgEphemerisFileDLResponse response) {
+            handleEphemerisResult(slotId, response);
+        }
+    };
+
+    private final ServiceConnection beidouServiceConnection = new ServiceConnection() {
+        @Override
+        public void onServiceConnected(ComponentName name, IBinder service) {
+            beidouService = IBeidouMsgAidlInterface.Stub.asInterface(service);
+            isBeidouServiceBound = true;
+            Log.d("BeiDouService", "北斗服务连接成功");
+            if (beidouService != null) {
+                try {
+                    beidouService.setCallback(beidouServiceCallback);
+                } catch (Exception e) {
+                    Log.e("BeiDouService", "设置北斗服务回调失败: " + e.getMessage(), e);
+                }
+            }
+        }
+
+        @Override
+        public void onServiceDisconnected(ComponentName name) {
+            beidouService = null;
+            isBeidouServiceBound = false;
+            Log.d("BeiDouService", "北斗服务连接断开");
+            rejectAllPendingPromises("SERVICE_DISCONNECTED", "北斗服务连接已断开");
+        }
+    };
+
+    public BeidouAidlHelper(@Nullable ReactApplicationContext reactContext) {
+        this.reactContext = reactContext;
+    }
+
+    public void bindService(String packageName, String actionName, Promise promise) {
+        if (reactContext == null) {
+            promise.reject("CONTEXT_NULL", "React上下文不可用");
+            return;
+        }
+
+        try {
+            bindBeidouService(packageName, actionName);
+            promise.resolve(true);
+        } catch (Exception e) {
+            promise.reject("BIND_ERROR", "绑定北斗服务失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void unbindService(Promise promise) {
+        if (reactContext == null) {
+            promise.reject("CONTEXT_NULL", "React上下文不可用");
+            return;
+        }
+
+        try {
+            unbindBeidouService();
+            promise.resolve(true);
+        } catch (Exception e) {
+            promise.reject("UNBIND_ERROR", "解绑北斗服务失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void authenticate(int slotId, Promise promise) {
+        if (!ensureServiceReady(promise)) {
+            return;
+        }
+
+        Promise existing;
+        synchronized (authLock) {
+            existing = pendingAuthPromise;
+            pendingAuthPromise = promise;
+        }
+        rejectIfExisting(existing, "REQUEST_REPLACED", "存在未完成的鉴权请求已被新的请求覆盖");
+
+        try {
+            if (beidouService != null) {
+                beidouService.BDAuthenticate(slotId);
+            }
+        } catch (Exception e) {
+            clearAuthPromise(promise);
+            promise.reject("REMOTE_ERROR", "北斗鉴权调用失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void getStatus(int slotId, Promise promise) {
+        if (!ensureServiceReady(promise)) {
+            return;
+        }
+
+        Promise existing;
+        synchronized (statusLock) {
+            existing = pendingStatusPromise;
+            pendingStatusPromise = promise;
+        }
+        rejectIfExisting(existing, "REQUEST_REPLACED", "存在未完成的状态查询请求已被新的请求覆盖");
+
+        try {
+            if (beidouService != null) {
+                beidouService.getBDMsgStatus(slotId);
+            }
+        } catch (Exception e) {
+            clearStatusPromise(promise);
+            promise.reject("REMOTE_ERROR", "获取北斗状态调用失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void checkValidatedKey(int slotId, Promise promise) {
+        if (!ensureServiceReady(promise)) {
+            return;
+        }
+
+        try {
+            if (beidouService != null) {
+                int result = beidouService.checkValidatedKey(slotId);
+                promise.resolve(result);
+            } else {
+                promise.reject("SERVICE_NOT_BOUND", "北斗服务未绑定，请先调用bindBeidouServiceMethod");
+            }
+        } catch (Exception e) {
+            promise.reject("REMOTE_ERROR", "检查北斗密钥失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void commonBDMsgEncrypt(int slotId, String speedType, @Nullable ReadableArray receiveList, String inputMsg,
+                                   Promise promise) {
+        if (!ensureServiceReady(promise)) {
+            return;
+        }
+
+        try {
+            List<String> receiveStringList = readableArrayToStringList(receiveList);
+            if (beidouService != null) {
+                List<BDMsgEncryptResponse> responses = beidouService.commonBDMsgEncrypt(slotId, speedType, receiveStringList,
+                        inputMsg);
+                promise.resolve(encryptResponseListToWritableArray(responses));
+            }
+        } catch (Exception e) {
+            promise.reject("REMOTE_ERROR", "通用报文加密失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void positionBDMsgEncrypt(int slotId, String speedType, @Nullable ReadableArray receiveList, String inputMsg,
+                                     double longitude, double latitude, Promise promise) {
+        if (!ensureServiceReady(promise)) {
+            return;
+        }
+
+        try {
+            List<String> receiveStringList = readableArrayToStringList(receiveList);
+            if (beidouService != null) {
+                List<BDMsgEncryptResponse> responses = beidouService.positionBDMsgEncrypt(slotId, speedType, receiveStringList,
+                        inputMsg, longitude, latitude);
+                promise.resolve(encryptResponseListToWritableArray(responses));
+            }
+        } catch (Exception e) {
+            promise.reject("REMOTE_ERROR", "位置报文加密失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void commonEmergencyBDMsgEncrypt(int slotId, String speedType, @Nullable ReadableArray receiveList, String inputMsg,
+                                            Promise promise) {
+        if (!ensureServiceReady(promise)) {
+            return;
+        }
+
+        try {
+            List<String> receiveStringList = readableArrayToStringList(receiveList);
+            if (beidouService != null) {
+                List<BDMsgEncryptResponse> responses = beidouService.commonEmergencyBDMsgEncrypt(slotId, speedType, receiveStringList,
+                        inputMsg);
+                promise.resolve(encryptResponseListToWritableArray(responses));
+            }
+        } catch (Exception e) {
+            promise.reject("REMOTE_ERROR", "应急通用报文加密失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void positionEmergencyBDMsgEncrypt(int slotId, String speedType, @Nullable ReadableArray receiveList, String inputMsg,
+                                              double longitude, double latitude, Promise promise) {
+        if (!ensureServiceReady(promise)) {
+            return;
+        }
+
+        try {
+            List<String> receiveStringList = readableArrayToStringList(receiveList);
+            if (beidouService != null) {
+                List<BDMsgEncryptResponse> responses = beidouService.positionEmergencyBDMsgEncrypt(slotId, speedType,
+                        receiveStringList, inputMsg, longitude, latitude);
+                promise.resolve(encryptResponseListToWritableArray(responses));
+            }
+        } catch (Exception e) {
+            promise.reject("REMOTE_ERROR", "应急位置报文加密失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void commonRichMediaBDMsgEncrypt(int slotId, String speedType, @Nullable ReadableArray receiveList, String msgType,
+                                            @Nullable ReadableArray inputRichMediaData, Promise promise) {
+        if (!ensureServiceReady(promise)) {
+            return;
+        }
+
+        try {
+            List<String> receiveStringList = readableArrayToStringList(receiveList);
+            byte[] richMediaData = readableArrayToByteArray(inputRichMediaData);
+            if (beidouService != null) {
+                List<BDMsgEncryptResponse> responses = beidouService.commonRichMediaBDMsgEncrypt(slotId, speedType,
+                        receiveStringList, msgType, richMediaData);
+                promise.resolve(encryptResponseListToWritableArray(responses));
+            }
+        } catch (Exception e) {
+            promise.reject("REMOTE_ERROR", "富媒体通用报文加密失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void positionRichMediaBDMsgEncrypt(int slotId, String speedType, @Nullable ReadableArray receiveList, String msgType,
+                                              @Nullable ReadableArray inputRichMediaData, double longitude, double latitude,
+                                              Promise promise) {
+        if (!ensureServiceReady(promise)) {
+            return;
+        }
+
+        try {
+            List<String> receiveStringList = readableArrayToStringList(receiveList);
+            byte[] richMediaData = readableArrayToByteArray(inputRichMediaData);
+            if (beidouService != null) {
+                List<BDMsgEncryptResponse> responses = beidouService.positionRichMediaBDMsgEncrypt(slotId, speedType,
+                        receiveStringList, msgType, richMediaData, longitude, latitude);
+                promise.resolve(encryptResponseListToWritableArray(responses));
+            }
+        } catch (Exception e) {
+            promise.reject("REMOTE_ERROR", "富媒体位置报文加密失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void commonRichMediaAndTextBDMsgEncrypt(int slotId, String speedType, @Nullable ReadableArray receiveList, String text,
+                                                   String msgType, @Nullable ReadableArray inputRichMediaData, Promise promise) {
+        if (!ensureServiceReady(promise)) {
+            return;
+        }
+
+        try {
+            List<String> receiveStringList = readableArrayToStringList(receiveList);
+            byte[] richMediaData = readableArrayToByteArray(inputRichMediaData);
+            if (beidouService != null) {
+                List<BDMsgEncryptResponse> responses = beidouService.commonRichMediaAndTextBDMsgEncrypt(slotId, speedType,
+                        receiveStringList, text, msgType, richMediaData);
+                promise.resolve(encryptResponseListToWritableArray(responses));
+            }
+        } catch (Exception e) {
+            promise.reject("REMOTE_ERROR", "图文混排通用报文加密失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void positionRichMediaAndTextBDMsgEncrypt(int slotId, String speedType, @Nullable ReadableArray receiveList, String text,
+                                                     String msgType, @Nullable ReadableArray inputRichMediaData, double longitude,
+                                                     double latitude, Promise promise) {
+        if (!ensureServiceReady(promise)) {
+            return;
+        }
+
+        try {
+            List<String> receiveStringList = readableArrayToStringList(receiveList);
+            byte[] richMediaData = readableArrayToByteArray(inputRichMediaData);
+            if (beidouService != null) {
+                List<BDMsgEncryptResponse> responses = beidouService.positionRichMediaAndTextBDMsgEncrypt(slotId, speedType,
+                        receiveStringList, text, msgType, richMediaData, longitude, latitude);
+                promise.resolve(encryptResponseListToWritableArray(responses));
+            }
+        } catch (Exception e) {
+            promise.reject("REMOTE_ERROR", "图文混排位置报文加密失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void mailboxQueryEncrypt(int slotId, Promise promise) {
+        if (!ensureServiceReady(promise)) {
+            return;
+        }
+
+        try {
+            if (beidouService != null) {
+                BDMsgEncryptResponse response = beidouService.BDMailboxQueryEncrypt(slotId);
+                promise.resolve(createEncryptResponseMap(response));
+            }
+        } catch (Exception e) {
+            promise.reject("REMOTE_ERROR", "信箱查询加密失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void emergencyMailboxQueryEncrypt(int slotId, String replyMobile, Promise promise) {
+        if (!ensureServiceReady(promise)) {
+            return;
+        }
+
+        try {
+            if (beidouService != null) {
+                BDMsgEncryptResponse response = beidouService.EmergencyBDMailboxQueryEncrypt(slotId, replyMobile);
+                promise.resolve(createEncryptResponseMap(response));
+            }
+        } catch (Exception e) {
+            promise.reject("REMOTE_ERROR", "应急信箱查询加密失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void decryptMessage(int slotId, @Nullable ReadableArray msg, int len, Promise promise) {
+        if (!ensureServiceReady(promise)) {
+            return;
+        }
+
+        try {
+            byte[] msgBytes = readableArrayToByteArray(msg);
+            if (beidouService != null) {
+                BDMsgDecryptResponse response = beidouService.BDMsgDecrypt(slotId, msgBytes, len);
+                promise.resolve(createDecryptResponseMap(response));
+            }
+        } catch (Exception e) {
+            promise.reject("REMOTE_ERROR", "报文解密失败: " + e.getMessage(), e);
+        }
+    }
+
+    public void downloadEphemerisFile(int slotId, String type, String version, Promise promise) {
+        if (!ensureServiceReady(promise)) {
+            return;
+        }
+
+        Promise existing;
+        synchronized (ephemerisLock) {
+            existing = pendingEphemerisPromise;
+            pendingEphemerisPromise = promise;
+        }
+        rejectIfExisting(existing, "REQUEST_REPLACED", "存在未完成的星历文件下载请求已被新的请求覆盖");
+
+        try {
+            if (beidouService != null) {
+                beidouService.DLEphemerisFile(slotId, type, version);
+            }
+        } catch (Exception e) {
+            clearEphemerisPromise(promise);
+            promise.reject("REMOTE_ERROR", "下载星历文件调用失败: " + e.getMessage(), e);
+        }
+    }
+
+    private void bindBeidouService(String packageName, String actionName) {
+        if (!isBeidouServiceBound && reactContext != null) {
+            Intent intent = new Intent();
+            intent.setComponent(new ComponentName(packageName, actionName));
+            boolean result = reactContext.bindService(intent, beidouServiceConnection, Context.BIND_AUTO_CREATE);
+            Log.d("BeiDouService", "绑定北斗服务结果: " + result + ", 包名: " + packageName + ", 类名: " + actionName);
+        }
+    }
+
+    private void unbindBeidouService() {
+        if (isBeidouServiceBound && reactContext != null) {
+            reactContext.unbindService(beidouServiceConnection);
+            beidouService = null;
+            isBeidouServiceBound = false;
+            Log.d("BeiDouService", "解绑北斗服务成功");
+            rejectAllPendingPromises("SERVICE_UNBOUND", "北斗服务已解绑");
+        }
+    }
+
+    private boolean ensureServiceReady(Promise promise) {
+        if (!isBeidouServiceBound || beidouService == null) {
+            promise.reject("SERVICE_NOT_BOUND", "北斗服务未绑定，请先调用bindBeidouServiceMethod");
+            return false;
+        }
+        return true;
+    }
+
+    private void handleAuthResult(int slotId, @Nullable BDAuthResponse response) {
+        WritableMap result = createAuthResultMap(slotId, response);
+        Promise promise;
+        synchronized (authLock) {
+            promise = pendingAuthPromise;
+            pendingAuthPromise = null;
+        }
+        if (promise != null) {
+            resolvePromiseOnUiThread(promise, result);
+        }
+        sendEventToJS("BeiDouAuthResult", createAuthResultMap(slotId, response));
+    }
+
+    private void handleStatusResult(int slotId, @Nullable BDStatusResponse response) {
+        WritableMap result = createStatusResultMap(slotId, response);
+        Promise promise;
+        synchronized (statusLock) {
+            promise = pendingStatusPromise;
+            pendingStatusPromise = null;
+        }
+        if (promise != null) {
+            resolvePromiseOnUiThread(promise, result);
+        }
+        sendEventToJS("BeiDouStatusResult", createStatusResultMap(slotId, response));
+    }
+
+    private void handleEphemerisResult(int slotId, @Nullable BDMsgEphemerisFileDLResponse response) {
+        WritableMap result = createEphemerisResultMap(slotId, response);
+        Promise promise;
+        synchronized (ephemerisLock) {
+            promise = pendingEphemerisPromise;
+            pendingEphemerisPromise = null;
+        }
+        if (promise != null) {
+            resolvePromiseOnUiThread(promise, result);
+        }
+        sendEventToJS("BeiDouEphemerisResult", createEphemerisResultMap(slotId, response));
+    }
+
+    private void resolvePromiseOnUiThread(final Promise promise, final WritableMap value) {
+        runOnUiQueueThread(() -> promise.resolve(value));
+    }
+
+    private void rejectPromiseOnUiThread(final Promise promise, final String code, final String message) {
+        runOnUiQueueThread(() -> promise.reject(code, message));
+    }
+
+    private void runOnUiQueueThread(Runnable runnable) {
+        if (reactContext != null) {
+            reactContext.runOnUiQueueThread(runnable);
+        } else {
+            runnable.run();
+        }
+    }
+
+    private void sendEventToJS(String eventName, @Nullable WritableMap params) {
+        if (reactContext == null) {
+            return;
+        }
+        WritableMap safeParams = params != null ? params : new WritableNativeMap();
+        runOnUiQueueThread(() -> reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(eventName, safeParams));
+    }
+
+    private WritableMap createAuthResultMap(int slotId, @Nullable BDAuthResponse response) {
+        WritableMap map = new WritableNativeMap();
+        map.putInt("slotId", slotId);
+        map.putInt("code", response != null ? response.code : -1);
+        map.putString("statusMsg", response != null ? response.statusMsg : null);
+        return map;
+    }
+
+    private WritableMap createStatusResultMap(int slotId, @Nullable BDStatusResponse response) {
+        WritableMap map = new WritableNativeMap();
+        map.putInt("slotId", slotId);
+        map.putInt("code", response != null ? response.code : -1);
+        map.putString("statusMsg", response != null ? response.statusMsg : null);
+        map.putInt("msgQuotaRemain", response != null ? response.msgQuotaRemain : -1);
+        map.putInt("userOpenStatus", response != null ? response.userOpenStatus : -1);
+        return map;
+    }
+
+    private WritableMap createEphemerisResultMap(int slotId, @Nullable BDMsgEphemerisFileDLResponse response) {
+        WritableMap map = new WritableNativeMap();
+        map.putInt("slotId", slotId);
+        map.putInt("code", response != null ? response.code : -1);
+        map.putString("statusMsg", response != null ? response.statusMsg : null);
+        map.putString("version", response != null ? response.version : null);
+        map.putString("ephemerisZipFileName", response != null ? response.ephemerisZipFileName : null);
+        map.putArray("ephemerisZipFile", response != null ? byteArrayToWritableArray(response.ephemerisZipFile)
+                : new WritableNativeArray());
+        return map;
+    }
+
+    private WritableMap createDecryptResponseMap(@Nullable BDMsgDecryptResponse response) {
+        WritableMap map = new WritableNativeMap();
+        map.putInt("statusMsg", response != null ? response.statusMsg : -1);
+        map.putInt("isRemainMsg", response != null ? response.isRemainMsg : -1);
+        map.putString("rcvMobile", response != null ? response.rcvMobile : null);
+        map.putString("data", response != null ? response.data : null);
+        return map;
+    }
+
+    private WritableMap createEncryptResponseMap(@Nullable BDMsgEncryptResponse response) {
+        WritableMap map = new WritableNativeMap();
+        if (response != null) {
+            map.putInt("code", response.code);
+            map.putString("statusMsg", response.statusMsg);
+            map.putArray("data", byteArrayToWritableArray(response.data));
+            map.putString("sendMobile", response.sendMobile);
+            map.putInt("len", response.len);
+        } else {
+            map.putInt("code", -1);
+            map.putString("statusMsg", null);
+            map.putArray("data", new WritableNativeArray());
+            map.putString("sendMobile", null);
+            map.putInt("len", -1);
+        }
+        return map;
+    }
+
+    private WritableArray encryptResponseListToWritableArray(@Nullable List<BDMsgEncryptResponse> responseList) {
+        WritableArray array = new WritableNativeArray();
+        if (responseList != null) {
+            for (BDMsgEncryptResponse response : responseList) {
+                array.pushMap(createEncryptResponseMap(response));
+            }
+        }
+        return array;
+    }
+
+    private WritableArray byteArrayToWritableArray(@Nullable byte[] byteArray) {
+        WritableArray array = new WritableNativeArray();
+        if (byteArray != null) {
+            for (byte b : byteArray) {
+                array.pushInt(b & 0xFF);
+            }
+        }
+        return array;
+    }
+
+    private List<String> readableArrayToStringList(@Nullable ReadableArray readableArray) {
+        List<String> list = new ArrayList<>();
+        if (readableArray == null) {
+            return list;
+        }
+        for (int i = 0; i < readableArray.size(); i++) {
+            list.add(readableArray.getString(i));
+        }
+        return list;
+    }
+
+    private byte[] readableArrayToByteArray(@Nullable ReadableArray readableArray) {
+        if (readableArray == null) {
+            return new byte[0];
+        }
+        byte[] bytes = new byte[readableArray.size()];
+        for (int i = 0; i < readableArray.size(); i++) {
+            bytes[i] = (byte) readableArray.getInt(i);
+        }
+        return bytes;
+    }
+
+    private void rejectAllPendingPromises(String code, String message) {
+        Promise auth;
+        Promise status;
+        Promise ephemeris;
+        synchronized (authLock) {
+            auth = pendingAuthPromise;
+            pendingAuthPromise = null;
+        }
+        synchronized (statusLock) {
+            status = pendingStatusPromise;
+            pendingStatusPromise = null;
+        }
+        synchronized (ephemerisLock) {
+            ephemeris = pendingEphemerisPromise;
+            pendingEphemerisPromise = null;
+        }
+        rejectIfExisting(auth, code, message);
+        rejectIfExisting(status, code, message);
+        rejectIfExisting(ephemeris, code, message);
+    }
+
+    private void rejectIfExisting(@Nullable Promise promise, String code, String message) {
+        if (promise != null) {
+            rejectPromiseOnUiThread(promise, code, message);
+        }
+    }
+
+    private void clearAuthPromise(Promise expected) {
+        synchronized (authLock) {
+            if (pendingAuthPromise == expected) {
+                pendingAuthPromise = null;
+            }
+        }
+    }
+
+    private void clearStatusPromise(Promise expected) {
+        synchronized (statusLock) {
+            if (pendingStatusPromise == expected) {
+                pendingStatusPromise = null;
+            }
+        }
+    }
+
+    private void clearEphemerisPromise(Promise expected) {
+        synchronized (ephemerisLock) {
+            if (pendingEphemerisPromise == expected) {
+                pendingEphemerisPromise = null;
+            }
+        }
+    }
+}
+

package/android/src/main/java/com/{cmcc_rn_module → fxzs.rnbeidou}/ByteUtil.java

@@ -1,4 +1,4 @@
-package com.cmcc_rn_module;
+package com.fxzs.rnbeidou;
 
 import android.util.Log;
 
@@ -10,7 +10,7 @@ public class ByteUtil {
 
     /**
      * 重复字符生成字符串的兼容方法（替代 String.repeat()）
-     * 
+     *
      * @param ch    要重复的字符
      * @param count 重复次数
      * @return 重复字符组成的字符串