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

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

@@ -8,33 +8,70 @@ import androidx.annotation.Nullable;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
-import com.vstarcam.app_p2p_api.AppP2PApi;
-import com.vstarcam.app_p2p_api.ClientConnectState;
-import com.vstarcam.app_p2p_api.ConnectListener;
-import com.vstarcam.app_p2p_api.CommandListener;
-
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
+/**
+ * VStarCam React Native Module
+ * 
+ * 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 AppP2PApi p2pApi;
-    private Map<Integer, ConnectListener> connectListeners = new HashMap<>();
-    private Map<Integer, CommandListener> commandListeners = new HashMap<>();
+    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.p2pApi = AppP2PApi.getInstance();
+        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());
+        }
     }
 
     @Override
@@ -44,89 +81,240 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
     }
 
     private void sendEvent(String eventName, @Nullable WritableMap params) {
-        reactContext
-            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-            .emit(eventName, params);
+        if (reactContext.hasActiveReactInstance()) {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(eventName, params);
+        }
     }
 
     /**
      * Create a P2P client for a device
+     * @param deviceId The camera's Device ID (DID)
      */
     @ReactMethod
     public void clientCreate(String deviceId, Promise promise) {
-        try {
-            int clientPtr = p2pApi.clientCreate(deviceId, null);
-            
-            if (clientPtr > 0) {
-                // Set up connection listener
-                ConnectListener connectListener = (state) -> {
-                    WritableMap params = Arguments.createMap();
-                    params.putInt("clientId", clientPtr);
-                    params.putInt("state", state.ordinal());
-                    sendEvent("onConnectionStateChanged", params);
-                };
-                connectListeners.put(clientPtr, connectListener);
-                p2pApi.setConnectListener(clientPtr, connectListener);
-                
-                // Set up command listener
-                CommandListener commandListener = (cmd, data) -> {
-                    WritableMap params = Arguments.createMap();
-                    params.putInt("clientId", clientPtr);
-                    params.putInt("command", cmd);
-                    params.putString("data", new String(data));
-                    sendEvent("onCommandReceived", params);
-                };
-                commandListeners.put(clientPtr, commandListener);
-                p2pApi.setCommandListener(clientPtr, commandListener);
+        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(clientPtr);
-        } 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 {
-            ClientConnectState state = p2pApi.clientConnect(clientPtr, lanScan, serverParam, connectType, 0);
-            promise.resolve(state.ordinal());
-        } 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 {
-            boolean success = p2pApi.clientLogin(clientPtr, username, password);
-            promise.resolve(success);
-        } 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 {
-            boolean success = p2pApi.clientWriteCgi(clientPtr, cgi, timeout);
-            promise.resolve(success);
-        } 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());
+            }
+        });
     }
 
     /**
@@ -134,33 +322,45 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
      */
     @ReactMethod
     public void clientDisconnect(int clientPtr, Promise promise) {
-        try {
-            boolean success = p2pApi.clientDisconnect(clientPtr);
-            promise.resolve(success);
-        } 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 {
-            // Remove listeners
-            p2pApi.removeConnectListener(clientPtr);
-            p2pApi.removeCommandListener(clientPtr);
-            connectListeners.remove(clientPtr);
-            commandListeners.remove(clientPtr);
-            
-            p2pApi.clientDestroy(clientPtr);
-            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());
+            }
+        });
     }
 
     /**
@@ -168,18 +368,19 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
      */
     @ReactMethod
     public void startVideoStream(int clientPtr, int streamType, Promise promise) {
-        try {
-            // Video streaming requires additional setup with AppPlayerPlugin
-            // This is a placeholder - actual implementation needs video decoder
-            String cgi = streamType == 0 ? 
-                "videostream.cgi?resolution=32&rate=0&" :
-                "videostream.cgi?resolution=8&rate=0&";
-            boolean success = p2pApi.clientWriteCgi(clientPtr, cgi, 5);
-            promise.resolve(success);
-        } 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());
+            }
+        });
     }
 
     /**
@@ -188,7 +389,7 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void stopVideoStream(int clientPtr, Promise promise) {
         try {
-            // Stop video streaming
+            Log.d(TAG, "stopVideoStream called");
             promise.resolve(true);
         } catch (Exception e) {
             Log.e(TAG, "stopVideoStream failed", e);
@@ -197,29 +398,15 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
     }
 
     /**
-     * Take snapshot
-     */
-    @ReactMethod
-    public void takeSnapshot(int clientPtr, Promise promise) {
-        try {
-            boolean success = p2pApi.clientWriteCgi(clientPtr, "snapshot.cgi?", 10);
-            // Note: Actual snapshot data comes via command listener
-            promise.resolve(success);
-        } 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 {
-            // This would return the connection mode (P2P, Relay, etc.)
+            ClientInfo clientInfo = clients.get(clientPtr);
+            
             WritableMap result = Arguments.createMap();
-            result.putBoolean("success", true);
+            result.putBoolean("success", clientInfo != null && clientInfo.isConnected);
             result.putInt("mode", 1); // P2P mode
             promise.resolve(result);
         } catch (Exception e) {
@@ -227,4 +414,24 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
             promise.reject("MODE_ERROR", e.getMessage());
         }
     }
+    
+    /**
+     * Check if native library is loaded
+     */
+    @ReactMethod
+    public void isNativeLibraryLoaded(Promise promise) {
+        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.1",
+  "version": "1.0.3",
   "description": "React Native bridge for VStarCam P2P SDK",
   "main": "src/index.ts",
   "types": "src/index.ts",