@bits-innovate/react-native-vstarcam 1.0.18 → 1.0.19

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

@@ -140,7 +140,8 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
     private final ExecutorService executor;
     
     // Client tracking - maps our clientPtr to actual SDK client handle
-    private Map<Integer, ClientInfo> clients = new HashMap<>();
+    // Made static so VStarCamVideoView can access SDK pointers
+    private static Map<Integer, ClientInfo> clients = new HashMap<>();
     private boolean isNativeLibraryLoaded = false;
     private boolean isP2PInitialized = false;
     
@@ -156,8 +157,21 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
         long sdkClientPtr = 0;    // Actual SDK client pointer (long)
         boolean isConnected = false;
         boolean isLoggedIn = false;
+        String username;          // Login username for CGI commands
+        String password;          // Login password for CGI commands
     }
 
+    /**
+     * Get the actual SDK client pointer for a given internal client ID.
+     * This is needed by VStarCamVideoView to connect to the player.
+     */
+    public static long getSdkClientPtr(int clientPtr) {
+        ClientInfo info = clients.get(clientPtr);
+        if (info != null) {
+            return info.sdkClientPtr;
+        }
+        return 0;
+    }
 
     public VStarCamModule(ReactApplicationContext reactContext) {
         super(reactContext);
@@ -552,6 +566,8 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
                 }
                 
                 clientInfo.isLoggedIn = true;
+                clientInfo.username = username;
+                clientInfo.password = password;
                 Log.d(TAG, "JNIApi.login called successfully");
                 
                 promise.resolve(true);
@@ -680,13 +696,45 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
     }
 
     /**
-     * Start video stream
+     * Start video stream by sending livestream.cgi command
+     * Resolution: 1=high, 2=general, 4=low, 100=superHD
      */
     @ReactMethod
     public void startVideoStream(int clientPtr, int streamType, Promise promise) {
-        // TODO: Implement video streaming
-        Log.d(TAG, "startVideoStream called - not yet implemented");
-        promise.resolve(true);
+        Log.d(TAG, "startVideoStream called with type: " + streamType);
+        try {
+            ClientInfo clientInfo = clients.get(clientPtr);
+            if (clientInfo == null || clientInfo.sdkClientPtr == 0) {
+                promise.reject("E_NOT_CONNECTED", "Client not connected");
+                return;
+            }
+
+            // Send livestream.cgi command to start streaming
+            // streamid=10 starts the stream, substream is the resolution
+            String cgi = String.format(
+                "livestream.cgi?streamid=10&substream=%d&loginuse=%s&loginpas=%s",
+                streamType,
+                clientInfo.username != null ? clientInfo.username : "admin",
+                clientInfo.password != null ? clientInfo.password : ""
+            );
+            
+            Log.d(TAG, "Sending livestream start command: " + cgi);
+            
+            Method writeCgiMethod = jniApiClass.getMethod("writeCgi", long.class, String.class, int.class);
+            Object result = writeCgiMethod.invoke(null, clientInfo.sdkClientPtr, cgi, 5);
+            
+            Log.d(TAG, "livestream start command sent, result: " + result);
+            
+            WritableMap response = Arguments.createMap();
+            response.putBoolean("success", true);
+            response.putString("message", "Video stream started");
+            response.putInt("resolution", streamType);
+            promise.resolve(response);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "startVideoStream error", e);
+            promise.reject("E_VIDEO_START_FAILED", e.getMessage(), e);
+        }
     }
 
     /**
@@ -695,7 +743,37 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void stopVideoStream(int clientPtr, Promise promise) {
         Log.d(TAG, "stopVideoStream called");
-        promise.resolve(true);
+        try {
+            ClientInfo clientInfo = clients.get(clientPtr);
+            if (clientInfo == null || clientInfo.sdkClientPtr == 0) {
+                promise.reject("E_NOT_CONNECTED", "Client not connected");
+                return;
+            }
+
+            // Send livestream.cgi command to stop streaming
+            // streamid=16 stops the stream
+            String cgi = String.format(
+                "livestream.cgi?streamid=16&substream=0&loginuse=%s&loginpas=%s",
+                clientInfo.username != null ? clientInfo.username : "admin",
+                clientInfo.password != null ? clientInfo.password : ""
+            );
+            
+            Log.d(TAG, "Sending livestream stop command: " + cgi);
+            
+            Method writeCgiMethod = jniApiClass.getMethod("writeCgi", long.class, String.class, int.class);
+            Object result = writeCgiMethod.invoke(null, clientInfo.sdkClientPtr, cgi, 5);
+            
+            Log.d(TAG, "livestream stop command sent, result: " + result);
+            
+            WritableMap response = Arguments.createMap();
+            response.putBoolean("success", true);
+            response.putString("message", "Video stream stopped");
+            promise.resolve(response);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "stopVideoStream error", e);
+            promise.reject("E_VIDEO_STOP_FAILED", e.getMessage(), e);
+        }
     }
 
     /**
@@ -757,7 +835,7 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void getSdkVersion(Promise promise) {
         WritableMap result = Arguments.createMap();
-        result.putString("version", "1.0.18");
+        result.putString("version", "1.0.19");
         result.putBoolean("nativeLoaded", isNativeLibraryLoaded);
         result.putString("nativeLib", "OKSMARTPPCS");
         result.putBoolean("p2pInitialized", isP2PInitialized);

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

@@ -4,6 +4,7 @@ import android.content.Context;
 import android.graphics.Color;
 import android.graphics.SurfaceTexture;
 import android.util.Log;
+import android.view.Surface;
 import android.view.TextureView;
 import android.view.Gravity;
 import android.widget.FrameLayout;
@@ -13,39 +14,46 @@ import java.lang.reflect.Method;
 
 /**
  * Native video view for VStarCam camera streaming.
- * Uses TextureView for video rendering with the native player SDK.
+ * Uses TextureView for video rendering with the native AppPlayer SDK.
  */
-public class VStarCamVideoView extends FrameLayout implements TextureView.SurfaceTextureListener {
+public class VStarCamVideoView extends FrameLayout
+    implements TextureView.SurfaceTextureListener {
+
     private static final String TAG = "VStarCamVideoView";
-    
+
     private TextureView textureView;
     private TextView statusView;
+    private Surface surface;
+
+    // Client info
     private long clientPtr = 0;
+    private long sdkClientPtr = 0;  // Actual SDK pointer from VStarCamModule
+    private int resolution = 2;
+
+    // Player info
     private long playerPtr = 0;
     private boolean isStreaming = false;
-    private int resolution = 2; // Default to general resolution
-    
-    // Player library class
+    private boolean playerInitialized = false;
+
+    // Player class (from AAR)
     private Class<?> appPlayerClass;
-    private Object playerInstance;
-    private boolean playerLibLoaded = false;
-    
+
     public VStarCamVideoView(Context context) {
         super(context);
         init(context);
     }
-    
+
     private void init(Context context) {
         setBackgroundColor(Color.BLACK);
-        
-        // Create texture view for video rendering
+
+        // Create TextureView for video rendering
         textureView = new TextureView(context);
         textureView.setSurfaceTextureListener(this);
         addView(textureView, new LayoutParams(
-            LayoutParams.MATCH_PARENT, 
+            LayoutParams.MATCH_PARENT,
             LayoutParams.MATCH_PARENT
         ));
-        
+
         // Status overlay
         statusView = new TextView(context);
         statusView.setTextColor(Color.WHITE);
@@ -58,140 +66,289 @@ public class VStarCamVideoView extends FrameLayout implements TextureView.Surfac
         );
         statusParams.gravity = Gravity.CENTER;
         addView(statusView, statusParams);
-        
-        // Try to load player library
+
+        // Load player library and find class
         loadPlayerLibrary();
     }
-    
+
     private void loadPlayerLibrary() {
         try {
+            // Load the player native lib
             System.loadLibrary("OKSMARTPLAY");
-            playerLibLoaded = true;
-            Log.d(TAG, "Player library loaded successfully");
-            
-            // Try to find player class via reflection
-            try {
-                appPlayerClass = Class.forName("com.vstarcam.player.AppPlayer");
-                Log.d(TAG, "AppPlayer class found");
-            } catch (ClassNotFoundException e) {
-                // Try alternative class names
+            Log.d(TAG, "OKSMARTPLAY library loaded");
+
+            // Find AppPlayer class - try multiple possible package names
+            String[] classNames = {
+                "com.vstarcam.player.AppPlayer",
+                "com.vstarcam.AppPlayer",
+                "com.oksmartplay.AppPlayer",
+                "com.vstarcam.app_player.AppPlayer"
+            };
+
+            for (String className : classNames) {
                 try {
-                    appPlayerClass = Class.forName("com.vstarcam.AppPlayer");
-                    Log.d(TAG, "AppPlayer class found (alt path)");
-                } catch (ClassNotFoundException e2) {
-                    Log.w(TAG, "AppPlayer class not found, using native methods directly");
+                    appPlayerClass = Class.forName(className);
+                    Log.d(TAG, "Found player class: " + className);
+                    
+                    // Log available methods for debugging
+                    logPlayerMethods();
+                    break;
+                } catch (ClassNotFoundException ignored) {
+                    Log.d(TAG, "Class not found: " + className);
                 }
             }
+
+            if (appPlayerClass == null) {
+                Log.e(TAG, "Could not find AppPlayer class in AAR");
+            }
+
         } catch (UnsatisfiedLinkError e) {
-            Log.e(TAG, "Failed to load player library: " + e.getMessage());
-            playerLibLoaded = false;
+            Log.e(TAG, "Failed to load OKSMARTPLAY: " + e.getMessage());
         }
     }
-    
+
+    private void logPlayerMethods() {
+        if (appPlayerClass == null) return;
+        
+        Log.d(TAG, "=== AppPlayer Methods ===");
+        for (Method m : appPlayerClass.getDeclaredMethods()) {
+            StringBuilder params = new StringBuilder();
+            for (Class<?> p : m.getParameterTypes()) {
+                if (params.length() > 0) params.append(", ");
+                params.append(p.getSimpleName());
+            }
+            Log.d(TAG, "  " + m.getName() + "(" + params + ") -> " +
+                m.getReturnType().getSimpleName());
+        }
+    }
+
     /**
-     * Set the client pointer for video streaming
+     * Set the client pointer from VStarCamModule.
+     * This is our internal pointer ID, not the SDK pointer.
      */
     public void setClientPtr(long ptr) {
         this.clientPtr = ptr;
         Log.d(TAG, "Client pointer set: " + ptr);
-        
-        if (clientPtr != 0) {
+
+        // Lookup the actual SDK pointer from VStarCamModule
+        this.sdkClientPtr = VStarCamModule.getSdkClientPtr((int) ptr);
+        Log.d(TAG, "SDK client pointer: " + sdkClientPtr);
+
+        if (sdkClientPtr != 0) {
             statusView.setText("Ready to stream");
+        } else {
+            statusView.setText("Waiting for connection...");
         }
     }
-    
+
     /**
-     * Set video resolution (1=high, 2=general, 4=low, 100=superHD)
+     * Set video resolution.
+     * 1=high, 2=general, 4=low, 100=superHD
      */
     public void setResolution(int res) {
         this.resolution = res;
         Log.d(TAG, "Resolution set: " + res);
     }
-    
+
     /**
-     * Start video streaming
+     * Start video streaming.
      */
     public void startStream() {
-        if (clientPtr == 0) {
-            Log.e(TAG, "Cannot start stream: no client pointer");
-            statusView.setText("No connection");
+        if (sdkClientPtr == 0) {
+            // Try to get SDK pointer again in case it was set after setClientPtr
+            this.sdkClientPtr = VStarCamModule.getSdkClientPtr((int) clientPtr);
+            if (sdkClientPtr == 0) {
+                Log.e(TAG, "Cannot start: no SDK client pointer");
+                statusView.setText("Not connected");
+                return;
+            }
+        }
+
+        if (surface == null) {
+            Log.e(TAG, "Cannot start: no surface available");
+            statusView.setText("No surface");
             return;
         }
-        
-        if (!playerLibLoaded) {
-            Log.e(TAG, "Cannot start stream: player library not loaded");
-            statusView.setText("Player not available");
+
+        if (appPlayerClass == null) {
+            Log.e(TAG, "Cannot start: player class not found");
+            statusView.setText("Player unavailable");
             return;
         }
-        
-        Log.d(TAG, "Starting video stream...");
+
         statusView.setText("Starting stream...");
-        
-        // The actual streaming is handled by sending CGI command
-        // Video frames come through the native player SDK
-        isStreaming = true;
-        
-        // Hide status once streaming
-        statusView.setVisibility(GONE);
+
+        try {
+            // 1. Create player instance if needed
+            if (playerPtr == 0) {
+                Method createMethod = appPlayerClass.getMethod("create");
+                Object result = createMethod.invoke(null);
+                playerPtr = (Long) result;
+                Log.d(TAG, "Player created: " + playerPtr);
+            }
+
+            // 2. Set the video source (P2P client)
+            try {
+                Method setSourceMethod = appPlayerClass.getMethod(
+                    "setSource", long.class, long.class);
+                setSourceMethod.invoke(null, playerPtr, sdkClientPtr);
+                Log.d(TAG, "Source set to client: " + sdkClientPtr);
+            } catch (NoSuchMethodException e) {
+                Log.w(TAG, "setSource method not found, trying alternative...");
+                // Try alternative method signatures if the main one doesn't exist
+            }
+
+            // 3. Set the render surface
+            try {
+                Method setSurfaceMethod = appPlayerClass.getMethod(
+                    "setSurface", long.class, Surface.class);
+                setSurfaceMethod.invoke(null, playerPtr, surface);
+                Log.d(TAG, "Surface set");
+            } catch (NoSuchMethodException e) {
+                Log.w(TAG, "setSurface method not found, trying alternative...");
+                // Try with Object parameter
+                try {
+                    Method setSurfaceMethod = appPlayerClass.getMethod(
+                        "setSurface", long.class, Object.class);
+                    setSurfaceMethod.invoke(null, playerPtr, surface);
+                    Log.d(TAG, "Surface set (via Object)");
+                } catch (NoSuchMethodException e2) {
+                    Log.e(TAG, "No setSurface method found");
+                }
+            }
+
+            // 4. Start playback
+            try {
+                Method startMethod = appPlayerClass.getMethod("start", long.class);
+                startMethod.invoke(null, playerPtr);
+                Log.d(TAG, "Playback started");
+            } catch (NoSuchMethodException e) {
+                // Try play() instead of start()
+                try {
+                    Method playMethod = appPlayerClass.getMethod("play", long.class);
+                    playMethod.invoke(null, playerPtr);
+                    Log.d(TAG, "Playback started (via play)");
+                } catch (NoSuchMethodException e2) {
+                    Log.e(TAG, "No start/play method found");
+                }
+            }
+
+            isStreaming = true;
+            statusView.setVisibility(GONE);
+
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to start stream", e);
+            statusView.setText("Start failed: " + e.getMessage());
+        }
     }
-    
+
     /**
-     * Stop video streaming
+     * Stop video streaming.
      */
     public void stopStream() {
-        if (!isStreaming) return;
-        
-        Log.d(TAG, "Stopping video stream...");
-        isStreaming = false;
-        statusView.setVisibility(VISIBLE);
-        statusView.setText("Stream stopped");
+        if (!isStreaming || playerPtr == 0) return;
+
+        Log.d(TAG, "Stopping stream...");
+
+        try {
+            try {
+                Method stopMethod = appPlayerClass.getMethod("stop", long.class);
+                stopMethod.invoke(null, playerPtr);
+                Log.d(TAG, "Playback stopped");
+            } catch (NoSuchMethodException e) {
+                // Try pause() instead
+                try {
+                    Method pauseMethod = appPlayerClass.getMethod("pause", long.class);
+                    pauseMethod.invoke(null, playerPtr);
+                    Log.d(TAG, "Playback paused");
+                } catch (NoSuchMethodException e2) {
+                    Log.w(TAG, "No stop/pause method found");
+                }
+            }
+
+            isStreaming = false;
+            statusView.setVisibility(VISIBLE);
+            statusView.setText("Stream stopped");
+
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to stop stream", e);
+        }
     }
-    
-    // TextureView.SurfaceTextureListener implementation
-    
+
+    private void releasePlayer() {
+        if (playerPtr == 0) return;
+
+        try {
+            stopStream();
+
+            try {
+                Method releaseMethod = appPlayerClass.getMethod("release", long.class);
+                releaseMethod.invoke(null, playerPtr);
+                Log.d(TAG, "Player released");
+            } catch (NoSuchMethodException e) {
+                // Try destroy() instead
+                try {
+                    Method destroyMethod = appPlayerClass.getMethod("destroy", long.class);
+                    destroyMethod.invoke(null, playerPtr);
+                    Log.d(TAG, "Player destroyed");
+                } catch (NoSuchMethodException e2) {
+                    Log.w(TAG, "No release/destroy method found");
+                }
+            }
+
+            playerPtr = 0;
+
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to release player", e);
+        }
+    }
+
+    // TextureView.SurfaceTextureListener
+
     @Override
-    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
+    public void onSurfaceTextureAvailable(
+            SurfaceTexture surfaceTexture, int width, int height) {
         Log.d(TAG, "Surface available: " + width + "x" + height);
-        // Initialize native player with surface when available
-        if (playerLibLoaded && clientPtr != 0) {
-            initializePlayer(surface, width, height);
+        this.surface = new Surface(surfaceTexture);
+
+        // If already supposed to be streaming, try to update surface
+        if (isStreaming && playerPtr != 0 && appPlayerClass != null) {
+            try {
+                Method setSurfaceMethod = appPlayerClass.getMethod(
+                    "setSurface", long.class, Surface.class);
+                setSurfaceMethod.invoke(null, playerPtr, surface);
+                Log.d(TAG, "Surface updated on existing player");
+            } catch (Exception e) {
+                Log.e(TAG, "Failed to update surface", e);
+            }
         }
     }
-    
+
     @Override
-    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
+    public void onSurfaceTextureSizeChanged(
+            SurfaceTexture surface, int width, int height) {
         Log.d(TAG, "Surface size changed: " + width + "x" + height);
     }
-    
+
     @Override
     public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
         Log.d(TAG, "Surface destroyed");
         stopStream();
-        releasePlayer();
+        if (this.surface != null) {
+            this.surface.release();
+            this.surface = null;
+        }
         return true;
     }
-    
+
     @Override
     public void onSurfaceTextureUpdated(SurfaceTexture surface) {
-        // Called when texture is updated with new frame
-    }
-    
-    private void initializePlayer(SurfaceTexture surface, int width, int height) {
-        // Native player initialization will be implemented based on SDK API
-        Log.d(TAG, "Initializing player for surface");
+        // Frame rendered - nothing to do
     }
-    
-    private void releasePlayer() {
-        if (playerPtr != 0) {
-            // Release native player resources
-            playerPtr = 0;
-        }
-    }
-    
+
     @Override
     protected void onDetachedFromWindow() {
         super.onDetachedFromWindow();
-        stopStream();
         releasePlayer();
     }
 }

package/package.json

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