react-native-beidou 1.1.4 → 1.1.6

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

@@ -1,30 +1,27 @@
 package com.fxzs.rnbeidou;
 
-import androidx.annotation.NonNull;
-
-import com.fxzs.rnbeidou.view.CompassManager;
-import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.ReactPackage;
 import com.facebook.react.uimanager.ViewManager;
-
+import com.fxzs.rnbeidou.view.CompassManager;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.List;
 
 public class BeiDouBluetoothPackage implements ReactPackage {
-    @NonNull
+
     @Override
-    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
-        return Arrays.asList(
-                new BeiDouBluetoothModule(reactContext));
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        return Arrays.<NativeModule>asList(
+                new BeiDouBluetoothModule(reactContext),
+                new SuperSimModule(reactContext)
+        );
     }
 
-    @NonNull
     @Override
-    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
         return Arrays.<ViewManager>asList(
-                new CompassManager(reactContext)
+                new CompassManager()
         );
     }
 }

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

@@ -29,7 +29,6 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class BeidouAidlHelper {
-
     @Nullable
     private final ReactApplicationContext reactContext;
     @Nullable
@@ -73,17 +72,13 @@ public class BeidouAidlHelper {
             if (beidouService != null) {
                 try {
                     beidouService.setCallback(beidouServiceCallback);
-                    if (beidouServicePromise != null) {
-                        beidouServicePromise.resolve(true);
-                        beidouServicePromise = null;
-                    }
+                    resolvePendingBindPromise(true);
                 } catch (Exception e) {
                     Log.e("BeiDouService", "设置北斗服务回调失败: " + e.getMessage(), e);
-                    if (beidouServicePromise != null) {
-                        beidouServicePromise.reject("BIND_ERROR", "绑定北斗服务失败: " + e.getMessage(), e);
-                        beidouServicePromise = null;
-                    }
+                    rejectPendingBindPromise("BIND_ERROR", "绑定北斗服务失败: " + e.getMessage(), e);
                 }
+            } else {
+                rejectPendingBindPromise("BIND_ERROR", "绑定北斗服务失败: service is null", null);
             }
         }
 
@@ -92,6 +87,7 @@ public class BeidouAidlHelper {
             beidouService = null;
             isBeidouServiceBound = false;
             Log.d("BeiDouService", "北斗服务连接断开");
+            rejectPendingBindPromise("SERVICE_DISCONNECTED", "北斗服务连接已断开", null);
             rejectAllPendingPromises("SERVICE_DISCONNECTED", "北斗服务连接已断开");
         }
     };
@@ -100,16 +96,30 @@ public class BeidouAidlHelper {
         this.reactContext = reactContext;
     }
     private Promise beidouServicePromise;
+
     public void bindService(String packageName, String actionName, Promise promise) {
         if (reactContext == null) {
             promise.reject("CONTEXT_NULL", "React上下文不可用");
             return;
         }
+        if (isBeidouServiceBound && beidouService != null) {
+            promise.resolve(true);
+            return;
+        }
         try {
+            if (beidouServicePromise != null) {
+                Promise old = beidouServicePromise;
+                beidouServicePromise = null;
+                old.reject("REQUEST_REPLACED", "存在未完成的绑定请求已被新的请求覆盖");
+            }
             beidouServicePromise = promise;
-            bindBeidouService(packageName, actionName);
-//            promise.resolve(true);
+            boolean bindRequested = bindBeidouService(packageName, actionName);
+            if (!bindRequested) {
+                rejectPendingBindPromise("BIND_ERROR", "绑定北斗服务失败: bindService returned false", null);
+                return;
+            }
         } catch (Exception e) {
+            beidouServicePromise = null;
             promise.reject("BIND_ERROR", "绑定北斗服务失败: " + e.getMessage(), e);
         }
     }
@@ -121,6 +131,7 @@ public class BeidouAidlHelper {
         }
 
         try {
+            rejectPendingBindPromise("SERVICE_UNBOUND", "北斗服务已解绑", null);
             unbindBeidouService();
             promise.resolve(true);
         } catch (Exception e) {
@@ -407,13 +418,15 @@ public class BeidouAidlHelper {
         }
     }
 
-    private void bindBeidouService(String packageName, String actionName) {
+    private boolean 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);
+            return result;
         }
+        return true;
     }
 
     private void unbindBeidouService() {
@@ -624,6 +637,26 @@ public class BeidouAidlHelper {
         }
     }
 
+    private void resolvePendingBindPromise(boolean value) {
+        Promise pending = beidouServicePromise;
+        beidouServicePromise = null;
+        if (pending != null) {
+            pending.resolve(value);
+        }
+    }
+
+    private void rejectPendingBindPromise(String code, String message, @Nullable Throwable throwable) {
+        Promise pending = beidouServicePromise;
+        beidouServicePromise = null;
+        if (pending != null) {
+            if (throwable != null) {
+                pending.reject(code, message, throwable);
+            } else {
+                pending.reject(code, message);
+            }
+        }
+    }
+
     private void clearAuthPromise(Promise expected) {
         synchronized (authLock) {
             if (pendingAuthPromise == expected) {
@@ -648,4 +681,3 @@ public class BeidouAidlHelper {
         }
     }
 }
-

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

@@ -0,0 +1,301 @@
+package com.fxzs.rnbeidou;
+
+import android.os.Handler;
+import android.os.Looper;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.beidou.bluetooth.supersim.SuperSimManager;
+import com.cmcc.bdmsgsecure.model.BDMsgGetUserInfoTerminalResponse;
+import com.cmcc.bdmsgsecure.model.BDMsgMailSynchronizeTerminalResponse;
+import com.cmcc.bdmsgserver.bdmsgauth.model.BDMsgMailReplyResponse;
+import com.cmcc.bdmsgserver.bdmsgauth.model.BDMsgSMCryptResponse;
+import com.cmft.gba.sdk.core.bean.Result;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+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 java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+
+public class SuperSimModule extends ReactContextBaseJavaModule {
+    public static final String NAME = "SuperSimModule";
+
+    private final ReactApplicationContext reactContext;
+    private final SuperSimManager superSimManager;
+    private final ExecutorService worker = Executors.newSingleThreadExecutor();
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+
+    public SuperSimModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+        this.superSimManager = SuperSimManager.getInstance(reactContext);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @ReactMethod
+    public void getSimType(double slotId, Promise promise) {
+        runOnWorker(() -> superSimManager.getSimType((int) slotId), promise);
+    }
+
+    @ReactMethod
+    public void getKsKeyAndAuthResult(double slotId, Promise promise) {
+        runOnWorker(() -> {
+            Result<String> result = superSimManager.getKsKeyAndAuthResult((int) slotId);
+            return objectToWritable(result, 3);
+        }, promise);
+    }
+
+    @ReactMethod
+    public void checkKeyIsExistAndValidate(double slotId, Promise promise) {
+        runOnWorker(() -> superSimManager.checkKeyIsExistAndValidate((int) slotId), promise);
+    }
+
+    @ReactMethod
+    public void commonMessageEncryptBDMsg(double slotId, @Nullable ReadableArray recipients, String message, Promise promise) {
+        runOnWorker(() -> {
+            LinkedList<String> list = readableArrayToStringList(recipients);
+            BDMsgSMCryptResponse resp = superSimManager.commonMessageEncryptBDMsg((int) slotId, list, message);
+            return objectToWritable(resp, 3);
+        }, promise);
+    }
+
+    @ReactMethod
+    public void positionReportEncryptBDMsg(double slotId, @Nullable ReadableArray recipients, String message, double longitude, double latitude, Promise promise) {
+        runOnWorker(() -> {
+            LinkedList<String> list = readableArrayToStringList(recipients);
+            BDMsgSMCryptResponse resp = superSimManager.positionReportEncryptBDMsg((int) slotId, list, message, longitude, latitude);
+            return objectToWritable(resp, 3);
+        }, promise);
+    }
+
+    @ReactMethod
+    public void mailboxQueryEncryptBDMsg(double slotId, Promise promise) {
+        runOnWorker(() -> {
+            BDMsgSMCryptResponse resp = superSimManager.mailboxQueryEncryptBDMsg((int) slotId);
+            return objectToWritable(resp, 3);
+        }, promise);
+    }
+
+    @ReactMethod
+    public void mailboxReplyDecryptBDMsg(double slotId, @Nullable ReadableArray data, double dataLength, Promise promise) {
+        runOnWorker(() -> {
+            byte[] bytes = readableArrayToByteArray(data);
+            BDMsgMailReplyResponse resp = superSimManager.mailboxReplyDecryptBDMsg((int) slotId, bytes, (int) dataLength);
+            return objectToWritable(resp, 3);
+        }, promise);
+    }
+
+    @ReactMethod
+    public void getCurrentUserInfo(double slotId, Promise promise) {
+        runOnWorker(() -> {
+            BDMsgGetUserInfoTerminalResponse resp = superSimManager.getCurrentUserInfo((int) slotId);
+            return objectToWritable(resp, 3);
+        }, promise);
+    }
+
+    @ReactMethod
+    public void mailboxSynchronizeDecryptBDMsg(double slotId, Promise promise) {
+        runOnWorker(() -> {
+            BDMsgMailSynchronizeTerminalResponse resp = superSimManager.mailboxSynchronizeDecryptBDMsg((int) slotId);
+            return objectToWritable(resp, 3);
+        }, promise);
+    }
+
+    private <T> void runOnWorker(Callable<T> task, Promise promise) {
+        worker.execute(() -> {
+            try {
+                T result = task.call();
+                mainHandler.post(() -> promise.resolve(result));
+            } catch (Exception e) {
+                mainHandler.post(() -> promise.reject("SUPER_SIM_ERROR", e.getMessage(), e));
+            }
+        });
+    }
+
+    private LinkedList<String> readableArrayToStringList(@Nullable ReadableArray readableArray) {
+        LinkedList<String> list = new LinkedList<>();
+        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 Object objectToWritable(@Nullable Object value, int depth) {
+        if (value == null) {
+            return null;
+        }
+        if (depth <= 0) {
+            return String.valueOf(value);
+        }
+        if (value instanceof String || value instanceof Number || value instanceof Boolean) {
+            return value;
+        }
+        if (value instanceof byte[]) {
+            return byteArrayToWritableArray((byte[]) value);
+        }
+        if (value.getClass().isArray()) {
+            return arrayToWritableArray(value, depth - 1);
+        }
+        if (value instanceof List) {
+            return listToWritableArray((List<?>) value, depth - 1);
+        }
+        if (value instanceof Map) {
+            return mapToWritableMap((Map<?, ?>) value, depth - 1);
+        }
+        return objectToWritableMapByGetters(value, depth - 1);
+    }
+
+    private WritableArray byteArrayToWritableArray(byte[] bytes) {
+        WritableArray array = new WritableNativeArray();
+        for (byte b : bytes) {
+            array.pushInt(b & 0xFF);
+        }
+        return array;
+    }
+
+    private WritableArray arrayToWritableArray(Object arrayObj, int depth) {
+        int length = Array.getLength(arrayObj);
+        WritableArray array = new WritableNativeArray();
+        for (int i = 0; i < length; i++) {
+            Object item = Array.get(arrayObj, i);
+            Object converted = objectToWritable(item, depth);
+            pushToArray(array, converted);
+        }
+        return array;
+    }
+
+    private WritableArray listToWritableArray(List<?> list, int depth) {
+        WritableArray array = new WritableNativeArray();
+        for (Object item : list) {
+            Object converted = objectToWritable(item, depth);
+            pushToArray(array, converted);
+        }
+        return array;
+    }
+
+    private WritableMap mapToWritableMap(Map<?, ?> map, int depth) {
+        WritableMap result = new WritableNativeMap();
+        for (Map.Entry<?, ?> entry : map.entrySet()) {
+            String key = String.valueOf(entry.getKey());
+            Object converted = objectToWritable(entry.getValue(), depth);
+            putToMap(result, key, converted);
+        }
+        return result;
+    }
+
+    private WritableMap objectToWritableMapByGetters(Object obj, int depth) {
+        WritableMap map = new WritableNativeMap();
+        Method[] methods = obj.getClass().getMethods();
+        for (Method method : methods) {
+            String name = method.getName();
+            if (method.getParameterTypes().length != 0) {
+                continue;
+            }
+            if ("getClass".equals(name)) {
+                continue;
+            }
+            if (name.startsWith("get") && name.length() > 3) {
+                String key = Character.toLowerCase(name.charAt(3)) + name.substring(4);
+                try {
+                    Object value = method.invoke(obj);
+                    Object converted = objectToWritable(value, depth);
+                    putToMap(map, key, converted);
+                } catch (Exception ignore) {
+                }
+            } else if (name.startsWith("is") && name.length() > 2) {
+                String key = Character.toLowerCase(name.charAt(2)) + name.substring(3);
+                try {
+                    Object value = method.invoke(obj);
+                    Object converted = objectToWritable(value, depth);
+                    putToMap(map, key, converted);
+                } catch (Exception ignore) {
+                }
+            }
+        }
+        if (map.toString().equals("{}")) {
+            map.putString("value", String.valueOf(obj));
+        }
+        return map;
+    }
+
+    private void putToMap(WritableMap map, String key, Object value) {
+        if (value == null) {
+            map.putNull(key);
+        } else if (value instanceof String) {
+            map.putString(key, (String) value);
+        } else if (value instanceof Integer) {
+            map.putInt(key, (Integer) value);
+        } else if (value instanceof Double) {
+            map.putDouble(key, (Double) value);
+        } else if (value instanceof Float) {
+            map.putDouble(key, ((Float) value).doubleValue());
+        } else if (value instanceof Long) {
+            map.putDouble(key, ((Long) value).doubleValue());
+        } else if (value instanceof Boolean) {
+            map.putBoolean(key, (Boolean) value);
+        } else if (value instanceof WritableMap) {
+            map.putMap(key, (WritableMap) value);
+        } else if (value instanceof WritableArray) {
+            map.putArray(key, (WritableArray) value);
+        } else {
+            map.putString(key, String.valueOf(value));
+        }
+    }
+
+    private void pushToArray(WritableArray array, Object value) {
+        if (value == null) {
+            array.pushNull();
+        } else if (value instanceof String) {
+            array.pushString((String) value);
+        } else if (value instanceof Integer) {
+            array.pushInt((Integer) value);
+        } else if (value instanceof Double) {
+            array.pushDouble((Double) value);
+        } else if (value instanceof Float) {
+            array.pushDouble(((Float) value).doubleValue());
+        } else if (value instanceof Long) {
+            array.pushDouble(((Long) value).doubleValue());
+        } else if (value instanceof Boolean) {
+            array.pushBoolean((Boolean) value);
+        } else if (value instanceof WritableMap) {
+            array.pushMap((WritableMap) value);
+        } else if (value instanceof WritableArray) {
+            array.pushArray((WritableArray) value);
+        } else {
+            array.pushString(String.valueOf(value));
+        }
+    }
+}

package/android/src/main/java/com/fxzs.rnbeidou/view/CompassManager.java

@@ -1,23 +1,15 @@
 package com.fxzs.rnbeidou.view;
 
-import android.view.View;
-
 import androidx.annotation.NonNull;
 
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.common.MapBuilder;
 import com.facebook.react.uimanager.SimpleViewManager;
 import com.facebook.react.uimanager.ThemedReactContext;
-import com.facebook.react.uimanager.annotations.ReactProp;
-import com.facebook.react.modules.core.DeviceEventManagerModule;
+import java.util.Map;
 
 public class CompassManager extends SimpleViewManager<CompassView> {
     public static final String REACT_CLASS = "CompassView";
 
-    private CompassView compassView;
-
-    public CompassManager(ReactApplicationContext reactContext) {}
-
     @NonNull
     @Override
     public String getName() {
@@ -27,15 +19,23 @@ public class CompassManager extends SimpleViewManager<CompassView> {
     @NonNull
     @Override
     protected CompassView createViewInstance(@NonNull ThemedReactContext reactContext) {
-        compassView = new CompassView(reactContext, null);
-        return compassView;
+        return new CompassView(reactContext, null);
+    }
+
+    @Override
+    public Map<String, Object> getExportedCustomBubblingEventTypeConstants() {
+        return MapBuilder.of(
+                "onHeadingChange",
+                MapBuilder.of(
+                        "phasedRegistrationNames",
+                        MapBuilder.of("bubbled", "onHeadingChange")
+                )
+        );
     }
 
     @Override
     public void onDropViewInstance(@NonNull CompassView view) {
         super.onDropViewInstance(view);
-        if (compassView != null) {
-            compassView.stop();
-        }
+        view.stop();
     }
 }

package/android/src/main/java/com/fxzs.rnbeidou/view/CompassView.java

@@ -14,8 +14,10 @@ import android.util.Log;
 import android.view.HapticFeedbackConstants;
 import android.view.View;
 
+import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
 
 public class CompassView extends View implements SensorEventListener {
     private static final String TAG = "OptimizedCompassView";
@@ -244,9 +246,13 @@ public class CompassView extends View implements SensorEventListener {
 
     private void sendDirectionUpdate(float azimuth) {
         if (getContext() instanceof ReactContext) {
-            ((ReactContext) getContext())
-                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                    .emit("onCompassUpdate", azimuth);
+            ReactContext reactContext = (ReactContext) getContext();
+            WritableMap event = Arguments.createMap();
+            event.putDouble("degrees", azimuth);
+            event.putDouble("radians", -Math.toRadians(azimuth));
+            reactContext
+                    .getJSModule(RCTEventEmitter.class)
+                    .receiveEvent(getId(), "onHeadingChange", event);
         }
     }
     public void start() {