react-native-unified-player 0.4.1 → 0.5.4

package/README.md

@@ -151,6 +151,10 @@ Control playback using the `UnifiedPlayer` object and the native tag of the `Uni
    yarn android  # for Android
    ```
 
+## Publishing
+
+This package is automatically published to npm when changes are pushed to the `main` or `master` branch. See [PUBLISHING.md](.github/PUBLISHING.md) for setup instructions and details about npm's new authentication system (granular access tokens).
+
 ## Contributing
 
 Contributions are welcome! Please read our [Contributing Guide](CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.

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

@@ -4,7 +4,6 @@ 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 android.util.Log
 import com.facebook.react.bridge.UiThreadUtil
 import android.view.View
@@ -15,279 +14,118 @@ class UnifiedPlayerModule(private val reactContext: ReactApplicationContext) : R
     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"
-    }
-    
+
+    override fun getName(): String = "UnifiedPlayer"
+
     private fun getPlayerViewByTag(viewTag: Int): UnifiedPlayerView? {
-        try {
+        return try {
             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}")
+            (view as? UnifiedPlayerView) ?: run {
+                if (view != null) {
+                    Log.e(TAG, "View with tag $viewTag is not a UnifiedPlayerView")
+                }
+                null
             }
         } catch (e: Exception) {
-            Log.e(TAG, "Error finding view with tag $viewTag: ${e.message}", e)
+            Log.e(TAG, "Error finding view: ${e.message}")
+            null
         }
-        return null
     }
-    
-    @ReactMethod
-    fun play(viewTag: Int, promise: Promise) {
-        Log.d(TAG, "Native play method called with viewTag: $viewTag")
+
+    /**
+     * Helper function to execute operations on the player view.
+     * Eliminates repetitive boilerplate across all methods.
+     */
+    private inline fun <T> executeOnPlayerView(
+        viewTag: Int,
+        promise: Promise,
+        errorCode: String,
+        crossinline action: (UnifiedPlayerView) -> T
+    ) {
         try {
             val playerView = getPlayerViewByTag(viewTag)
             if (playerView != null) {
                 UiThreadUtil.runOnUiThread {
                     try {
-                        playerView.play()
-                        Log.d(TAG, "Play command executed successfully")
-                        promise.resolve(true)
+                        val result = action(playerView)
+                        promise.resolve(result)
                     } catch (e: Exception) {
-                        Log.e(TAG, "Error during play: ${e.message}", e)
-                        promise.reject("PLAY_ERROR", "Error during play: ${e.message}", e)
+                        Log.e(TAG, "Error during $errorCode: ${e.message}")
+                        promise.reject(errorCode, 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 play method: ${e.message}", e)
-            promise.reject("PLAY_ERROR", "Error in play method: ${e.message}", e)
+            Log.e(TAG, "Error in $errorCode: ${e.message}")
+            promise.reject(errorCode, e.message, e)
         }
     }
 
     @ReactMethod
-    fun pause(viewTag: Int, promise: Promise) {
-        Log.d(TAG, "Native pause method called with viewTag: $viewTag")
-        try {
-            val playerView = getPlayerViewByTag(viewTag)
-            if (playerView != null) {
-                UiThreadUtil.runOnUiThread {
-                    try {
-                        playerView.pause()
-                        Log.d(TAG, "Pause command executed successfully")
-                        promise.resolve(true)
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Error during pause: ${e.message}", e)
-                        promise.reject("PAUSE_ERROR", "Error during pause: ${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 pause method: ${e.message}", e)
-            promise.reject("PAUSE_ERROR", "Error in pause method: ${e.message}", e)
-        }
+    fun play(viewTag: Int, promise: Promise) = executeOnPlayerView(viewTag, promise, "PLAY_ERROR") {
+        it.play()
+        true
     }
 
     @ReactMethod
-    fun seekTo(viewTag: Int, seconds: Float, promise: Promise) {
-        Log.d(TAG, "Native seekTo method called with viewTag: $viewTag, seconds: $seconds")
-        try {
-            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)
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Error during seekTo: ${e.message}", e)
-                        promise.reject("SEEK_ERROR", "Error during seekTo: ${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 seekTo method: ${e.message}", e)
-            promise.reject("SEEK_ERROR", "Error in seekTo method: ${e.message}", e)
-        }
+    fun pause(viewTag: Int, promise: Promise) = executeOnPlayerView(viewTag, promise, "PAUSE_ERROR") {
+        it.pause()
+        true
     }
 
     @ReactMethod
-    fun getCurrentTime(viewTag: Int, promise: Promise) {
-        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)
-                    }
-                }
-            } 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)
-        }
+    fun seekTo(viewTag: Int, seconds: Float, promise: Promise) = executeOnPlayerView(viewTag, promise, "SEEK_ERROR") {
+        it.seekTo(seconds)
+        true
     }
 
     @ReactMethod
-    fun getDuration(viewTag: Int, promise: Promise) {
-        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)
-                    }
-                }
-            } 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)
-        }
+    fun getCurrentTime(viewTag: Int, promise: Promise) = executeOnPlayerView(viewTag, promise, "GET_TIME_ERROR") {
+        it.getCurrentTime()
     }
 
     @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)
-        }
+    fun getDuration(viewTag: Int, promise: Promise) = executeOnPlayerView(viewTag, promise, "GET_DURATION_ERROR") {
+        it.getDuration()
     }
-    
+
     @ReactMethod
-    fun startRecording(viewTag: Int, outputPath: String?, promise: Promise) {
-        Log.d(TAG, "Native startRecording method called with viewTag: $viewTag, outputPath: $outputPath")
-        try {
-            val playerView = getPlayerViewByTag(viewTag)
-            if (playerView != null) {
-                UiThreadUtil.runOnUiThread {
-                    try {
-                        // Determine the output path
-                        val finalOutputPath = if (outputPath.isNullOrEmpty()) {
-                            // Use app-specific storage for Android 10+ (API level 29+)
-                            val moviesDir = File(reactApplicationContext.getExternalFilesDir(Environment.DIRECTORY_MOVIES), "recordings")
-                            if (!moviesDir.exists()) {
-                                moviesDir.mkdirs()
-                            }
-                            val timestamp = System.currentTimeMillis()
-                            File(moviesDir, "recording_$timestamp.mp4").absolutePath
-                        } else {
-                            outputPath
-                        }
-                        
-                        // Start recording
-                        val result = playerView.startRecording(finalOutputPath)
-                        Log.d(TAG, "Start recording command executed successfully, result: $result")
-                        promise.resolve(result)
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Error during startRecording: ${e.message}", e)
-                        promise.reject("RECORDING_ERROR", "Error during startRecording: ${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 startRecording method: ${e.message}", e)
-            promise.reject("RECORDING_ERROR", "Error in startRecording method: ${e.message}", e)
-        }
+    fun capture(viewTag: Int, promise: Promise) = executeOnPlayerView(viewTag, promise, "CAPTURE_ERROR") {
+        it.capture()
     }
-    
+
+    /**
+     * Start recording/downloading the video.
+     * Note: This downloads the source video file rather than recording the rendered video.
+     */
     @ReactMethod
-    fun toggleFullscreen(viewTag: Int, isFullscreen: Boolean, promise: Promise) {
-        Log.d(TAG, "Native toggleFullscreen method called with viewTag: $viewTag, isFullscreen: $isFullscreen")
-        try {
-            val playerView = getPlayerViewByTag(viewTag)
-            if (playerView != null) {
-                UiThreadUtil.runOnUiThread {
-                    try {
-                        playerView.setIsFullscreen(isFullscreen)
-                        Log.d(TAG, "toggleFullscreen executed successfully")
-                        promise.resolve(true)
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Error toggling fullscreen: ${e.message}", e)
-                        promise.reject("FULLSCREEN_ERROR", "Error toggling fullscreen: ${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 toggleFullscreen method: ${e.message}", e)
-            promise.reject("FULLSCREEN_ERROR", "Error in toggleFullscreen method: ${e.message}", e)
+    fun startRecording(viewTag: Int, outputPath: String?, promise: Promise) = executeOnPlayerView(viewTag, promise, "RECORDING_ERROR") {
+        val finalOutputPath = if (outputPath.isNullOrEmpty()) {
+            val moviesDir = File(reactApplicationContext.getExternalFilesDir(Environment.DIRECTORY_MOVIES), "recordings")
+            if (!moviesDir.exists()) moviesDir.mkdirs()
+            File(moviesDir, "recording_${System.currentTimeMillis()}.mp4").absolutePath
+        } else {
+            outputPath
         }
+        it.startRecording(finalOutputPath)
     }
 
     @ReactMethod
-    fun stopRecording(viewTag: Int, promise: Promise) {
-        Log.d(TAG, "Native stopRecording method called with viewTag: $viewTag")
-        try {
-            val playerView = getPlayerViewByTag(viewTag)
-            if (playerView != null) {
-                UiThreadUtil.runOnUiThread {
-                    try {
-                        // Stop recording
-                        val filePath = playerView.stopRecording()
-                        Log.d(TAG, "Stop recording command executed successfully, filePath: $filePath")
-                        promise.resolve(filePath)
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Error during stopRecording: ${e.message}", e)
-                        promise.reject("RECORDING_ERROR", "Error during stopRecording: ${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 stopRecording method: ${e.message}", e)
-            promise.reject("RECORDING_ERROR", "Error in stopRecording method: ${e.message}", e)
-        }
+    fun toggleFullscreen(viewTag: Int, isFullscreen: Boolean, promise: Promise) = executeOnPlayerView(viewTag, promise, "FULLSCREEN_ERROR") {
+        it.setIsFullscreen(isFullscreen)
+        true
+    }
+
+    @ReactMethod
+    fun stopRecording(viewTag: Int, promise: Promise) = executeOnPlayerView(viewTag, promise, "RECORDING_ERROR") {
+        it.stopRecording()
+    }
+
+    @ReactMethod
+    fun setSpeed(viewTag: Int, speed: Float, promise: Promise) = executeOnPlayerView(viewTag, promise, "SPEED_ERROR") {
+        it.setSpeed(speed)
+        true
     }
 }