@bits-innovate/react-native-vstarcam 1.0.41 → 1.0.43

package/android/src/main/java/com/reactnativevstarcam/VStarCamModule.java

@@ -11,7 +11,6 @@ import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
 import java.io.BufferedReader;
@@ -35,22 +34,22 @@ import org.json.JSONObject;
  * 
  * Implements P2P camera connectivity using the VStarCam SDK.
  * Uses JNI calls to the native OKSMARTPPCS library via JNIApi class.
+ * 
+ * JNI API Methods (discovered via reflection):
+ *   - create(String did, String serverParam) -> long clientPtr
+ *   - connect(long clientPtr, int timeout, String serverParam, int connectType) 
+ *   - login(long clientPtr, String username, String password)
+ *   - disconnect(long clientPtr)
+ *   - destroy(long clientPtr)
+ *   - writeCgi(long clientPtr, String cgi, int timeout)
+ *   - init(ClientStateListener, ClientCommandListener, ClientReleaseListener)
  */
-@ReactModule(name = "VStarCam")
 public class VStarCamModule extends ReactContextBaseJavaModule {
     private static final String TAG = "VStarCamModule";
-    public static final String MODULE_NAME = "VStarCam";
+    private static final String MODULE_NAME = "VStarCam";
     
     // Set to true for verbose logging during development
-    private static final boolean DEBUG_LOGGING = true;
-    
-    // Counter for unique internal client IDs
-    private static final java.util.concurrent.atomic.AtomicInteger nextClientPtr = new java.util.concurrent.atomic.AtomicInteger(1000);
-    
-    // Static proxy references to prevent GC. 
-    private static Object stateListenerProxy;
-    private static Object commandListenerProxy;
-    private static Object releaseListenerProxy;
+    private static final boolean DEBUG_LOGGING = false;
     
     // Helper for conditional debug logging
     private static void logDebug(String message) {
@@ -78,8 +77,6 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
         put("VSKM", "EIHGFNBAKMIIGLJEEAHKFEEJHLNBHCNIGFFDBLCMAKJNLELPDDAGCNOOGILMJFLJAOMKLADEOEMJAPCDJCNPJF:veepai2024");
         put("VSLL", "EIHGFOBBKKIOGNJKENHHFKEEGMNOHLMNHBFKBBDOAHJBLMKIDLAJCAPIGDLBJGLKAOMILNDJOJMGAHCLJHNMJG:veepai2024");
         put("ACAE", "EEGDFHBLKGJIGEJLEKGOFMEDHAMHHJNAGGFABMCOBGJOLHLJDFAFCPPHGILKIKLMANNHKEDKOINIBNCPJOMK:vstarcam2018"); // Try VSTH params
-        put("ACDG", "EEGDFHBLKGJIGEJLEKGOFMEDHAMHHJNAGGFABMCOBGJOLHLJDFAFCPPHGILKIKLMANNHKEDKOINIBNCPJOMK:vstarcam2018"); // Same as ACAE/VSTH
-        put("ACAQ", "EEGDFHBLKGJIGEJLEKGOFMEDHAMHHJNAGGFABMCOBGJOLHLJDFAFCPPHGILKIKLMANNHKEDKOINIBNCPJOMK:vstarcam2018"); // Same as ACAE/VSTH
         // Fallback for unknown prefixes
         put("DEFAULT", "EBGBEMBMKGJMGAJPEIGIFKEGHBMCHMNFGKEGBFCBBMJELILDCJADCIOLHHLLJBKEAMMBLCDGONMDBJCJJPNFJP");
     }};
@@ -99,7 +96,56 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
         return param;
     }
     
-
+    // Pattern to detect virtual UIDs (like ACAE0001151GWYQ)
+    // Virtual UIDs: start with letters, have 7+ digits, end with letters
+    private static final Pattern VIRTUAL_UID_PATTERN = Pattern.compile("^[a-zA-Z]{1,}\\d{7,}.*[a-zA-Z]$");
+    
+    // Check if a device ID is a virtual UID that needs conversion
+    private static boolean isVirtualId(String deviceId) {
+        if (deviceId == null || deviceId.length() < 10) return false;
+        return VIRTUAL_UID_PATTERN.matcher(deviceId).matches();
+    }
+    
+    // Convert virtual UID to real client ID using VStarCam API
+    // Returns: {uid, supplier, cluster} or null on failure
+    private String[] convertVirtualUid(String virtualUid) {
+        try {
+            URL url = new URL("https://vuid.eye4.cn?vuid=" + virtualUid);
+            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+            conn.setRequestMethod("GET");
+            conn.setConnectTimeout(10000);
+            conn.setReadTimeout(10000);
+            conn.setRequestProperty("Content-Type", "application/json; charset=utf-8");
+            
+            int responseCode = conn.getResponseCode();
+            if (responseCode == 200) {
+                BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
+                StringBuilder response = new StringBuilder();
+                String line;
+                while ((line = reader.readLine()) != null) {
+                    response.append(line);
+                }
+                reader.close();
+                
+                JSONObject json = new JSONObject(response.toString());
+                String uid = json.optString("uid", null);
+                String supplier = json.optString("supplier", "");
+                String cluster = json.optString("cluster", "");
+                
+                if (uid != null && !uid.isEmpty()) {
+                    Log.d(TAG, "Converted virtual UID " + virtualUid + " -> real UID: " + uid + " (supplier: " + supplier + ", cluster: " + cluster + ")");
+                    return new String[]{uid, supplier, cluster};
+                }
+            } else {
+                Log.e(TAG, "Virtual UID conversion failed, HTTP " + responseCode);
+            }
+            conn.disconnect();
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to convert virtual UID: " + e.getMessage(), e);
+        }
+        return null;
+    }
+    
     private final ReactApplicationContext reactContext;
     private final ExecutorService executor;
     
@@ -116,7 +162,8 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
     private Class<?> releaseListenerClass = null;
     
     private static class ClientInfo {
-        String deviceId;          // Original device ID
+        String deviceId;          // Original device ID (can be virtual UID)
+        String realClientId;      // Converted client ID (for JNI calls)
         long sdkClientPtr = 0;    // Actual SDK client pointer (long)
         boolean isConnected = false;
         boolean isLoggedIn = false;
@@ -158,11 +205,25 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
                 Log.d(TAG, "JNIApi class found: " + jniApiClass.getName());
                 
                 // Load listener interfaces
-                stateListenerClass = Class.forName("com.vstarcam.app_p2p_api.ClientStateListener", true, jniApiClass.getClassLoader());
-                commandListenerClass = Class.forName("com.vstarcam.app_p2p_api.ClientCommandListener", true, jniApiClass.getClassLoader());
-                releaseListenerClass = Class.forName("com.vstarcam.app_p2p_api.ClientReleaseListener", true, jniApiClass.getClassLoader());
+                stateListenerClass = Class.forName("com.vstarcam.app_p2p_api.ClientStateListener");
+                commandListenerClass = Class.forName("com.vstarcam.app_p2p_api.ClientCommandListener");
+                releaseListenerClass = Class.forName("com.vstarcam.app_p2p_api.ClientReleaseListener");
                 Log.d(TAG, "Listener interfaces loaded");
                 
+                // Log all methods on each listener for debugging
+                Log.d(TAG, "ClientStateListener methods:");
+                for (Method m : stateListenerClass.getDeclaredMethods()) {
+                    Log.d(TAG, "  -> " + m.getName() + "(" + java.util.Arrays.toString(m.getParameterTypes()) + ")");
+                }
+                Log.d(TAG, "ClientCommandListener methods:");
+                for (Method m : commandListenerClass.getDeclaredMethods()) {
+                    Log.d(TAG, "  -> " + m.getName() + "(" + java.util.Arrays.toString(m.getParameterTypes()) + ")");
+                }
+                Log.d(TAG, "ClientReleaseListener methods:");
+                for (Method m : releaseListenerClass.getDeclaredMethods()) {
+                    Log.d(TAG, "  -> " + m.getName() + "(" + java.util.Arrays.toString(m.getParameterTypes()) + ")");
+                }
+                
                 // Initialize P2P system with listeners
                 initializeP2P();
             } catch (ClassNotFoundException e) {
@@ -182,24 +243,15 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
         
         try {
             // Create dynamic proxy for ClientStateListener
-            stateListenerProxy = Proxy.newProxyInstance(
+            Object stateListener = Proxy.newProxyInstance(
                 stateListenerClass.getClassLoader(),
                 new Class<?>[] { stateListenerClass },
                 new InvocationHandler() {
                     @Override
                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                         try {
-                            String methodName = method.getName();
-                            
-                            // Handle standard Object methods
-                            if (method.getDeclaringClass() == Object.class) {
-                                if (methodName.equals("equals")) return proxy == args[0];
-                                if (methodName.equals("hashCode")) return System.identityHashCode(proxy);
-                                if (methodName.equals("toString")) return proxy.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(proxy));
-                            }
-
-                            Log.d(TAG, "ClientStateListener." + methodName + " called");
-                            if (methodName.equals("stateListener")) {
+                            Log.d(TAG, "ClientStateListener." + method.getName() + " called with " + (args != null ? args.length : 0) + " args");
+                            if (method.getName().equals("stateListener")) {
                                 // args: long clientPtr, int state
                                 final long clientPtr = (Long) args[0];
                                 final int state = (Integer) args[1];
@@ -224,34 +276,26 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
             );
             
             // Create dynamic proxy for ClientCommandListener
-            commandListenerProxy = Proxy.newProxyInstance(
+            Object commandListener = Proxy.newProxyInstance(
                 commandListenerClass.getClassLoader(),
                 new Class<?>[] { commandListenerClass },
                 new InvocationHandler() {
                     @Override
                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                         try {
-                            String methodName = method.getName();
-                            
-                            // Handle standard Object methods
-                            if (method.getDeclaringClass() == Object.class) {
-                                if (methodName.equals("equals")) return proxy == args[0];
-                                if (methodName.equals("hashCode")) return System.identityHashCode(proxy);
-                                if (methodName.equals("toString")) return proxy.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(proxy));
-                            }
-
-                            Log.d(TAG, "ClientCommandListener." + methodName + " called");
-                            if (methodName.equals("commandListener")) {
-                                final long sdkPtr = (Long) args[0];
+                            Log.d(TAG, "ClientCommandListener." + method.getName() + " called with " + (args != null ? args.length : 0) + " args");
+                            if (method.getName().equals("commandListener")) {
+                                // args: long clientPtr, byte[] data, int length (from interface)
+                                final long clientPtr = (Long) args[0];
                                 final byte[] data = (byte[]) args[1];
                                 final int length = (Integer) args[2];
-                                Log.d(TAG, "Command callback: sdkPtr=" + sdkPtr + ", len=" + length);
+                                Log.d(TAG, "Command callback: clientPtr=" + clientPtr + ", dataLen=" + (data != null ? data.length : 0));
                                 
                                 if (reactContext != null) {
                                     reactContext.runOnUiQueueThread(new Runnable() {
                                         @Override
                                         public void run() {
-                                            handleCommandReceive(sdkPtr, 0, data);
+                                            handleCommandReceive(clientPtr, 0, data);
                                         }
                                     });
                                 }
@@ -265,23 +309,14 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
             );
             
             // Create dynamic proxy for ClientReleaseListener
-            releaseListenerProxy = Proxy.newProxyInstance(
+            Object releaseListener = Proxy.newProxyInstance(
                 releaseListenerClass.getClassLoader(),
                 new Class<?>[] { releaseListenerClass },
                 new InvocationHandler() {
                     @Override
                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                         try {
-                            String methodName = method.getName();
-                            
-                            // Handle standard Object methods
-                            if (method.getDeclaringClass() == Object.class) {
-                                if (methodName.equals("equals")) return proxy == args[0];
-                                if (methodName.equals("hashCode")) return System.identityHashCode(proxy);
-                                if (methodName.equals("toString")) return proxy.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(proxy));
-                            }
-
-                            Log.d(TAG, "ClientReleaseListener." + methodName + " called");
+                            Log.d(TAG, "ClientReleaseListener." + method.getName() + " called");
                         } catch (Exception e) {
                             Log.e(TAG, "Error in releaseListener callback", e);
                         }
@@ -293,7 +328,7 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
             // Call JNIApi.init(stateListener, commandListener, releaseListener)
             Method initMethod = jniApiClass.getMethod("init", 
                 stateListenerClass, commandListenerClass, releaseListenerClass);
-            initMethod.invoke(null, stateListenerProxy, commandListenerProxy, releaseListenerProxy);
+            initMethod.invoke(null, stateListener, commandListener, releaseListener);
             
             isP2PInitialized = true;
             Log.d(TAG, "P2P system initialized successfully!");
@@ -383,10 +418,23 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
                     return;
                 }
                 
-                // Call JNIApi.create(did, serverParam)
-                String serviceParam = getServiceParam(deviceId);
+                // Check if this is a virtual UID that needs conversion
+                String realClientId = deviceId;
+                if (isVirtualId(deviceId)) {
+                    Log.d(TAG, "Device ID " + deviceId + " looks like a virtual UID, converting...");
+                    String[] conversionResult = convertVirtualUid(deviceId);
+                    if (conversionResult != null && conversionResult[0] != null) {
+                        realClientId = conversionResult[0];
+                        Log.d(TAG, "Using converted client ID: " + realClientId);
+                    } else {
+                        Log.w(TAG, "Virtual UID conversion failed, trying with original ID");
+                    }
+                }
+                
+                // Call JNIApi.create(did, serverParam) with real client ID
+                String serviceParam = getServiceParam(realClientId);  // Use real client ID prefix
                 Method createMethod = jniApiClass.getMethod("create", String.class, String.class);
-                Object result = createMethod.invoke(null, deviceId, serviceParam);
+                Object result = createMethod.invoke(null, realClientId, serviceParam);
                 long sdkClientPtr = (Long) result;
                 
                 Log.d(TAG, "JNIApi.create result: " + sdkClientPtr);
@@ -402,10 +450,11 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
                 
                 ClientInfo clientInfo = new ClientInfo();
                 clientInfo.deviceId = deviceId;
+                clientInfo.realClientId = realClientId;  // Store the converted ID
                 clientInfo.sdkClientPtr = sdkClientPtr;
                 clients.put(ourClientPtr, clientInfo);
                 
-                Log.d(TAG, "Created client: ourPtr=" + ourClientPtr + ", sdkPtr=" + sdkClientPtr);
+                Log.d(TAG, "Created client: ourPtr=" + ourClientPtr + ", sdkPtr=" + sdkClientPtr + ", realId=" + realClientId);
                 promise.resolve(ourClientPtr);
             } catch (Exception e) {
                 Log.e(TAG, "clientCreate failed", e);
@@ -441,10 +490,11 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
                 params.putInt("state", 1); // CONNECTING
                 sendEvent("onConnectionStateChanged", params);
                 
-                // Construct the service param string
+                // Use realClientId for service param lookup (it has the correct prefix like VSTN)
+                String realId = clientInfo.realClientId != null ? clientInfo.realClientId : clientInfo.deviceId;
                 String param = (serverParam != null && !serverParam.isEmpty()) 
                     ? serverParam 
-                    : getServiceParam(clientInfo.deviceId);
+                    : getServiceParam(realId);
                 
                 // Default connectType to 126 (from V1 app) if not specified
                 // connectType 126 = P2P/Relay combination that works reliably
@@ -458,8 +508,8 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
                 Log.d(TAG, "Calling JNIApi.connect(" + clientInfo.sdkClientPtr + ", 15, " + param + ", " + actualConnectType + ")");
                 
                 try {
-                    Object result = connectMethod.invoke(null, clientInfo.sdkClientPtr, 15, param, actualConnectType);
-                    Log.d(TAG, "JNIApi.connect result: " + result);
+                    connectMethod.invoke(null, clientInfo.sdkClientPtr, 15, param, actualConnectType);
+                    Log.d(TAG, "JNIApi.connect returned normally");
                 } catch (java.lang.reflect.InvocationTargetException ite) {
                     Log.e(TAG, "JNIApi.connect threw exception: " + ite.getCause(), ite.getCause());
                     throw ite;
@@ -512,21 +562,34 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
                 Method loginMethod = jniApiClass.getMethod("login", 
                     long.class, String.class, String.class);
                 
-                Log.d(TAG, "Calling JNIApi.login(" + clientInfo.sdkClientPtr + ", " + username + ")");
+                Log.d(TAG, "Calling JNIApi.login(" + clientInfo.sdkClientPtr + ", " + username + ", ***)");
                 
+                boolean loginSuccess = false;
                 try {
                     loginMethod.invoke(null, clientInfo.sdkClientPtr, username, password);
-                } catch (Exception e) {
-                    Log.e(TAG, "Login failed: " + e.getMessage());
+                    Log.d(TAG, "JNIApi.login returned normally");
+                    loginSuccess = true;
+                } catch (java.lang.reflect.InvocationTargetException ite) {
+                    Throwable cause = ite.getCause();
+                    Log.e(TAG, "JNIApi.login threw exception: " + cause, cause);
+                    // Don't rethrow - return false instead to prevent crash
+                    promise.resolve(false);
+                    return;
+                } catch (Throwable t) {
+                    Log.e(TAG, "JNIApi.login crashed: " + t.getMessage(), t);
+                    // Don't rethrow - return false instead to prevent crash
                     promise.resolve(false);
                     return;
                 }
                 
-                clientInfo.isLoggedIn = true;
-                clientInfo.username = username;
-                clientInfo.password = password;
+                if (loginSuccess) {
+                    clientInfo.isLoggedIn = true;
+                    clientInfo.username = username;
+                    clientInfo.password = password;
+                }
                 
-                promise.resolve(true);
+                Log.d(TAG, "JNIApi.login completed with result: " + loginSuccess);
+                promise.resolve(loginSuccess);
             } catch (Exception e) {
                 Log.e(TAG, "clientLogin failed", e);
                 promise.reject("LOGIN_ERROR", e.getMessage());
@@ -651,42 +714,6 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
         });
     }
 
-    /**
-     * Get device information
-     */
-    @ReactMethod
-    public void clientGetDeviceInfo(int clientPtr, Promise promise) {
-        executor.execute(() -> {
-            try {
-                ClientInfo clientInfo = clients.get(clientPtr);
-                if (clientInfo == null) {
-                    promise.reject("E_CLIENT_NOT_FOUND", "Client not found");
-                    return;
-                }
-
-                WritableMap result = Arguments.createMap();
-                result.putString("serialNumber", clientInfo.deviceId);
-                result.putString("model", "VStarCam");
-                result.putString("firmware", "Unknown");
-                result.putString("manufacturer", "VStarCam");
-                result.putBoolean("responsive", clientInfo.isConnected);
-                
-                WritableMap features = Arguments.createMap();
-                features.putBoolean("ptz", true);
-                features.putBoolean("audio", true);
-                features.putBoolean("twoWayAudio", true);
-                features.putBoolean("nightVision", true);
-                features.putBoolean("motionDetection", true);
-                features.putBoolean("wifi", true);
-                result.putMap("features", features);
-
-                promise.resolve(result);
-            } catch (Exception e) {
-                promise.reject("E_GET_INFO_FAILED", e.getMessage());
-            }
-        });
-    }
-
     /**
      * Start video stream by sending livestream.cgi command
      * Resolution: 1=high, 2=general, 4=low, 100=superHD

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bits-innovate/react-native-vstarcam",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "description": "React Native bridge for VStarCam P2P SDK",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/index.ts

@@ -288,6 +288,14 @@ class VStarCamClient {
     return VStarCamModule.clientCheckMode(this.clientPtr);
   }
 
+  /**
+   * Get the current connection state of the client
+   */
+  async getState(): Promise<any> {
+    if (!this.clientPtr) return { state: 5, isConnected: false };
+    return VStarCamModule.clientGetState(this.clientPtr);
+  }
+
   /**
    * Login to the camera
    * @param username Camera username (default: admin)