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

package/android/build.gradle

@@ -54,6 +54,8 @@ repositories {
 
 dependencies {
     implementation "com.facebook.react:react-native:+"
-    // AAR for Java classes only (SDK wrapper classes)
+    // AAR for P2P connectivity
     implementation files('libs/app_p2p_api-5.0.0.aar')
+    // AAR for video player/decoder
+    implementation files('libs/app_player-5.0.0.aar')
 }

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.17");
+        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/VStarCamPackage.java

@@ -8,7 +8,7 @@ import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
 
 import java.util.ArrayList;
-import java.util.Collections;
+import java.util.Arrays;
 import java.util.List;
 
 public class VStarCamPackage implements ReactPackage {
@@ -23,6 +23,9 @@ public class VStarCamPackage implements ReactPackage {
     @NonNull
     @Override
     public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
-        return Collections.emptyList();
+        return Arrays.<ViewManager>asList(
+            new VStarCamVideoViewManager()
+        );
     }
 }
+

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

@@ -0,0 +1,354 @@
+package com.reactnativevstarcam;
+
+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;
+import android.widget.TextView;
+
+import java.lang.reflect.Method;
+
+/**
+ * Native video view for VStarCam camera streaming.
+ * Uses TextureView for video rendering with the native AppPlayer SDK.
+ */
+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 boolean playerInitialized = false;
+
+    // Player class (from AAR)
+    private Class<?> appPlayerClass;
+
+    public VStarCamVideoView(Context context) {
+        super(context);
+        init(context);
+    }
+
+    private void init(Context context) {
+        setBackgroundColor(Color.BLACK);
+
+        // Create TextureView for video rendering
+        textureView = new TextureView(context);
+        textureView.setSurfaceTextureListener(this);
+        addView(textureView, new LayoutParams(
+            LayoutParams.MATCH_PARENT,
+            LayoutParams.MATCH_PARENT
+        ));
+
+        // Status overlay
+        statusView = new TextView(context);
+        statusView.setTextColor(Color.WHITE);
+        statusView.setTextSize(14);
+        statusView.setGravity(Gravity.CENTER);
+        statusView.setText("Waiting for connection...");
+        LayoutParams statusParams = new LayoutParams(
+            LayoutParams.WRAP_CONTENT,
+            LayoutParams.WRAP_CONTENT
+        );
+        statusParams.gravity = Gravity.CENTER;
+        addView(statusView, statusParams);
+
+        // Load player library and find class
+        loadPlayerLibrary();
+    }
+
+    private void loadPlayerLibrary() {
+        try {
+            // Load the player native lib
+            System.loadLibrary("OKSMARTPLAY");
+            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(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 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 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);
+
+        // 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
+     */
+    public void setResolution(int res) {
+        this.resolution = res;
+        Log.d(TAG, "Resolution set: " + res);
+    }
+
+    /**
+     * Start video streaming.
+     */
+    public void startStream() {
+        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 (appPlayerClass == null) {
+            Log.e(TAG, "Cannot start: player class not found");
+            statusView.setText("Player unavailable");
+            return;
+        }
+
+        statusView.setText("Starting stream...");
+
+        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.
+     */
+    public void stopStream() {
+        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);
+        }
+    }
+
+    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 surfaceTexture, int width, int height) {
+        Log.d(TAG, "Surface available: " + width + "x" + 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) {
+        Log.d(TAG, "Surface size changed: " + width + "x" + height);
+    }
+
+    @Override
+    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
+        Log.d(TAG, "Surface destroyed");
+        stopStream();
+        if (this.surface != null) {
+            this.surface.release();
+            this.surface = null;
+        }
+        return true;
+    }
+
+    @Override
+    public void onSurfaceTextureUpdated(SurfaceTexture surface) {
+        // Frame rendered - nothing to do
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+        releasePlayer();
+    }
+}

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

@@ -0,0 +1,106 @@
+package com.reactnativevstarcam;
+
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+import java.util.Map;
+
+/**
+ * React Native ViewManager for VStarCamVideoView.
+ * Exposes the native video view as a React component.
+ */
+public class VStarCamVideoViewManager extends SimpleViewManager<VStarCamVideoView> {
+    public static final String REACT_CLASS = "VStarCamVideoView";
+    
+    // Command IDs for direct commands from JS
+    public static final int COMMAND_START_STREAM = 1;
+    public static final int COMMAND_STOP_STREAM = 2;
+
+    @NonNull
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @NonNull
+    @Override
+    protected VStarCamVideoView createViewInstance(@NonNull ThemedReactContext reactContext) {
+        return new VStarCamVideoView(reactContext);
+    }
+
+    /**
+     * Set the client pointer for the video stream
+     */
+    @ReactProp(name = "clientPtr")
+    public void setClientPtr(VStarCamVideoView view, double clientPtr) {
+        // React Native passes numbers as doubles, convert to long
+        view.setClientPtr((long) clientPtr);
+    }
+
+    /**
+     * Set the video resolution
+     * 1 = high, 2 = general/default, 4 = low, 100 = superHD
+     */
+    @ReactProp(name = "resolution", defaultInt = 2)
+    public void setResolution(VStarCamVideoView view, int resolution) {
+        view.setResolution(resolution);
+    }
+
+    /**
+     * Control streaming via prop
+     */
+    @ReactProp(name = "streaming", defaultBoolean = false)
+    public void setStreaming(VStarCamVideoView view, boolean streaming) {
+        if (streaming) {
+            view.startStream();
+        } else {
+            view.stopStream();
+        }
+    }
+
+    /**
+     * Commands that can be called from JS via dispatchViewManagerCommand
+     */
+    @Nullable
+    @Override
+    public Map<String, Integer> getCommandsMap() {
+        return MapBuilder.of(
+            "startStream", COMMAND_START_STREAM,
+            "stopStream", COMMAND_STOP_STREAM
+        );
+    }
+
+    @Override
+    public void receiveCommand(@NonNull VStarCamVideoView view, String commandId, @Nullable ReadableArray args) {
+        switch (commandId) {
+            case "startStream":
+                view.startStream();
+                break;
+            case "stopStream":
+                view.stopStream();
+                break;
+        }
+    }
+
+    /**
+     * Events that can be sent to JS
+     */
+    @Nullable
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+        return MapBuilder.<String, Object>builder()
+            .put("onStreamStarted", MapBuilder.of("registrationName", "onStreamStarted"))
+            .put("onStreamStopped", MapBuilder.of("registrationName", "onStreamStopped"))
+            .put("onStreamError", MapBuilder.of("registrationName", "onStreamError"))
+            .put("onFrameReceived", MapBuilder.of("registrationName", "onFrameReceived"))
+            .build();
+    }
+}

package/package.json

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

package/src/index.ts

@@ -10,7 +10,50 @@
  * - Camera settings
  */
 
-import { NativeModules, NativeEventEmitter, Platform } from "react-native";
+import {
+  NativeModules,
+  NativeEventEmitter,
+  Platform,
+  requireNativeComponent,
+  ViewStyle,
+} from "react-native";
+import React from "react";
+
+// Video View Component
+export interface VStarCamVideoViewProps {
+  /** Client pointer from create() call */
+  clientPtr: number;
+  /** Video resolution: 1=high, 2=general, 4=low, 100=superHD */
+  resolution?: 1 | 2 | 4 | 100;
+  /** Whether streaming is active */
+  streaming?: boolean;
+  /** Style for the video view */
+  style?: ViewStyle;
+  /** Called when stream starts */
+  onStreamStarted?: () => void;
+  /** Called when stream stops */
+  onStreamStopped?: () => void;
+  /** Called on stream error */
+  onStreamError?: (error: { message: string }) => void;
+}
+
+/**
+ * Native video view component for VStarCam camera streaming.
+ *
+ * Usage:
+ * ```tsx
+ * <VStarCamVideoView
+ *   clientPtr={client.clientPtr}
+ *   resolution={2}
+ *   streaming={isPlaying}
+ *   style={{ width: 300, height: 200 }}
+ * />
+ * ```
+ */
+export const VStarCamVideoView =
+  Platform.OS === "android"
+    ? requireNativeComponent<VStarCamVideoViewProps>("VStarCamVideoView")
+    : () => null; // iOS not implemented yet
 
 const LINKING_ERROR =
   `The package 'react-native-vstarcam' doesn't seem to be linked. Make sure: \n\n` +