@bits-innovate/react-native-vstarcam 1.0.47 → 1.0.49

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

@@ -56,11 +56,22 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
     // 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;
     
+    // Static context reference for reloads
+    private static java.lang.ref.WeakReference<ReactApplicationContext> currentContext;
+    
+    // Static initialization state
+    private static boolean isNativeLibraryLoaded = false;
+    private static boolean isP2PInitialized = false;
+    private static Class<?> jniApiClass = null;
+    private static Class<?> stateListenerClass = null;
+    private static Class<?> commandListenerClass = null;
+    private static Class<?> releaseListenerClass = null;
+    private static final Object initLock = new Object();
+    
     // Helper for conditional debug logging
     private static void logDebug(String message) {
         if (DEBUG_LOGGING) {
@@ -162,14 +173,6 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
     // Client tracking - maps our clientPtr to actual SDK client handle
     // Made static so VStarCamVideoView can access SDK pointers
     private static Map<Integer, ClientInfo> clients = new java.util.concurrent.ConcurrentHashMap<>();
-    private boolean isNativeLibraryLoaded = false;
-    private boolean isP2PInitialized = false;
-    
-    // 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;          // Original device ID (can be virtual UID)
@@ -198,55 +201,38 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
         this.reactContext = reactContext;
         this.executor = Executors.newCachedThreadPool();
         
-        // Load the native libraries
-        try {
-            // Load vp_log first (dependency)
-            System.loadLibrary("vp_log");
-            Log.d(TAG, "vp_log library loaded");
-            
-            // Then load the main P2P library
-            System.loadLibrary("OKSMARTPPCS");
-            isNativeLibraryLoaded = true;
-            Log.d(TAG, "OKSMARTPPCS library loaded successfully");
-            
-            // Load JNI API class
+        // Update current context for static proxies
+        currentContext = new java.lang.ref.WeakReference<>(reactContext);
+        
+        synchronized (initLock) {
+            // Load the native libraries
             try {
-                jniApiClass = Class.forName("com.vstarcam.JNIApi");
-                Log.d(TAG, "JNIApi class found: " + jniApiClass.getName());
-                
-                // 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");
-                
-                // 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()) + ")");
+                if (!isNativeLibraryLoaded) {
+                    System.loadLibrary("vp_log");
+                    System.loadLibrary("OKSMARTPPCS");
+                    isNativeLibraryLoaded = true;
+                    Log.d(TAG, "Native libraries loaded successfully");
                 }
-                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()) + ")");
+                
+                // Load JNI API class
+                if (jniApiClass == null) {
+                    jniApiClass = Class.forName("com.vstarcam.JNIApi");
+                    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, "JNI classes and interfaces loaded");
                 }
                 
-                // Initialize P2P system with listeners
+                // Initialize P2P system
                 initializeP2P();
-            } catch (ClassNotFoundException e) {
-                Log.e(TAG, "JNIApi class not found: " + e.getMessage());
+            } catch (Exception e) {
+                Log.e(TAG, "Native initialization failed", e);
             }
-        } catch (UnsatisfiedLinkError e) {
-            Log.e(TAG, "Failed to load native library: " + e.getMessage());
-            isNativeLibraryLoaded = false;
         }
     }
     
     private void initializeP2P() {
-        if (!isNativeLibraryLoaded || jniApiClass == null) {
+        if (!VStarCamModule.isNativeLibraryLoaded || VStarCamModule.jniApiClass == null) {
             Log.e(TAG, "Cannot initialize P2P: native library or JNIApi not available");
             return;
         }
@@ -272,19 +258,18 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
                             Log.d(TAG, "ClientStateListener." + methodName + " called");
                             if (methodName.equals("stateListener")) {
                                 // args: long clientPtr, int state
-                                final long clientPtr = (Long) args[0];
-                                final int state = (Integer) args[1];
+                                long clientPtr = 0;
+                                int state = 0;
+                                
+                                if (args != null && args.length >= 2) {
+                                    if (args[0] instanceof Number) clientPtr = ((Number) args[0]).longValue();
+                                    if (args[1] instanceof Number) state = ((Number) args[1]).intValue();
+                                }
+                                
                                 Log.d(TAG, "State callback: clientPtr=" + clientPtr + ", state=" + state);
                                 
                                 // Post to main thread for React Native compatibility
-                                if (reactContext != null) {
-                                    reactContext.runOnUiQueueThread(new Runnable() {
-                                        @Override
-                                        public void run() {
-                                            handleStateChange(clientPtr, state);
-                                        }
-                                    });
-                                }
+                                VStarCamModule.handleStateChange(clientPtr, state);
                             }
                         } catch (Exception e) {
                             Log.e(TAG, "Error in stateListener callback", e);
@@ -314,19 +299,20 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
                             Log.d(TAG, "ClientCommandListener." + methodName + " called");
                             if (methodName.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: clientPtr=" + clientPtr + ", dataLen=" + (data != null ? data.length : 0));
+                                long clientPtr = 0;
+                                byte[] data = null;
+                                int length = 0;
                                 
-                                if (reactContext != null) {
-                                    reactContext.runOnUiQueueThread(new Runnable() {
-                                        @Override
-                                        public void run() {
-                                            handleCommandReceive(clientPtr, 0, data);
-                                        }
-                                    });
+                                if (args != null && args.length >= 3) {
+                                    if (args[0] instanceof Number) clientPtr = ((Number) args[0]).longValue();
+                                    if (args[1] instanceof byte[]) data = (byte[]) args[1];
+                                    if (args[2] instanceof Number) length = ((Number) args[2]).intValue();
                                 }
+                                
+                                Log.d(TAG, "Command callback: clientPtr=" + clientPtr + ", dataLen=" + (data != null ? data.length : 0));
+                                
+                                // Post to main thread for React Native compatibility
+                                VStarCamModule.handleCommandReceive(clientPtr, 0, data);
                             }
                         } catch (Exception e) {
                             Log.e(TAG, "Error in commandListener callback", e);
@@ -363,53 +349,75 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
             );
             
             // Call JNIApi.init(stateListener, commandListener, releaseListener)
-            Method initMethod = jniApiClass.getMethod("init", 
-                stateListenerClass, commandListenerClass, releaseListenerClass);
+            Method initMethod = VStarCamModule.jniApiClass.getMethod("init", 
+                VStarCamModule.stateListenerClass, VStarCamModule.commandListenerClass, VStarCamModule.releaseListenerClass);
             initMethod.invoke(null, stateListenerProxy, commandListenerProxy, releaseListenerProxy);
             
-            isP2PInitialized = true;
+            VStarCamModule.isP2PInitialized = true;
             Log.d(TAG, "P2P system initialized successfully!");
         } catch (Exception e) {
             Log.e(TAG, "Failed to initialize P2P: " + e.getMessage(), e);
         }
     }
     
-    private void handleStateChange(long clientPtr, int state) {
+    private static 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;
-            }
+        final ReactApplicationContext ctx = currentContext != null ? currentContext.get() : null;
+        if (ctx == null || !ctx.hasActiveReactInstance()) {
+            Log.w(TAG, "State change ignored: no active React instance");
+            return;
         }
+
+        ctx.runOnUiQueueThread(new Runnable() {
+            @Override
+            public void run() {
+                // 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) {
+    private static 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;
-            }
+        final ReactApplicationContext ctx = currentContext != null ? currentContext.get() : null;
+        if (ctx == null || !ctx.hasActiveReactInstance()) {
+            Log.w(TAG, "Command receive ignored: no active React instance");
+            return;
         }
+
+        ctx.runOnUiQueueThread(new Runnable() {
+            @Override
+            public void run() {
+                // 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;
+                    }
+                }
+            }
+        });
     }
 
     @Override
@@ -432,10 +440,32 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
         Log.d(TAG, "removeListeners called with count: " + count);
     }
 
-    private void sendEvent(String eventName, @Nullable WritableMap params) {
-        if (reactContext != null && reactContext.hasActiveReactInstance()) {
-            reactContext
-                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+    @Override
+    public void invalidate() {
+        Log.d(TAG, "invalidate: Cleaning up " + clients.size() + " clients");
+        for (Integer clientId : clients.keySet()) {
+            try {
+                ClientInfo info = clients.get(clientId);
+                if (info != null && info.sdkClientPtr != 0 && jniApiClass != null) {
+                    Method disconnectMethod = jniApiClass.getMethod("disconnect", long.class);
+                    disconnectMethod.invoke(null, info.sdkClientPtr);
+                    
+                    Method destroyMethod = jniApiClass.getMethod("destroy", long.class);
+                    destroyMethod.invoke(null, info.sdkClientPtr);
+                    Log.d(TAG, "Cleanup: disconnected and destroyed client " + clientId);
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Failed to cleanup client " + clientId, e);
+            }
+        }
+        clients.clear();
+        super.invalidate();
+    }
+
+    private static void sendEvent(String eventName, @Nullable WritableMap params) {
+        final ReactApplicationContext ctx = currentContext != null ? currentContext.get() : null;
+        if (ctx != null && ctx.hasActiveReactInstance()) {
+            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                 .emit(eventName, params);
         }
     }

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

@@ -1,6 +1,7 @@
 package com.reactnativevstarcam;
 
 import android.content.Context;
+import android.graphics.Bitmap;
 import android.graphics.Color;
 import android.graphics.SurfaceTexture;
 import android.util.Log;
@@ -10,6 +11,8 @@ import android.view.Gravity;
 import android.widget.FrameLayout;
 import android.widget.TextView;
 
+import java.io.File;
+import java.io.FileOutputStream;
 import java.lang.reflect.Method;
 
 /**
@@ -279,6 +282,32 @@ public class VStarCamVideoView extends FrameLayout
         }
     }
 
+    /**
+     * Capture current frame and save to file.
+     */
+    public void captureSnapshot(String path) {
+        if (textureView == null) return;
+        
+        Bitmap bitmap = textureView.getBitmap();
+        if (bitmap == null) {
+            Log.e(TAG, "Failed to capture snapshot: bitmap is null");
+            return;
+        }
+
+        try {
+            File file = new File(path);
+            if (file.exists()) file.delete();
+            
+            FileOutputStream out = new FileOutputStream(file);
+            bitmap.compress(Bitmap.CompressFormat.JPEG, 90, out);
+            out.flush();
+            out.close();
+            Log.d(TAG, "Snapshot saved to: " + path);
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to save snapshot", e);
+        }
+    }
+
     private void releasePlayer() {
         if (playerPtr == 0) return;
 

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

@@ -25,6 +25,7 @@ public class VStarCamVideoViewManager extends SimpleViewManager<VStarCamVideoVie
     // Command IDs for direct commands from JS
     public static final int COMMAND_START_STREAM = 1;
     public static final int COMMAND_STOP_STREAM = 2;
+    public static final int COMMAND_CAPTURE_SNAPSHOT = 3;
 
     @NonNull
     @Override
@@ -76,7 +77,8 @@ public class VStarCamVideoViewManager extends SimpleViewManager<VStarCamVideoVie
     public Map<String, Integer> getCommandsMap() {
         return MapBuilder.of(
             "startStream", COMMAND_START_STREAM,
-            "stopStream", COMMAND_STOP_STREAM
+            "stopStream", COMMAND_STOP_STREAM,
+            "captureSnapshot", COMMAND_CAPTURE_SNAPSHOT
         );
     }
 
@@ -89,6 +91,11 @@ public class VStarCamVideoViewManager extends SimpleViewManager<VStarCamVideoVie
             case "stopStream":
                 view.stopStream();
                 break;
+            case "captureSnapshot":
+                if (args != null && args.size() > 0) {
+                    view.captureSnapshot(args.getString(0));
+                }
+                break;
         }
     }
 

package/package.json

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

package/src/index.ts

@@ -16,6 +16,8 @@ import {
   Platform,
   requireNativeComponent,
   ViewStyle,
+  UIManager,
+  findNodeHandle,
 } from "react-native";
 import React from "react";
 
@@ -62,6 +64,22 @@ if (Platform.OS === "android") {
 
 export const VStarCamVideoView = VStarCamVideoViewNative || (() => null);
 
+/**
+ * Capture a snapshot from the video view and save it to a file.
+ * @param viewRef Reference to the VStarCamVideoView component
+ * @param filePath Absolute path where the JPEG will be saved
+ */
+export function captureSnapshot(viewRef: any, filePath: string) {
+  const node = findNodeHandle(viewRef);
+  if (node) {
+    UIManager.dispatchViewManagerCommand(
+      node,
+      (UIManager as any).VStarCamVideoView.Commands.captureSnapshot,
+      [filePath]
+    );
+  }
+}
+
 const LINKING_ERROR =
   `The package 'react-native-vstarcam' doesn't seem to be linked. Make sure: \n\n` +
   Platform.select({ ios: "- You have run 'pod install'\n", default: "" }) +