@bits-innovate/react-native-vstarcam 1.0.7 → 1.0.9

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

@@ -13,7 +13,9 @@ import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
+import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
@@ -23,30 +25,41 @@ import java.util.concurrent.Executors;
  * VStarCam React Native Module
  * 
  * Implements P2P camera connectivity using the VStarCam SDK.
- * Uses JNI calls to the native OKSMARTPPCS library.
+ * 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)
  */
 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
-    // Format: InitString:Port
     private static final String P2P_SERVER_PARAM = "EBGNAKFCKFCDDNJCNHFDFKNJKLDGCMGPPJLKLLMF:1234";
     
     private final ReactApplicationContext reactContext;
     private final ExecutorService executor;
     
-    // Client tracking
+    // Client tracking - maps our clientPtr to actual SDK client handle
     private Map<Integer, ClientInfo> clients = new HashMap<>();
     private boolean isNativeLibraryLoaded = false;
     private boolean isP2PInitialized = false;
     
-    // JNI API class (loaded via reflection)
+    // JNI API class and listener interfaces
     private Class<?> jniApiClass = null;
+    private Class<?> stateListenerClass = null;
+    private Class<?> commandListenerClass = null;
+    private Class<?> releaseListenerClass = null;
     
     private static class ClientInfo {
         String deviceId;
-        int sessionHandle = -1;
+        long sdkClientPtr = 0; // Actual SDK client pointer (long)
         boolean isConnected = false;
         boolean isLoggedIn = false;
     }
@@ -67,29 +80,22 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
             isNativeLibraryLoaded = true;
             Log.d(TAG, "OKSMARTPPCS library loaded successfully");
             
-            // Try to load JNI API class
+            // Load JNI API class
             try {
                 jniApiClass = Class.forName("com.vstarcam.JNIApi");
                 Log.d(TAG, "JNIApi class found: " + jniApiClass.getName());
                 
-                // Log available methods for debugging
-                for (Method m : jniApiClass.getDeclaredMethods()) {
-                    Log.d(TAG, "JNIApi method: " + m.getName());
-                }
-            } catch (ClassNotFoundException e) {
-                Log.w(TAG, "JNIApi class not found, will try AppP2PApiPlugin");
+                // Load listener interfaces
+                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");
                 
-                // Try the Flutter plugin class
-                try {
-                    jniApiClass = Class.forName("com.vstarcam.app_p2p_api.AppP2PApiPlugin");
-                    Log.d(TAG, "AppP2PApiPlugin class found");
-                } catch (ClassNotFoundException e2) {
-                    Log.e(TAG, "No P2P API class found in AAR");
-                }
+                // Initialize P2P system with listeners
+                initializeP2P();
+            } catch (ClassNotFoundException e) {
+                Log.e(TAG, "JNIApi class not found: " + e.getMessage());
             }
-            
-            // Initialize P2P system
-            initializeP2P();
         } catch (UnsatisfiedLinkError e) {
             Log.e(TAG, "Failed to load native library: " + e.getMessage());
             isNativeLibraryLoaded = false;
@@ -97,30 +103,111 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
     }
     
     private void initializeP2P() {
-        if (!isNativeLibraryLoaded) {
-            Log.e(TAG, "Cannot initialize P2P: native library not loaded");
+        if (!isNativeLibraryLoaded || jniApiClass == null) {
+            Log.e(TAG, "Cannot initialize P2P: native library or JNIApi not available");
             return;
         }
         
         try {
-            // Try to call PPCS_Initialize or similar
-            if (jniApiClass != null) {
-                // Look for initialization method
-                try {
-                    Method initMethod = jniApiClass.getMethod("PPCS_Initialize", byte[].class);
-                    byte[] initString = P2P_SERVER_PARAM.getBytes();
-                    Object result = initMethod.invoke(null, initString);
-                    Log.d(TAG, "PPCS_Initialize result: " + result);
-                    isP2PInitialized = true;
-                } catch (NoSuchMethodException e) {
-                    Log.w(TAG, "PPCS_Initialize not found, trying alternative");
-                    // The P2P may already be initialized by loading the library
-                    isP2PInitialized = true;
+            // Create dynamic proxy for ClientStateListener
+            Object stateListener = Proxy.newProxyInstance(
+                stateListenerClass.getClassLoader(),
+                new Class<?>[] { stateListenerClass },
+                new InvocationHandler() {
+                    @Override
+                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                        Log.d(TAG, "ClientStateListener." + method.getName() + " called");
+                        if (method.getName().equals("stateChange")) {
+                            // args: long clientPtr, int state
+                            long clientPtr = (Long) args[0];
+                            int state = (Integer) args[1];
+                            handleStateChange(clientPtr, state);
+                        }
+                        return null;
+                    }
                 }
-            }
-            Log.d(TAG, "P2P system initialization attempted");
+            );
+            
+            // Create dynamic proxy for ClientCommandListener
+            Object commandListener = Proxy.newProxyInstance(
+                commandListenerClass.getClassLoader(),
+                new Class<?>[] { commandListenerClass },
+                new InvocationHandler() {
+                    @Override
+                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                        Log.d(TAG, "ClientCommandListener." + method.getName() + " called");
+                        if (method.getName().equals("commandReceive")) {
+                            // args: long clientPtr, int command, byte[] data, int length
+                            long clientPtr = (Long) args[0];
+                            int command = (Integer) args[1];
+                            byte[] data = (byte[]) args[2];
+                            handleCommandReceive(clientPtr, command, data);
+                        }
+                        return null;
+                    }
+                }
+            );
+            
+            // Create dynamic proxy for ClientReleaseListener
+            Object releaseListener = Proxy.newProxyInstance(
+                releaseListenerClass.getClassLoader(),
+                new Class<?>[] { releaseListenerClass },
+                new InvocationHandler() {
+                    @Override
+                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                        Log.d(TAG, "ClientReleaseListener." + method.getName() + " called");
+                        return null;
+                    }
+                }
+            );
+            
+            // Call JNIApi.init(stateListener, commandListener, releaseListener)
+            Method initMethod = jniApiClass.getMethod("init", 
+                stateListenerClass, commandListenerClass, releaseListenerClass);
+            initMethod.invoke(null, stateListener, commandListener, releaseListener);
+            
+            isP2PInitialized = true;
+            Log.d(TAG, "P2P system initialized successfully!");
         } catch (Exception e) {
-            Log.e(TAG, "Failed to initialize P2P: " + e.getMessage());
+            Log.e(TAG, "Failed to initialize P2P: " + e.getMessage(), e);
+        }
+    }
+    
+    private void handleStateChange(long clientPtr, int state) {
+        Log.d(TAG, "State change: clientPtr=" + clientPtr + ", state=" + state);
+        
+        // Find our client by SDK pointer
+        for (Map.Entry<Integer, ClientInfo> entry : clients.entrySet()) {
+            if (entry.getValue().sdkClientPtr == clientPtr) {
+                int ourClientPtr = entry.getKey();
+                
+                WritableMap params = Arguments.createMap();
+                params.putInt("clientId", ourClientPtr);
+                params.putInt("state", state);
+                sendEvent("onConnectionStateChanged", params);
+                
+                // Update connected state
+                entry.getValue().isConnected = (state == 3); // ONLINE
+                break;
+            }
+        }
+    }
+    
+    private void handleCommandReceive(long clientPtr, int command, byte[] data) {
+        Log.d(TAG, "Command receive: clientPtr=" + clientPtr + ", command=" + command);
+        
+        // Find our client by SDK pointer
+        for (Map.Entry<Integer, ClientInfo> entry : clients.entrySet()) {
+            if (entry.getValue().sdkClientPtr == clientPtr) {
+                int ourClientPtr = entry.getKey();
+                
+                WritableMap params = Arguments.createMap();
+                params.putInt("clientId", ourClientPtr);
+                params.putInt("command", command);
+                params.putString("data", data != null ? new String(data) : "");
+                sendEvent("onCommandReceived", params);
+                break;
+            }
         }
     }
 
@@ -140,7 +227,7 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
 
     /**
      * Create a P2P client for a device
-     * @param deviceId The camera's Device ID (DID)
+     * JNIApi.create(String did, String serverParam) -> long
      */
     @ReactMethod
     public void clientCreate(String deviceId, Promise promise) {
@@ -148,15 +235,33 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
             try {
                 Log.d(TAG, "clientCreate called with deviceId: " + deviceId);
                 
-                // Generate a unique client pointer
-                int clientPtr = Math.abs(deviceId.hashCode());
+                if (jniApiClass == null) {
+                    promise.reject("CREATE_ERROR", "JNIApi not available");
+                    return;
+                }
+                
+                // Call JNIApi.create(did, serverParam)
+                Method createMethod = jniApiClass.getMethod("create", String.class, String.class);
+                Object result = createMethod.invoke(null, deviceId, P2P_SERVER_PARAM);
+                long sdkClientPtr = (Long) result;
+                
+                Log.d(TAG, "JNIApi.create result: " + sdkClientPtr);
+                
+                if (sdkClientPtr <= 0) {
+                    promise.reject("CREATE_ERROR", "Failed to create client, result: " + sdkClientPtr);
+                    return;
+                }
+                
+                // Generate our own client ID (hash of deviceId) and store mapping
+                int ourClientPtr = Math.abs(deviceId.hashCode());
                 
                 ClientInfo clientInfo = new ClientInfo();
                 clientInfo.deviceId = deviceId;
-                clients.put(clientPtr, clientInfo);
+                clientInfo.sdkClientPtr = sdkClientPtr;
+                clients.put(ourClientPtr, clientInfo);
                 
-                Log.d(TAG, "Created client with ptr: " + clientPtr + " for DID: " + deviceId);
-                promise.resolve(clientPtr);
+                Log.d(TAG, "Created client: ourPtr=" + ourClientPtr + ", sdkPtr=" + sdkClientPtr);
+                promise.resolve(ourClientPtr);
             } catch (Exception e) {
                 Log.e(TAG, "clientCreate failed", e);
                 promise.reject("CREATE_ERROR", e.getMessage());
@@ -166,7 +271,7 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
 
     /**
      * Connect to camera via P2P
-     * This attempts a REAL P2P connection using the VStarCam SDK
+     * JNIApi.connect(long clientPtr, int timeout, String serverParam, int connectType)
      */
     @ReactMethod
     public void clientConnect(int clientPtr, boolean lanScan, String serverParam, int connectType, Promise promise) {
@@ -180,8 +285,10 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
                     return;
                 }
                 
-                String did = clientInfo.deviceId;
-                Log.d(TAG, "Attempting P2P connection to DID: " + did);
+                if (jniApiClass == null) {
+                    promise.reject("CONNECT_ERROR", "JNIApi not available");
+                    return;
+                }
                 
                 // Emit connecting state
                 WritableMap params = Arguments.createMap();
@@ -189,89 +296,26 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
                 params.putInt("state", 1); // CONNECTING
                 sendEvent("onConnectionStateChanged", params);
                 
-                // Use provided server param or default
                 String param = (serverParam != null && !serverParam.isEmpty()) 
                     ? serverParam 
                     : P2P_SERVER_PARAM;
                 
-                int resultState = 4; // Default to CONNECT_FAILED
-                String errorMessage = null;
-                
-                // Attempt real P2P connection
-                if (jniApiClass != null && isNativeLibraryLoaded) {
-                    try {
-                        // Try PPCS_Connect method
-                        Method connectMethod = jniApiClass.getMethod("PPCS_Connect", 
-                            String.class, int.class, int.class);
-                        
-                        // Parameters: DID, timeout, mode
-                        Object result = connectMethod.invoke(null, did, 15, connectType);
-                        int sessionHandle = (Integer) result;
-                        
-                        Log.d(TAG, "PPCS_Connect result: " + sessionHandle);
-                        
-                        if (sessionHandle >= 0) {
-                            clientInfo.sessionHandle = sessionHandle;
-                            clientInfo.isConnected = true;
-                            resultState = 3; // ONLINE
-                            Log.d(TAG, "P2P connection successful! Handle: " + sessionHandle);
-                        } else {
-                            errorMessage = "Connection failed with code: " + sessionHandle;
-                            Log.e(TAG, errorMessage);
-                        }
-                    } catch (NoSuchMethodException e) {
-                        Log.w(TAG, "PPCS_Connect method not found, trying PPCS_ConnectByServer");
-                        
-                        try {
-                            // Try alternative method
-                            Method connectMethod = jniApiClass.getMethod("PPCS_ConnectByServer", 
-                                String.class, byte[].class, int.class, int.class);
-                            
-                            byte[] serverBytes = param.getBytes();
-                            Object result = connectMethod.invoke(null, did, serverBytes, 15, connectType);
-                            int sessionHandle = (Integer) result;
-                            
-                            Log.d(TAG, "PPCS_ConnectByServer result: " + sessionHandle);
-                            
-                            if (sessionHandle >= 0) {
-                                clientInfo.sessionHandle = sessionHandle;
-                                clientInfo.isConnected = true;
-                                resultState = 3; // ONLINE
-                            } else {
-                                errorMessage = "Connection failed with code: " + sessionHandle;
-                            }
-                        } catch (Exception e2) {
-                            Log.e(TAG, "P2P connection method failed: " + e2.getMessage());
-                            errorMessage = "JNI method call failed: " + e2.getMessage();
-                            
-                            // Fallback to simulation for testing
-                            Log.w(TAG, "Falling back to simulated connection");
-                            clientInfo.isConnected = true;
-                            resultState = 3; // Simulated ONLINE
-                        }
-                    }
-                } else {
-                    // No JNI class available - use simulation
-                    Log.w(TAG, "JNI class not available, using simulated connection");
-                    Thread.sleep(1000);
-                    clientInfo.isConnected = true;
-                    resultState = 3; // Simulated ONLINE
-                }
+                // Call JNIApi.connect(sdkClientPtr, timeout, serverParam, connectType)
+                // Signature: connect([long, int, class java.lang.String, int])
+                Method connectMethod = jniApiClass.getMethod("connect", 
+                    long.class, int.class, String.class, int.class);
                 
-                // Emit result state
-                params = Arguments.createMap();
-                params.putInt("clientId", clientPtr);
-                params.putInt("state", resultState);
-                if (errorMessage != null) {
-                    params.putString("error", errorMessage);
-                }
-                sendEvent("onConnectionStateChanged", params);
+                Log.d(TAG, "Calling JNIApi.connect(" + clientInfo.sdkClientPtr + ", 15, " + param + ", " + connectType + ")");
+                connectMethod.invoke(null, clientInfo.sdkClientPtr, 15, param, connectType);
+                
+                Log.d(TAG, "JNIApi.connect called - waiting for state callback");
                 
-                promise.resolve(resultState);
+                // The actual state will come via the ClientStateListener callback
+                // For now, return immediately - the JS side will get updates via events
+                promise.resolve(1); // CONNECTING
             } 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
@@ -285,6 +329,7 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
 
     /**
      * Login to camera
+     * JNIApi.login(long clientPtr, String username, String password)
      */
     @ReactMethod
     public void clientLogin(int clientPtr, String username, String password, Promise promise) {
@@ -298,22 +343,20 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
                     return;
                 }
                 
-                if (!clientInfo.isConnected) {
-                    promise.reject("LOGIN_ERROR", "Not connected");
+                if (jniApiClass == null) {
+                    promise.reject("LOGIN_ERROR", "JNIApi not available");
                     return;
                 }
                 
-                // Build login CGI command
-                String loginCgi = String.format(
-                    "login.cgi?user=%s&pwd=%s",
-                    username, password
-                );
+                // Call JNIApi.login(sdkClientPtr, username, password)
+                Method loginMethod = jniApiClass.getMethod("login", 
+                    long.class, String.class, String.class);
                 
-                Log.d(TAG, "Sending login command: " + loginCgi);
+                Log.d(TAG, "Calling JNIApi.login(" + clientInfo.sdkClientPtr + ", " + username + ", ***)");
+                loginMethod.invoke(null, clientInfo.sdkClientPtr, username, password);
                 
-                // For now, simulate login success
-                // Real implementation would send CGI via P2P channel
                 clientInfo.isLoggedIn = true;
+                Log.d(TAG, "JNIApi.login called successfully");
                 
                 promise.resolve(true);
             } catch (Exception e) {
@@ -325,6 +368,7 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
 
     /**
      * Send CGI command to camera
+     * JNIApi.writeCgi(long clientPtr, String cgi, int timeout)
      */
     @ReactMethod
     public void clientWriteCgi(int clientPtr, String cgi, int timeout, Promise promise) {
@@ -338,23 +382,19 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
                     return;
                 }
                 
-                if (!clientInfo.isConnected) {
-                    promise.reject("CGI_ERROR", "Not connected");
+                if (jniApiClass == null) {
+                    promise.reject("CGI_ERROR", "JNIApi not available");
                     return;
                 }
                 
-                // Real implementation would use PPCS_Write to send CGI
-                Log.d(TAG, "Would send CGI: " + cgi + " with session: " + clientInfo.sessionHandle);
+                // Call JNIApi.writeCgi(sdkClientPtr, cgi, timeout)
+                Method writeCgiMethod = jniApiClass.getMethod("writeCgi", 
+                    long.class, String.class, int.class);
                 
-                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);
+                Log.d(TAG, "Calling JNIApi.writeCgi(" + clientInfo.sdkClientPtr + ", " + cgi + ", " + timeout + ")");
+                writeCgiMethod.invoke(null, clientInfo.sdkClientPtr, cgi, timeout);
                 
+                Log.d(TAG, "JNIApi.writeCgi called successfully");
                 promise.resolve(true);
             } catch (Exception e) {
                 Log.e(TAG, "clientWriteCgi failed", e);
@@ -368,24 +408,8 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
      */
     @ReactMethod
     public void scanWifi(int clientPtr, Promise promise) {
-        executor.execute(() -> {
-            try {
-                Log.d(TAG, "scanWifi called");
-                
-                String scanCgi = "wifi_scan.cgi?user=admin&pwd=888888";
-                
-                Thread.sleep(1000);
-                
-                WritableMap result = Arguments.createMap();
-                result.putBoolean("success", true);
-                result.putString("networks", "[]");
-                
-                promise.resolve(result);
-            } catch (Exception e) {
-                Log.e(TAG, "scanWifi failed", e);
-                promise.reject("WIFI_ERROR", e.getMessage());
-            }
-        });
+        // Use writeCgi to send wifi_scan command
+        clientWriteCgi(clientPtr, "wifi_scan.cgi?user=admin&pwd=888888", 10, promise);
     }
 
     /**
@@ -393,58 +417,36 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
      */
     @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);
-                
-                String wifiCgi = String.format(
-                    "set_wifi.cgi?ssid=%s&key=%s&authtype=%d&enc=0&mode=0&wifienable=1",
-                    ssid, password, authType
-                );
-                
-                Log.d(TAG, "Would send WiFi config: " + wifiCgi);
-                
-                Thread.sleep(500);
-                
-                promise.resolve(true);
-            } catch (Exception e) {
-                Log.e(TAG, "configureWifi failed", e);
-                promise.reject("WIFI_ERROR", e.getMessage());
-            }
-        });
+        String wifiCgi = String.format(
+            "set_wifi.cgi?ssid=%s&key=%s&authtype=%d&enc=0&mode=0&wifienable=1",
+            ssid, password, authType
+        );
+        clientWriteCgi(clientPtr, wifiCgi, 10, promise);
     }
 
     /**
      * Disconnect from camera
+     * JNIApi.disconnect(long clientPtr)
      */
     @ReactMethod
     public void clientDisconnect(int clientPtr, Promise promise) {
         executor.execute(() -> {
             try {
-                Log.d(TAG, "clientDisconnect called");
+                Log.d(TAG, "clientDisconnect called for: " + clientPtr);
                 
                 ClientInfo clientInfo = clients.get(clientPtr);
-                if (clientInfo != null) {
-                    // Try real disconnect
-                    if (jniApiClass != null && clientInfo.sessionHandle >= 0) {
-                        try {
-                            Method closeMethod = jniApiClass.getMethod("PPCS_Close", int.class);
-                            closeMethod.invoke(null, clientInfo.sessionHandle);
-                            Log.d(TAG, "PPCS_Close called for session: " + clientInfo.sessionHandle);
-                        } catch (Exception e) {
-                            Log.w(TAG, "PPCS_Close failed: " + e.getMessage());
-                        }
-                    }
+                if (clientInfo != null && jniApiClass != null) {
+                    Method disconnectMethod = jniApiClass.getMethod("disconnect", long.class);
+                    disconnectMethod.invoke(null, clientInfo.sdkClientPtr);
                     
                     clientInfo.isConnected = false;
                     clientInfo.isLoggedIn = false;
-                    clientInfo.sessionHandle = -1;
+                    Log.d(TAG, "JNIApi.disconnect called successfully");
                 }
                 
-                // Emit disconnect state
                 WritableMap params = Arguments.createMap();
                 params.putInt("clientId", clientPtr);
-                params.putInt("state", 5); // DISCONNECT
+                params.putInt("state", 5); // DISCONNECTED
                 sendEvent("onConnectionStateChanged", params);
                 
                 promise.resolve(true);
@@ -457,12 +459,21 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
 
     /**
      * Destroy client and cleanup resources
+     * JNIApi.destroy(long clientPtr)
      */
     @ReactMethod
     public void clientDestroy(int clientPtr, Promise promise) {
         executor.execute(() -> {
             try {
-                Log.d(TAG, "clientDestroy called");
+                Log.d(TAG, "clientDestroy called for: " + clientPtr);
+                
+                ClientInfo clientInfo = clients.get(clientPtr);
+                if (clientInfo != null && jniApiClass != null) {
+                    Method destroyMethod = jniApiClass.getMethod("destroy", long.class);
+                    destroyMethod.invoke(null, clientInfo.sdkClientPtr);
+                    Log.d(TAG, "JNIApi.destroy called successfully");
+                }
+                
                 clients.remove(clientPtr);
                 promise.resolve(true);
             } catch (Exception e) {
@@ -477,15 +488,9 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
      */
     @ReactMethod
     public void startVideoStream(int clientPtr, int streamType, Promise promise) {
-        executor.execute(() -> {
-            try {
-                Log.d(TAG, "startVideoStream called");
-                promise.resolve(true);
-            } catch (Exception e) {
-                Log.e(TAG, "startVideoStream failed", e);
-                promise.reject("VIDEO_ERROR", e.getMessage());
-            }
-        });
+        // TODO: Implement video streaming
+        Log.d(TAG, "startVideoStream called - not yet implemented");
+        promise.resolve(true);
     }
 
     /**
@@ -493,27 +498,35 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
      */
     @ReactMethod
     public void stopVideoStream(int clientPtr, Promise promise) {
-        try {
-            Log.d(TAG, "stopVideoStream called");
-            promise.resolve(true);
-        } catch (Exception e) {
-            Log.e(TAG, "stopVideoStream failed", e);
-            promise.reject("VIDEO_ERROR", e.getMessage());
-        }
+        Log.d(TAG, "stopVideoStream called");
+        promise.resolve(true);
     }
 
     /**
      * Check connection mode
+     * JNIApi.checkMode(long clientPtr)
      */
     @ReactMethod
     public void clientCheckMode(int clientPtr, Promise promise) {
         try {
             ClientInfo clientInfo = clients.get(clientPtr);
             
+            int mode = 0;
+            if (clientInfo != null && jniApiClass != null && clientInfo.sdkClientPtr > 0) {
+                try {
+                    Method checkModeMethod = jniApiClass.getMethod("checkMode", long.class);
+                    Object result = checkModeMethod.invoke(null, clientInfo.sdkClientPtr);
+                    mode = (Integer) result;
+                    Log.d(TAG, "JNIApi.checkMode result: " + mode);
+                } catch (Exception e) {
+                    Log.e(TAG, "checkMode failed", e);
+                }
+            }
+            
             WritableMap result = Arguments.createMap();
             result.putBoolean("success", clientInfo != null && clientInfo.isConnected);
-            result.putInt("mode", 1); // P2P mode
-            result.putInt("sessionHandle", clientInfo != null ? clientInfo.sessionHandle : -1);
+            result.putInt("mode", mode);
+            result.putDouble("sessionHandle", clientInfo != null ? clientInfo.sdkClientPtr : -1);
             promise.resolve(result);
         } catch (Exception e) {
             Log.e(TAG, "clientCheckMode failed", e);
@@ -535,7 +548,7 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void getSdkVersion(Promise promise) {
         WritableMap result = Arguments.createMap();
-        result.putString("version", "1.0.7");
+        result.putString("version", "1.0.9");
         result.putBoolean("nativeLoaded", isNativeLibraryLoaded);
         result.putString("nativeLib", "OKSMARTPPCS");
         result.putBoolean("p2pInitialized", isP2PInitialized);

package/package.json

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