react-native-unified-player 0.3.5 → 0.3.7

package/android/build.gradle

@@ -77,6 +77,6 @@ dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
-  implementation "com.google.android.exoplayer:exoplayer-core:2.18.1"
-  implementation "com.google.android.exoplayer:exoplayer-ui:2.18.1"
+implementation "com.google.android.exoplayer:exoplayer-core:2.19.0"
+implementation "com.google.android.exoplayer:exoplayer-ui:2.19.0"
 }

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

@@ -169,4 +169,30 @@ class UnifiedPlayerModule(private val reactContext: ReactApplicationContext) : R
         }
     }
 
-}
+    @ReactMethod
+    fun capture(viewTag: Int, promise: Promise) {
+        Log.d(TAG, "Native capture method called with viewTag: $viewTag")
+        try {
+            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)
+                    }
+                }
+            } 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.message}", e)
+            promise.reject("CAPTURE_ERROR", "Error in capture method: ${e.message}", e)
+        }
+    }
+}

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

@@ -2,11 +2,17 @@ package com.unifiedplayer
 
 import android.annotation.SuppressLint
 import android.content.Context
+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.View
 import android.widget.FrameLayout
 import com.facebook.react.bridge.Arguments
 import com.google.android.exoplayer2.ExoPlayer
@@ -37,8 +43,8 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
     private var videoUrl: String? = null
     private var autoplay: Boolean = true
     private var loop: Boolean = false
-    private var playerView: PlayerView
-    private var player: ExoPlayer? = null
+    private var textureView: android.view.TextureView
+    internal var player: ExoPlayer? = null
     private var currentProgress = 0
     private var isPaused = false
 
@@ -76,20 +82,23 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
         // Create ExoPlayer
         player = ExoPlayer.Builder(context).build()
 
-        // Create PlayerView
-        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
-        }
+    // Create TextureView for video rendering
+    textureView = android.view.TextureView(context).apply {
+        layoutParams = LayoutParams(
+            LayoutParams.MATCH_PARENT,
+            LayoutParams.MATCH_PARENT
+        )
+    }
+
+    // Add TextureView to the view hierarchy
+    addView(textureView)
 
-        addView(playerView)
-        // Add logging for playerView dimensions and post play call
-        playerView.post {
-            Log.d(TAG, "PlayerView dimensions after addView: width=${playerView.width}, height=${playerView.height}")
+    // We'll set the video surface when the TextureView's surface is available
+    // in the onSurfaceTextureAvailable callback
+    Log.d(TAG, "TextureView added to view hierarchy")
+        // Log dimensions of the view
+        post {
+            Log.d(TAG, "UnifiedPlayerView dimensions after init: width=${width}, height=${height}")
         }
 
         player?.addListener(object : Player.Listener {
@@ -175,24 +184,7 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
             }
 
             override fun onVideoSizeChanged(videoSize: VideoSize) {
-                // Called when video size changes.
-                Log.d(TAG, "ExoPlayer onVideoSizeChanged: videoSize=$videoSize")
-                Log.d(TAG, "Video size changed: width=${videoSize.width}, height=${videoSize.height}")
-            }
-
-            override fun onSurfaceSizeChanged(width: Int, height: Int) {
-                // Called when the size of the surface changes.
-                Log.d(TAG, "ExoPlayer onSurfaceSizeChanged: width=$width, height=$height")
-            }
-
-            override fun onRenderedFirstFrame() {
-                // Called when the first frame is rendered.
-                Log.d(TAG, "ExoPlayer onRenderedFirstFrame")
-            }
-
-            override fun onSkipSilenceEnabledChanged(skipSilenceEnabled: Boolean) {
-                // Called when skip silence is enabled or disabled.
-                Log.d(TAG, "ExoPlayer onSkipSilenceEnabledChanged: skipSilenceEnabled=$skipSilenceEnabled")
+                // Handle video size changes if needed
             }
         })
     }
@@ -253,14 +245,9 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
         }
     }
 
-    fun setAuthToken(token: String?) {
-        // Removed as per request
-        Log.d(TAG, "Auth token handling removed")
-    }
-
     fun setAutoplay(value: Boolean) {
         autoplay = value
-        player?.playWhenReady = value // Set ExoPlayer's playWhenReady property
+        player?.playWhenReady = value
     }
 
     fun setLoop(value: Boolean) {
@@ -296,7 +283,7 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
             it.seekTo(milliseconds)
             
             // Force a progress update after seeking
-            progressRunnable.run()
+        progressRunnable.run()
         } ?: Log.e(TAG, "Cannot seek: player is null")
     }
 
@@ -370,14 +357,39 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
         val width = right - left
         val height = bottom - top
         Log.d(TAG, "UnifiedPlayerView onLayout: width=$width, height=$height")
-        // Ensure playerView also gets laid out
-        playerView.layout(0, 0, width, height)
+        // Ensure textureView gets laid out properly
+        textureView.layout(0, 0, width, height)
     }
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
         Log.d(TAG, "UnifiedPlayerView onAttachedToWindow")
-        playerView.setPlayer(player)
+        textureView.surfaceTextureListener = object : android.view.TextureView.SurfaceTextureListener {
+    override fun onSurfaceTextureAvailable(surface: android.graphics.SurfaceTexture, width: Int, height: Int) {
+        Log.d(TAG, "TextureView onSurfaceTextureAvailable: width=$width, height=$height")
+        // Create a Surface from the SurfaceTexture and set it on the player
+        val videoSurface = android.view.Surface(surface)
+        player?.setVideoSurface(videoSurface)
+        Log.d(TAG, "Set video surface from TextureView's SurfaceTexture")
+    }
+
+    override fun onSurfaceTextureSizeChanged(surface: android.graphics.SurfaceTexture, width: Int, height: Int) {
+        Log.d(TAG, "TextureView onSurfaceTextureSizeChanged: width=$width, height=$height")
+    }
+
+    override fun onSurfaceTextureDestroyed(surface: android.graphics.SurfaceTexture): Boolean {
+        Log.d(TAG, "TextureView onSurfaceTextureDestroyed")
+        // Set the player's surface to null to release it
+        player?.setVideoSurface(null)
+        Log.d(TAG, "Cleared video surface from player")
+        return true
+    }
+
+    override fun onSurfaceTextureUpdated(surface: android.graphics.SurfaceTexture) {
+        // This is called very frequently, so we'll comment out this log
+        // Log.d(TAG, "TextureView onSurfaceTextureUpdated")
+    }
+}
         startProgressUpdates() // Use the new method to start progress updates
     }
 
@@ -387,4 +399,62 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
         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 ""
+}
+
+// Debugging: Log the dimensions of the bitmap
+bitmap.let {
+    Log.d(TAG, "Bitmap dimensions: width=${it.width}, height=${it.height}")
+    
+    // Check if bitmap is empty (all black)
+    var hasNonBlackPixel = false
+    for (x in 0 until it.width) {
+        for (y in 0 until it.height) {
+            if (it.getPixel(x, y) != Color.BLACK) {
+                hasNonBlackPixel = true
+                break
+            }
+        }
+        if (hasNonBlackPixel) break
+    }
+    
+    if (!hasNonBlackPixel) {
+        Log.w(TAG, "Bitmap appears to be all black")
+    }
+}
+                // 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/package.json

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