react-native-unified-player 0.3.4 → 0.3.6

package/android/src/main/java/com/unifiedplayer/UnifiedPlayerEventEmitter.kt

@@ -62,4 +62,4 @@ class UnifiedPlayerEventEmitter(private val reactContext: ReactApplicationContex
         super.onCatalystInstanceDestroy()
         instance = null
     }
-}
+}

package/android/src/main/java/com/unifiedplayer/UnifiedPlayerModule.kt

@@ -1,187 +1,198 @@
 package com.unifiedplayer
 
-import android.graphics.Bitmap
-import android.util.Base64
-import android.util.Log
-import com.facebook.react.bridge.*
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
 import com.facebook.react.uimanager.UIManagerModule
-import com.facebook.react.uimanager.UIBlock
-import com.facebook.react.uimanager.NativeViewHierarchyManager
-import java.io.ByteArrayOutputStream
+import android.util.Log
+import com.facebook.react.bridge.UiThreadUtil
+import android.view.View
 
 class UnifiedPlayerModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
-    private var isModuleReady = false
-
-    override fun initialize() {
-        super.initialize()
+    companion object {
+        private const val TAG = "UnifiedPlayerModule"
+    }
+    
+    init {
+        Log.d(TAG, "UnifiedPlayerModule initialized")
+    }
+    
+    override fun getName(): String {
+        Log.d(TAG, "getName() called, returning 'UnifiedPlayer'")
+        return "UnifiedPlayer"
+    }
+    
+    private fun getPlayerViewByTag(viewTag: Int): UnifiedPlayerView? {
         try {
-            reactContext.getNativeModule(UIManagerModule::class.java)?.let {
-                isModuleReady = true
-                Log.d(TAG, "Module successfully initialized")
+            val view = reactApplicationContext.currentActivity?.findViewById<View>(viewTag)
+            Log.d(TAG, "Looking for view with tag: $viewTag, found: ${view != null}")
+            
+            if (view is UnifiedPlayerView) {
+                return view
+            } else if (view != null) {
+                Log.e(TAG, "View with tag $viewTag is not a UnifiedPlayerView, it's a ${view.javaClass.simpleName}")
             }
         } catch (e: Exception) {
-            Log.e(TAG, "Initialization failed", e)
+            Log.e(TAG, "Error finding view with tag $viewTag: ${e.message}", e)
         }
+        return null
     }
-    companion object {
-        private const val TAG = "UnifiedPlayerModule"
-    }
-
-    override fun getName(): String = "UnifiedPlayer"
-
+    
     @ReactMethod
     fun play(viewTag: Int, promise: Promise) {
+        Log.d(TAG, "Native play method called with viewTag: $viewTag")
         try {
-            val uiManager = reactApplicationContext.getNativeModule(UIManagerModule::class.java)
-                ?: throw IllegalStateException("UIManagerModule not available")
-            
-            uiManager.addUIBlock(UIBlock { nativeViewHierarchyManager ->
-                try {
-                    val view = nativeViewHierarchyManager.resolveView(viewTag) as? UnifiedPlayerView
-                    if (view != null) {
-                        view.play()
+            val playerView = getPlayerViewByTag(viewTag)
+            if (playerView != null) {
+                UiThreadUtil.runOnUiThread {
+                    try {
+                        playerView.play()
+                        Log.d(TAG, "Play command executed successfully")
                         promise.resolve(true)
-                    } else {
-                        promise.reject("INVALID_VIEW", "View with tag $viewTag not found")
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Error during play: ${e.message}", e)
+                        promise.reject("PLAY_ERROR", "Error during play: ${e.message}", e)
                     }
-                } catch (e: Exception) {
-                    Log.e(TAG, "Error in play method", e)
-                    promise.reject("PLAY_ERROR", "Error in play method", e)
                 }
-            })
+            } else {
+                Log.e(TAG, "Player view not found for tag: $viewTag")
+                promise.reject("VIEW_NOT_FOUND", "Player view not found for tag: $viewTag")
+            }
         } catch (e: Exception) {
-            Log.e(TAG, "Error in play method", e)
-            promise.reject("UIMANAGER_ERROR", "UIManagerModule not available", e)
+            Log.e(TAG, "Error in play method: ${e.message}", e)
+            promise.reject("PLAY_ERROR", "Error in play method: ${e.message}", e)
         }
     }
 
     @ReactMethod
     fun pause(viewTag: Int, promise: Promise) {
+        Log.d(TAG, "Native pause method called with viewTag: $viewTag")
         try {
-            val uiManager = reactApplicationContext.getNativeModule(UIManagerModule::class.java)
-                ?: throw IllegalStateException("UIManagerModule not available")
-            
-            uiManager.addUIBlock(UIBlock { nativeViewHierarchyManager ->
-                try {
-                    val view = nativeViewHierarchyManager.resolveView(viewTag) as? UnifiedPlayerView
-                    if (view != null) {
-                        view.pause()
+            val playerView = getPlayerViewByTag(viewTag)
+            if (playerView != null) {
+                UiThreadUtil.runOnUiThread {
+                    try {
+                        playerView.pause()
+                        Log.d(TAG, "Pause command executed successfully")
                         promise.resolve(true)
-                    } else {
-                        promise.reject("INVALID_VIEW", "View with tag $viewTag not found")
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Error during pause: ${e.message}", e)
+                        promise.reject("PAUSE_ERROR", "Error during pause: ${e.message}", e)
                     }
-                } catch (e: Exception) {
-                    Log.e(TAG, "Error in pause method", e)
-                    promise.reject("PAUSE_ERROR", "Error in pause method", e)
                 }
-            })
+            } else {
+                Log.e(TAG, "Player view not found for tag: $viewTag")
+                promise.reject("VIEW_NOT_FOUND", "Player view not found for tag: $viewTag")
+            }
         } catch (e: Exception) {
-            Log.e(TAG, "Error in pause method", e)
-            promise.reject("UIMANAGER_ERROR", "UIManagerModule not available", e)
+            Log.e(TAG, "Error in pause method: ${e.message}", e)
+            promise.reject("PAUSE_ERROR", "Error in pause method: ${e.message}", e)
         }
     }
 
     @ReactMethod
     fun seekTo(viewTag: Int, seconds: Float, promise: Promise) {
+        Log.d(TAG, "Native seekTo method called with viewTag: $viewTag, seconds: $seconds")
         try {
-            val uiManager = reactApplicationContext.getNativeModule(UIManagerModule::class.java)
-                ?: throw IllegalStateException("UIManagerModule not available")
-            
-            uiManager.addUIBlock(UIBlock { nativeViewHierarchyManager ->
-                try {
-                    val view = nativeViewHierarchyManager.resolveView(viewTag) as? UnifiedPlayerView
-                    if (view != null) {
-                        view.seekTo(seconds)
+            val playerView = getPlayerViewByTag(viewTag)
+            if (playerView != null) {
+                UiThreadUtil.runOnUiThread {
+                    try {
+                        playerView.seekTo(seconds)
+                        Log.d(TAG, "SeekTo command executed successfully to $seconds seconds")
                         promise.resolve(true)
-                    } else {
-                        promise.reject("INVALID_VIEW", "View with tag $viewTag not found")
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Error during seekTo: ${e.message}", e)
+                        promise.reject("SEEK_ERROR", "Error during seekTo: ${e.message}", e)
                     }
-                } catch (e: Exception) {
-                    Log.e(TAG, "Error in seekTo method", e)
-                    promise.reject("SEEK_ERROR", "Error in seekTo method", e)
                 }
-            })
+            } else {
+                Log.e(TAG, "Player view not found for tag: $viewTag")
+                promise.reject("VIEW_NOT_FOUND", "Player view not found for tag: $viewTag")
+            }
         } catch (e: Exception) {
-            Log.e(TAG, "Error in seekTo method", e)
-            promise.reject("UIMANAGER_ERROR", "UIManagerModule not available", e)
+            Log.e(TAG, "Error in seekTo method: ${e.message}", e)
+            promise.reject("SEEK_ERROR", "Error in seekTo method: ${e.message}", e)
         }
     }
 
     @ReactMethod
     fun getCurrentTime(viewTag: Int, promise: Promise) {
-        reactApplicationContext.getNativeModule(UIManagerModule::class.java)?.let { uiManager ->
-            uiManager.addUIBlock(UIBlock { nativeViewHierarchyManager ->
-                try {
-                    val view = nativeViewHierarchyManager.resolveView(viewTag) as? UnifiedPlayerView
-                    if (view != null) {
-                        promise.resolve(view.getCurrentTime())
-                    } else {
-                        promise.reject("INVALID_VIEW", "View with tag $viewTag not found")
+        Log.d(TAG, "Native getCurrentTime method called with viewTag: $viewTag")
+        try {
+            val playerView = getPlayerViewByTag(viewTag)
+            if (playerView != null) {
+                UiThreadUtil.runOnUiThread {
+                    try {
+                        val currentTime = playerView.getCurrentTime()
+                        Log.d(TAG, "getCurrentTime executed successfully, current time: $currentTime")
+                        promise.resolve(currentTime)
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Error getting current time: ${e.message}", e)
+                        promise.reject("GET_TIME_ERROR", "Error getting current time: ${e.message}", e)
                     }
-                } catch (e: Exception) {
-                    Log.e(TAG, "Error in getCurrentTime method", e)
-                    promise.reject("GET_TIME_ERROR", "Error in getCurrentTime method", e)
                 }
-            })
-        } ?: run {
-            promise.reject("ERROR", "UIManagerModule not available")
+            } else {
+                Log.e(TAG, "Player view not found for tag: $viewTag")
+                promise.reject("VIEW_NOT_FOUND", "Player view not found for tag: $viewTag")
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in getCurrentTime method: ${e.message}", e)
+            promise.reject("GET_TIME_ERROR", "Error in getCurrentTime method: ${e.message}", e)
         }
     }
 
     @ReactMethod
     fun getDuration(viewTag: Int, promise: Promise) {
-        reactApplicationContext.getNativeModule(UIManagerModule::class.java)?.let { uiManager ->
-            uiManager.addUIBlock(UIBlock { nativeViewHierarchyManager ->
-                try {
-                    val view = nativeViewHierarchyManager.resolveView(viewTag) as? UnifiedPlayerView
-                    if (view != null) {
-                        promise.resolve(view.getDuration())
-                    } else {
-                        promise.reject("INVALID_VIEW", "View with tag $viewTag not found")
+        Log.d(TAG, "Native getDuration method called with viewTag: $viewTag")
+        try {
+            val playerView = getPlayerViewByTag(viewTag)
+            if (playerView != null) {
+                UiThreadUtil.runOnUiThread {
+                    try {
+                        val duration = playerView.getDuration()
+                        Log.d(TAG, "getDuration executed successfully, duration: $duration")
+                        promise.resolve(duration)
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Error getting duration: ${e.message}", e)
+                        promise.reject("GET_DURATION_ERROR", "Error getting duration: ${e.message}", e)
                     }
-                } catch (e: Exception) {
-                    Log.e(TAG, "Error in getDuration method", e)
-                    promise.reject("GET_DURATION_ERROR", "Error in getDuration method", e)
                 }
-            })
-        } ?: run {
-            promise.reject("ERROR", "UIManagerModule not available")
+            } else {
+                Log.e(TAG, "Player view not found for tag: $viewTag")
+                promise.reject("VIEW_NOT_FOUND", "Player view not found for tag: $viewTag")
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in getDuration method: ${e.message}", e)
+            promise.reject("GET_DURATION_ERROR", "Error in getDuration method: ${e.message}", e)
         }
     }
 
     @ReactMethod
     fun capture(viewTag: Int, promise: Promise) {
+        Log.d(TAG, "Native capture method called with viewTag: $viewTag")
         try {
-            if (!isModuleReady) {
-                throw IllegalStateException("Module not ready. Ensure React Native bridge is initialized.")
-            }
-            val uiManager = reactApplicationContext.getNativeModule(UIManagerModule::class.java)
-                ?: throw IllegalStateException("UIManagerModule not available. Is the bridge active?")
-            
-            uiManager.addUIBlock(UIBlock { nativeViewHierarchyManager ->
-                try {
-                    val view = nativeViewHierarchyManager.resolveView(viewTag) as? UnifiedPlayerView
-                    if (view != null) {
-                        val bitmap = view.captureFrame()
-                        if (bitmap != null) {
-                            val outputStream = ByteArrayOutputStream()
-                            bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
-                            val base64 = Base64.encodeToString(outputStream.toByteArray(), Base64.DEFAULT)
-                            promise.resolve(base64)
-                        } else {
-                            promise.reject("CAPTURE_ERROR", "Failed to capture frame")
-                        }
-                    } else {
-                        promise.reject("INVALID_VIEW", "View with tag $viewTag not found")
+            val playerView = getPlayerViewByTag(viewTag)
+            if (playerView != null) {
+                UiThreadUtil.runOnUiThread {
+                    try {
+                        // Assuming playerView has a method called capture() that returns a String
+                        val captureResult = playerView.capture()
+                        Log.d(TAG, "Capture command executed successfully, result: $captureResult")
+                        promise.resolve(captureResult)
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Error during capture: ${e.message}", e)
+                        promise.reject("CAPTURE_ERROR", "Error during capture: ${e.message}", e)
                     }
-                } catch (e: Exception) {
-                    Log.e(TAG, "Error in capture method", e)
-                    promise.reject("CAPTURE_ERROR", "Error in capture method", e)
                 }
-            })
+            } else {
+                Log.e(TAG, "Player view not found for tag: $viewTag")
+                promise.reject("VIEW_NOT_FOUND", "Player view not found for tag: $viewTag")
+            }
         } catch (e: Exception) {
-            Log.e(TAG, "Error in capture method", e)
-            promise.reject("UIMANAGER_ERROR", "UIManagerModule not available", e)
+            Log.e(TAG, "Error in capture method: ${e.message}", e)
+            promise.reject("CAPTURE_ERROR", "Error in capture method: ${e.message}", e)
         }
     }
 }

package/android/src/main/java/com/unifiedplayer/UnifiedPlayerPackage.kt

@@ -12,12 +12,7 @@ class UnifiedPlayerPackage : ReactPackage {
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
     Log.d(TAG, "Creating native modules")
     return listOf(
-      UnifiedPlayerModule(reactContext).apply {
-        reactContext.runOnUiQueueThread {
-          // Initialize module on UI thread
-          Log.d(TAG, "Module initialized on UI thread")
-        }
-      }
+      UnifiedPlayerModule(reactContext)
     )
   }
 
@@ -25,4 +20,4 @@ class UnifiedPlayerPackage : ReactPackage {
     Log.d(TAG, "Creating view managers")
     return listOf(UnifiedPlayerViewManager())
   }
-}
+}

package/android/src/main/java/com/unifiedplayer/UnifiedPlayerView.kt

@@ -2,14 +2,16 @@ package com.unifiedplayer
 
 import android.annotation.SuppressLint
 import android.content.Context
-import android.graphics.Color
-import android.util.Log
 import android.graphics.Bitmap
 import android.graphics.Canvas
+import android.graphics.Color
+import android.view.PixelCopy
+import android.util.Base64
+import java.io.ByteArrayOutputStream
+import android.util.Log
 import android.os.Handler
 import android.os.Looper
 import android.view.Gravity
-import android.view.TextureView
 import android.view.View
 import android.widget.FrameLayout
 import com.facebook.react.bridge.Arguments
@@ -42,6 +44,7 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
     private var autoplay: Boolean = true
     private var loop: Boolean = false
     private var playerView: PlayerView
+    private var textureView: android.view.TextureView? = null
     private var player: ExoPlayer? = null
     private var currentProgress = 0
     private var isPaused = false
@@ -80,17 +83,30 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
         // Create ExoPlayer
         player = ExoPlayer.Builder(context).build()
 
-        // Create PlayerView
+        // Create TextureView for video rendering
+        textureView = android.view.TextureView(context).apply {
+            layoutParams = LayoutParams(
+                LayoutParams.MATCH_PARENT,
+                LayoutParams.MATCH_PARENT
+            )
+        }
+
+        // Create PlayerView without SurfaceView
         playerView = PlayerView(context).apply {
             layoutParams = LayoutParams(
                 LayoutParams.MATCH_PARENT,
                 LayoutParams.MATCH_PARENT
             )
             setPlayer(player)
-            // playerView.surfaceView?.surfaceType = android.view.SurfaceView.SURFACE_TYPE_SOFTWARE // Reverted: Let's remove surfaceType setting
+            useController = false // Disable default controls
         }
 
+        // Add views to hierarchy
+        addView(textureView)
         addView(playerView)
+
+        // Set TextureView as video surface
+        player?.setVideoTextureView(textureView)
         // Add logging for playerView dimensions and post play call
         playerView.post {
             Log.d(TAG, "PlayerView dimensions after addView: width=${playerView.width}, height=${playerView.height}")
@@ -316,41 +332,17 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
         }
     }
 
-fun getDuration(): Float {
-    Log.d(TAG, "GetDuration method called")
-    return player?.let {
-        val duration = it.duration.toFloat() / 1000f
-        Log.d(TAG, "Duration: $duration seconds (raw: ${it.duration})")
-        if (it.duration > 0) duration else 0f
-    } ?: run {
-        Log.e(TAG, "Cannot get duration: player is null")
-        0f
-    }
-}
-
-fun captureFrame(): Bitmap? {
-    Log.d(TAG, "CaptureFrame method called")
-    try {
-        // Create a bitmap with the same dimensions as the player view
-        val bitmap = Bitmap.createBitmap(
-            playerView.width, 
-            playerView.height,
-            Bitmap.Config.ARGB_8888
-        )
-        
-        // Create a canvas with the bitmap
-        val canvas = Canvas(bitmap)
-        
-        // Draw the player view onto the canvas
-        playerView.draw(canvas)
-        
-        Log.d(TAG, "Successfully captured frame from PlayerView")
-        return bitmap
-    } catch (e: Exception) {
-        Log.e(TAG, "Error capturing frame: ${e.message}", e)
-        return null
+    fun getDuration(): Float {
+        Log.d(TAG, "GetDuration method called")
+        return player?.let {
+            val duration = it.duration.toFloat() / 1000f
+            Log.d(TAG, "Duration: $duration seconds (raw: ${it.duration})")
+            if (it.duration > 0) duration else 0f
+        } ?: run {
+            Log.e(TAG, "Cannot get duration: player is null")
+            0f
+        }
     }
-}
 
     // Add a getter for the ExoPlayer instance
     val exoPlayer: ExoPlayer?
@@ -415,4 +407,42 @@ fun captureFrame(): Bitmap? {
         progressHandler.removeCallbacks(progressRunnable) // Stop progress updates
         player?.release()
     }
+
+    fun capture(): String {
+        Log.d(TAG, "Capture method called")
+        return try {
+            player?.let { exoPlayer ->
+                // Get the video size from the player
+                val videoSize = exoPlayer.videoSize
+                if (videoSize.width <= 0 || videoSize.height <= 0) {
+                    Log.e(TAG, "Invalid video dimensions: ${videoSize.width}x${videoSize.height}")
+                    return ""
+                }
+
+                // Get bitmap directly from TextureView
+                val bitmap = textureView?.bitmap ?: run {
+                    Log.e(TAG, "Failed to get bitmap from TextureView")
+                    return ""
+                }
+
+                // Compress and encode the bitmap
+                val byteArrayOutputStream = ByteArrayOutputStream()
+                if (bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteArrayOutputStream)) {
+                    val byteArray = byteArrayOutputStream.toByteArray()
+                    val base64EncodedString = Base64.encodeToString(byteArray, Base64.DEFAULT)
+                    Log.d(TAG, "Capture successful, base64 length: ${base64EncodedString.length}")
+                    base64EncodedString
+                } else {
+                    Log.e(TAG, "Failed to compress bitmap")
+                    ""
+                }
+            } ?: run {
+                Log.e(TAG, "Cannot capture: player is null")
+                ""
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error during capture: ${e.message}", e)
+            ""
+        }
+    }
 }

package/android/src/main/java/com/unifiedplayer/UnifiedPlayerViewManager.kt

@@ -57,4 +57,4 @@ class UnifiedPlayerViewManager : SimpleViewManager<UnifiedPlayerView>() {
       .put("topLoadStart", MapBuilder.of("registrationName", "onLoadStart"))
       .build()
   }
-}
+}

package/ios/UnifiedPlayerUIView.h

@@ -16,6 +16,7 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, weak) RCTBridge *bridge;
 @property (nonatomic, assign) VLCMediaPlayerState previousState;
 @property (nonatomic, assign) BOOL hasRenderedVideo;
+@property (nonatomic, assign) BOOL readyEventSent;
 
 // Event callbacks
 @property (nonatomic, copy) RCTDirectEventBlock onLoadStart;

package/ios/UnifiedPlayerViewManager.m

@@ -19,6 +19,7 @@
         
         // Initialize properties
         _hasRenderedVideo = NO;
+        _readyEventSent = NO;
         
         // Create the player
         _player = [[VLCMediaPlayer alloc] init];
@@ -182,8 +183,9 @@
                self.window ? @"YES" : @"NO",
                self.superview ? @"YES" : @"NO");
     
-    // Reset the rendered flag
+    // Reset the flags
     _hasRenderedVideo = NO;
+    _readyEventSent = NO;
     
     // Make sure we're in the main thread
     dispatch_async(dispatch_get_main_queue(), ^{
@@ -432,6 +434,19 @@
     VLCMediaPlayerState state = _player.state;
     RCTLogInfo(@"[UnifiedPlayerViewManager] mediaPlayerStateChanged - New State: %d", state); // Added Log
     
+    // Check if media is ready to play
+    if ((state == VLCMediaPlayerStateBuffering || state == VLCMediaPlayerStatePlaying || state == VLCMediaPlayerStatePaused) && !_readyEventSent) {
+        // Check if we have video tracks
+        NSArray *videoTracks = [_player.media tracksInformation];
+        if (videoTracks.count > 0 || _player.hasVideoOut) {
+            RCTLogInfo(@"[UnifiedPlayerViewManager] Media is ready to play - Video tracks found: %lu", (unsigned long)videoTracks.count);
+            
+            // Send ready event when media is ready, regardless of autoplay
+            [self sendEvent:@"onReadyToPlay" body:@{}];
+            _readyEventSent = YES;
+        }
+    }
+    
     // Debug information for video output
     if (state == VLCMediaPlayerStatePlaying) {
         RCTLogInfo(@"[UnifiedPlayerViewManager] Video size: %@", 
@@ -444,11 +459,6 @@
         if (videoTracks.count > 0) {
             RCTLogInfo(@"[UnifiedPlayerViewManager] Video tracks found: %lu", (unsigned long)videoTracks.count);
             
-            // Send ready event the first time we start playing
-            if (!_hasRenderedVideo) {
-                [self sendEvent:@"onReadyToPlay" body:@{}];
-            }
-            
             // Send playing event when we actually start playing
             [self sendEvent:@"onPlaying" body:@{}];
             

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-unified-player",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Unified Player",
   "source": "./src/index.tsx",
   "main": "./lib/module/index.js",