@bits-innovate/react-native-vstarcam 1.0.2 → 1.0.3

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

@@ -13,32 +13,64 @@ import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
 /**
  * VStarCam React Native Module
  * 
- * Provides P2P camera connectivity, WiFi configuration, video streaming, and PTZ control.
- * 
- * Note: This is a simplified implementation that uses the VStarCam JNI layer.
- * For full functionality, the native JNI methods need to be properly integrated.
+ * Implements P2P camera connectivity using the VStarCam SDK.
+ * Currently uses simulation with architecture ready for real JNI integration.
  */
 public class VStarCamModule extends ReactContextBaseJavaModule {
     private static final String TAG = "VStarCamModule";
     private static final String MODULE_NAME = "VStarCam";
     
+    // P2P Server parameter - used for cloud relay connection
+    private static final String P2P_SERVER_PARAM = "EBGNAKFCKFCDDNJCNHFDFKNJKLDGCMGPPJLKLLMF:1234";
+    
     private final ReactApplicationContext reactContext;
-    private int currentClientPtr = 0;
-    private boolean isConnected = false;
+    private final ExecutorService executor;
+    
+    // Client tracking
+    private Map<Integer, ClientInfo> clients = new HashMap<>();
+    private boolean isNativeLibraryLoaded = false;
+    
+    private static class ClientInfo {
+        String deviceId;
+        int sessionHandle = -1;
+        boolean isConnected = false;
+        boolean isLoggedIn = false;
+    }
 
     public VStarCamModule(ReactApplicationContext reactContext) {
         super(reactContext);
         this.reactContext = reactContext;
+        this.executor = Executors.newCachedThreadPool();
         
         // Load the native library
         try {
             System.loadLibrary("OKSMARTPPCS");
+            isNativeLibraryLoaded = true;
             Log.d(TAG, "VStarCam native library loaded successfully");
+            
+            // Initialize P2P system
+            initializeP2P();
         } catch (UnsatisfiedLinkError e) {
             Log.e(TAG, "Failed to load VStarCam native library: " + e.getMessage());
+            isNativeLibraryLoaded = false;
+        }
+    }
+    
+    private void initializeP2P() {
+        try {
+            // Call JNIApi initialization
+            // The exact method signature needs to be determined from the AAR
+            Log.d(TAG, "P2P system initialized");
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to initialize P2P: " + e.getMessage());
         }
     }
 
@@ -58,81 +90,231 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
 
     /**
      * Create a P2P client for a device
+     * @param deviceId The camera's Device ID (DID)
      */
     @ReactMethod
     public void clientCreate(String deviceId, Promise promise) {
-        try {
-            Log.d(TAG, "clientCreate called with deviceId: " + deviceId);
-            
-            // Generate a simple client pointer
-            currentClientPtr = deviceId.hashCode();
-            if (currentClientPtr < 0) {
-                currentClientPtr = -currentClientPtr;
+        executor.execute(() -> {
+            try {
+                Log.d(TAG, "clientCreate called with deviceId: " + deviceId);
+                
+                // Generate a unique client pointer
+                int clientPtr = deviceId.hashCode();
+                if (clientPtr < 0) clientPtr = -clientPtr;
+                
+                ClientInfo clientInfo = new ClientInfo();
+                clientInfo.deviceId = deviceId;
+                clients.put(clientPtr, clientInfo);
+                
+                Log.d(TAG, "Created client with ptr: " + clientPtr);
+                promise.resolve(clientPtr);
+            } catch (Exception e) {
+                Log.e(TAG, "clientCreate failed", e);
+                promise.reject("CREATE_ERROR", e.getMessage());
             }
-            
-            promise.resolve(currentClientPtr);
-        } catch (Exception e) {
-            Log.e(TAG, "clientCreate failed", e);
-            promise.reject("CREATE_ERROR", e.getMessage());
-        }
+        });
     }
 
     /**
      * Connect to camera via P2P
+     * @param clientPtr Client pointer from clientCreate
+     * @param lanScan Whether to scan LAN for device
+     * @param serverParam P2P server parameter for cloud relay
+     * @param connectType Connection type (0=P2P, 1=Relay, etc.)
      */
     @ReactMethod
     public void clientConnect(int clientPtr, boolean lanScan, String serverParam, int connectType, Promise promise) {
-        try {
-            Log.d(TAG, "clientConnect called for client: " + clientPtr);
-            
-            // TODO: Implement actual P2P connection using JNI
-            // For now, simulate successful connection
-            isConnected = true;
-            
-            // Emit connection state change
-            WritableMap params = Arguments.createMap();
-            params.putInt("clientId", clientPtr);
-            params.putInt("state", 3); // ONLINE state
-            sendEvent("onConnectionStateChanged", params);
-            
-            // Return ONLINE state (3)
-            promise.resolve(3);
-        } catch (Exception e) {
-            Log.e(TAG, "clientConnect failed", e);
-            promise.reject("CONNECT_ERROR", e.getMessage());
-        }
+        executor.execute(() -> {
+            try {
+                Log.d(TAG, "clientConnect called for client: " + clientPtr);
+                
+                ClientInfo clientInfo = clients.get(clientPtr);
+                if (clientInfo == null) {
+                    promise.reject("CONNECT_ERROR", "Client not found");
+                    return;
+                }
+                
+                // Use provided server param or default
+                String param = (serverParam != null && !serverParam.isEmpty()) 
+                    ? serverParam 
+                    : P2P_SERVER_PARAM;
+                
+                // Emit connecting state
+                WritableMap params = Arguments.createMap();
+                params.putInt("clientId", clientPtr);
+                params.putInt("state", 1); // CONNECTING
+                sendEvent("onConnectionStateChanged", params);
+                
+                // TODO: Call actual JNI connection method
+                // For now, simulate successful connection after delay
+                Thread.sleep(1000);
+                
+                // Simulate successful connection
+                clientInfo.isConnected = true;
+                
+                // Emit online state
+                params = Arguments.createMap();
+                params.putInt("clientId", clientPtr);
+                params.putInt("state", 3); // ONLINE
+                sendEvent("onConnectionStateChanged", params);
+                
+                // Return ONLINE state (3)
+                promise.resolve(3);
+            } catch (Exception e) {
+                Log.e(TAG, "clientConnect failed", e);
+                
+                // Emit connection failed state
+                WritableMap params = Arguments.createMap();
+                params.putInt("clientId", clientPtr);
+                params.putInt("state", 4); // CONNECT_FAILED
+                sendEvent("onConnectionStateChanged", params);
+                
+                promise.reject("CONNECT_ERROR", e.getMessage());
+            }
+        });
     }
 
     /**
      * Login to camera
+     * @param clientPtr Client pointer
+     * @param username Camera username (usually "admin")
+     * @param password Camera password (usually "888888")
      */
     @ReactMethod
     public void clientLogin(int clientPtr, String username, String password, Promise promise) {
-        try {
-            Log.d(TAG, "clientLogin called with user: " + username);
-            
-            // TODO: Implement actual login using JNI
-            promise.resolve(true);
-        } catch (Exception e) {
-            Log.e(TAG, "clientLogin failed", e);
-            promise.reject("LOGIN_ERROR", e.getMessage());
-        }
+        executor.execute(() -> {
+            try {
+                Log.d(TAG, "clientLogin called with user: " + username);
+                
+                ClientInfo clientInfo = clients.get(clientPtr);
+                if (clientInfo == null) {
+                    promise.reject("LOGIN_ERROR", "Client not found");
+                    return;
+                }
+                
+                if (!clientInfo.isConnected) {
+                    promise.reject("LOGIN_ERROR", "Not connected");
+                    return;
+                }
+                
+                // Build login CGI command
+                String loginCgi = String.format(
+                    "login.cgi?user=%s&pwd=%s",
+                    username, password
+                );
+                
+                // TODO: Send actual login CGI via P2P
+                // For now, simulate successful login
+                clientInfo.isLoggedIn = true;
+                
+                promise.resolve(true);
+            } catch (Exception e) {
+                Log.e(TAG, "clientLogin failed", e);
+                promise.reject("LOGIN_ERROR", e.getMessage());
+            }
+        });
     }
 
     /**
-     * Send CGI command
+     * Send CGI command to camera
+     * @param clientPtr Client pointer
+     * @param cgi CGI command string (e.g., "set_wifi.cgi?ssid=X&key=Y")
+     * @param timeout Timeout in seconds
      */
     @ReactMethod
     public void clientWriteCgi(int clientPtr, String cgi, int timeout, Promise promise) {
-        try {
-            Log.d(TAG, "clientWriteCgi called with cgi: " + cgi);
-            
-            // TODO: Implement actual CGI command using JNI
-            promise.resolve(true);
-        } catch (Exception e) {
-            Log.e(TAG, "clientWriteCgi failed", e);
-            promise.reject("CGI_ERROR", e.getMessage());
-        }
+        executor.execute(() -> {
+            try {
+                Log.d(TAG, "clientWriteCgi called with cgi: " + cgi);
+                
+                ClientInfo clientInfo = clients.get(clientPtr);
+                if (clientInfo == null) {
+                    promise.reject("CGI_ERROR", "Client not found");
+                    return;
+                }
+                
+                if (!clientInfo.isConnected) {
+                    promise.reject("CGI_ERROR", "Not connected");
+                    return;
+                }
+                
+                // TODO: Send actual CGI command via P2P channel
+                // For now, simulate successful command
+                Thread.sleep(500);
+                
+                // Emit command result
+                WritableMap params = Arguments.createMap();
+                params.putInt("clientId", clientPtr);
+                params.putInt("command", cgi.hashCode());
+                params.putString("data", "OK");
+                sendEvent("onCommandReceived", params);
+                
+                promise.resolve(true);
+            } catch (Exception e) {
+                Log.e(TAG, "clientWriteCgi failed", e);
+                promise.reject("CGI_ERROR", e.getMessage());
+            }
+        });
+    }
+
+    /**
+     * Scan WiFi networks available to the camera
+     * @param clientPtr Client pointer
+     */
+    @ReactMethod
+    public void scanWifi(int clientPtr, Promise promise) {
+        executor.execute(() -> {
+            try {
+                Log.d(TAG, "scanWifi called");
+                
+                // Send WiFi scan CGI
+                String scanCgi = "wifi_scan.cgi?user=admin&pwd=888888";
+                
+                // TODO: Send actual CGI and parse response
+                // For now, return mock data
+                Thread.sleep(1000);
+                
+                // In real implementation, parse XML response from camera
+                WritableMap result = Arguments.createMap();
+                result.putBoolean("success", true);
+                result.putString("networks", "[]"); // Would contain network list
+                
+                promise.resolve(result);
+            } catch (Exception e) {
+                Log.e(TAG, "scanWifi failed", e);
+                promise.reject("WIFI_ERROR", e.getMessage());
+            }
+        });
+    }
+
+    /**
+     * Configure WiFi on camera
+     * @param clientPtr Client pointer
+     * @param ssid WiFi network name
+     * @param password WiFi password
+     * @param authType Authentication type (0=Open, 1=WEP, 2=WPA, etc.)
+     */
+    @ReactMethod
+    public void configureWifi(int clientPtr, String ssid, String password, int authType, Promise promise) {
+        executor.execute(() -> {
+            try {
+                Log.d(TAG, "configureWifi called for SSID: " + ssid);
+                
+                // Build WiFi configuration CGI
+                String wifiCgi = String.format(
+                    "set_wifi.cgi?ssid=%s&key=%s&authtype=%d&enc=0&mode=0&wifienable=1",
+                    ssid, password, authType
+                );
+                
+                // TODO: Send actual CGI command
+                Thread.sleep(500);
+                
+                promise.resolve(true);
+            } catch (Exception e) {
+                Log.e(TAG, "configureWifi failed", e);
+                promise.reject("WIFI_ERROR", e.getMessage());
+            }
+        });
     }
 
     /**
@@ -140,37 +322,45 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
      */
     @ReactMethod
     public void clientDisconnect(int clientPtr, Promise promise) {
-        try {
-            Log.d(TAG, "clientDisconnect called");
-            isConnected = false;
-            
-            // Emit connection state change
-            WritableMap params = Arguments.createMap();
-            params.putInt("clientId", clientPtr);
-            params.putInt("state", 5); // DISCONNECTED state
-            sendEvent("onConnectionStateChanged", params);
-            
-            promise.resolve(true);
-        } catch (Exception e) {
-            Log.e(TAG, "clientDisconnect failed", e);
-            promise.reject("DISCONNECT_ERROR", e.getMessage());
-        }
+        executor.execute(() -> {
+            try {
+                Log.d(TAG, "clientDisconnect called");
+                
+                ClientInfo clientInfo = clients.get(clientPtr);
+                if (clientInfo != null) {
+                    clientInfo.isConnected = false;
+                    clientInfo.isLoggedIn = false;
+                }
+                
+                // Emit disconnect state
+                WritableMap params = Arguments.createMap();
+                params.putInt("clientId", clientPtr);
+                params.putInt("state", 5); // DISCONNECT
+                sendEvent("onConnectionStateChanged", params);
+                
+                promise.resolve(true);
+            } catch (Exception e) {
+                Log.e(TAG, "clientDisconnect failed", e);
+                promise.reject("DISCONNECT_ERROR", e.getMessage());
+            }
+        });
     }
 
     /**
-     * Destroy client and cleanup
+     * Destroy client and cleanup resources
      */
     @ReactMethod
     public void clientDestroy(int clientPtr, Promise promise) {
-        try {
-            Log.d(TAG, "clientDestroy called");
-            currentClientPtr = 0;
-            isConnected = false;
-            promise.resolve(true);
-        } catch (Exception e) {
-            Log.e(TAG, "clientDestroy failed", e);
-            promise.reject("DESTROY_ERROR", e.getMessage());
-        }
+        executor.execute(() -> {
+            try {
+                Log.d(TAG, "clientDestroy called");
+                clients.remove(clientPtr);
+                promise.resolve(true);
+            } catch (Exception e) {
+                Log.e(TAG, "clientDestroy failed", e);
+                promise.reject("DESTROY_ERROR", e.getMessage());
+            }
+        });
     }
 
     /**
@@ -178,15 +368,19 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
      */
     @ReactMethod
     public void startVideoStream(int clientPtr, int streamType, Promise promise) {
-        try {
-            Log.d(TAG, "startVideoStream called");
-            
-            // TODO: Implement video streaming using JNI
-            promise.resolve(true);
-        } catch (Exception e) {
-            Log.e(TAG, "startVideoStream failed", e);
-            promise.reject("VIDEO_ERROR", e.getMessage());
-        }
+        executor.execute(() -> {
+            try {
+                Log.d(TAG, "startVideoStream called");
+                
+                // TODO: Implement video streaming
+                // This requires setting up video decode pipeline
+                
+                promise.resolve(true);
+            } catch (Exception e) {
+                Log.e(TAG, "startVideoStream failed", e);
+                promise.reject("VIDEO_ERROR", e.getMessage());
+            }
+        });
     }
 
     /**
@@ -204,32 +398,16 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
     }
 
     /**
-     * Take snapshot
-     */
-    @ReactMethod
-    public void takeSnapshot(int clientPtr, Promise promise) {
-        try {
-            Log.d(TAG, "takeSnapshot called");
-            
-            // TODO: Implement snapshot using JNI
-            promise.resolve(true);
-        } catch (Exception e) {
-            Log.e(TAG, "takeSnapshot failed", e);
-            promise.reject("SNAPSHOT_ERROR", e.getMessage());
-        }
-    }
-
-    /**
-     * Check connection mode
+     * Check connection mode (P2P, Relay, LAN)
      */
     @ReactMethod
     public void clientCheckMode(int clientPtr, Promise promise) {
         try {
-            Log.d(TAG, "clientCheckMode called");
+            ClientInfo clientInfo = clients.get(clientPtr);
             
             WritableMap result = Arguments.createMap();
-            result.putBoolean("success", true);
-            result.putInt("mode", isConnected ? 1 : 0); // P2P mode if connected
+            result.putBoolean("success", clientInfo != null && clientInfo.isConnected);
+            result.putInt("mode", 1); // P2P mode
             promise.resolve(result);
         } catch (Exception e) {
             Log.e(TAG, "clientCheckMode failed", e);
@@ -242,11 +420,18 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
      */
     @ReactMethod
     public void isNativeLibraryLoaded(Promise promise) {
-        try {
-            // Try to verify the library is loaded
-            promise.resolve(true);
-        } catch (Exception e) {
-            promise.resolve(false);
-        }
+        promise.resolve(isNativeLibraryLoaded);
+    }
+    
+    /**
+     * Get SDK version info
+     */
+    @ReactMethod
+    public void getSdkVersion(Promise promise) {
+        WritableMap result = Arguments.createMap();
+        result.putString("version", "1.0.3");
+        result.putBoolean("nativeLoaded", isNativeLibraryLoaded);
+        result.putString("nativeLib", "OKSMARTPPCS");
+        promise.resolve(result);
     }
 }

package/package.json

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