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

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

@@ -539,7 +539,17 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
                     long.class, String.class, String.class);
                 
                 Log.d(TAG, "Calling JNIApi.login(" + clientInfo.sdkClientPtr + ", " + username + ", ***)");
-                loginMethod.invoke(null, clientInfo.sdkClientPtr, username, password);
+                
+                try {
+                    loginMethod.invoke(null, clientInfo.sdkClientPtr, username, password);
+                    Log.d(TAG, "JNIApi.login returned normally");
+                } catch (java.lang.reflect.InvocationTargetException ite) {
+                    Log.e(TAG, "JNIApi.login threw exception: " + ite.getCause(), ite.getCause());
+                    throw ite;
+                } catch (Throwable t) {
+                    Log.e(TAG, "JNIApi.login crashed: " + t.getMessage(), t);
+                    throw t;
+                }
                 
                 clientInfo.isLoggedIn = true;
                 Log.d(TAG, "JNIApi.login called successfully");
@@ -747,7 +757,7 @@ public class VStarCamModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void getSdkVersion(Promise promise) {
         WritableMap result = Arguments.createMap();
-        result.putString("version", "1.0.16");
+        result.putString("version", "1.0.18");
         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,197 @@
+package com.reactnativevstarcam;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.graphics.SurfaceTexture;
+import android.util.Log;
+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 player SDK.
+ */
+public class VStarCamVideoView extends FrameLayout implements TextureView.SurfaceTextureListener {
+    private static final String TAG = "VStarCamVideoView";
+    
+    private TextureView textureView;
+    private TextView statusView;
+    private long clientPtr = 0;
+    private long playerPtr = 0;
+    private boolean isStreaming = false;
+    private int resolution = 2; // Default to general resolution
+    
+    // Player library class
+    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
+        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);
+        
+        // Try to load player library
+        loadPlayerLibrary();
+    }
+    
+    private void loadPlayerLibrary() {
+        try {
+            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
+                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");
+                }
+            }
+        } catch (UnsatisfiedLinkError e) {
+            Log.e(TAG, "Failed to load player library: " + e.getMessage());
+            playerLibLoaded = false;
+        }
+    }
+    
+    /**
+     * Set the client pointer for video streaming
+     */
+    public void setClientPtr(long ptr) {
+        this.clientPtr = ptr;
+        Log.d(TAG, "Client pointer set: " + ptr);
+        
+        if (clientPtr != 0) {
+            statusView.setText("Ready to stream");
+        }
+    }
+    
+    /**
+     * 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 (clientPtr == 0) {
+            Log.e(TAG, "Cannot start stream: no client pointer");
+            statusView.setText("No connection");
+            return;
+        }
+        
+        if (!playerLibLoaded) {
+            Log.e(TAG, "Cannot start stream: player library not loaded");
+            statusView.setText("Player not available");
+            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);
+    }
+    
+    /**
+     * Stop video streaming
+     */
+    public void stopStream() {
+        if (!isStreaming) return;
+        
+        Log.d(TAG, "Stopping video stream...");
+        isStreaming = false;
+        statusView.setVisibility(VISIBLE);
+        statusView.setText("Stream stopped");
+    }
+    
+    // TextureView.SurfaceTextureListener implementation
+    
+    @Override
+    public void onSurfaceTextureAvailable(SurfaceTexture surface, 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);
+        }
+    }
+    
+    @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();
+        releasePlayer();
+        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");
+    }
+    
+    private void releasePlayer() {
+        if (playerPtr != 0) {
+            // Release native player resources
+            playerPtr = 0;
+        }
+    }
+    
+    @Override
+    protected void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+        stopStream();
+        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.16",
+  "version": "1.0.18",
   "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` +