react-native-unified-player 0.3.2 → 0.3.4

package/README.md

@@ -65,7 +65,6 @@ const MyPlayerComponent = () => {
         videoUrl="YOUR_VIDEO_URL_HERE" // Replace with your video URL
         autoplay={false} // Optional: set to true to autoplay
         loop={false} // Optional: set to true to loop
-        // authToken="YOUR_AUTH_TOKEN" // Optional: for protected streams
         // You can also use direct view props instead of or in addition to event listeners:
         // onReadyToPlay={() => console.log('View prop: Ready to play')}
         // onError={(e) => console.log('View prop: Error', e)}
@@ -87,7 +86,6 @@ export default MyPlayerComponent;
 | `style` | `ViewStyle` | Yes | Apply custom styling |
 | `autoplay` | `boolean` | No | Autoplay video when loaded |
 | `loop` | `boolean` | No | Should video loop when finished |
-| `authToken` | `string` | No | Optional auth token for protected streams |
 | `onReadyToPlay` | `() => void` | No | Callback when video is ready to play |
 | `onError` | `(error: any) => void` | No | Callback when an error occurs |
 | `onPlaybackComplete` | `() => void` | No | Callback when video playback finishes |

package/UnifiedPlayer.podspec

@@ -10,7 +10,7 @@ Pod::Spec.new do |s|
   s.license      = package["license"]
   s.authors      = package["author"]
 
-  s.platforms    = { :ios => min_ios_version_supported }
+  s.platforms    = { :ios => "13.0" }
   s.source       = { :git => "https://github.com/blueromans/react-native-unified-player.git", :tag => "#{s.version}" }
 
   s.source_files = "ios/**/*.{h,m,mm}"

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

@@ -12,12 +12,15 @@ class UnifiedPlayerEventEmitter(private val reactContext: ReactApplicationContex
         private const val TAG = "UnifiedPlayerEventEmitter"
         
         // Define all possible event types
+        const val EVENT_LOAD_START = "onLoadStart"
         const val EVENT_READY = "onReadyToPlay"
         const val EVENT_ERROR = "onError"
         const val EVENT_PROGRESS = "onProgress"
         const val EVENT_COMPLETE = "onPlaybackComplete"
         const val EVENT_STALLED = "onPlaybackStalled"
         const val EVENT_RESUMED = "onPlaybackResumed"
+        const val EVENT_PLAYING = "onPlaying"
+        const val EVENT_PAUSED = "onPaused"
         
         // Singleton instance for access from other classes
         private var instance: UnifiedPlayerEventEmitter? = null
@@ -59,4 +62,4 @@ class UnifiedPlayerEventEmitter(private val reactContext: ReactApplicationContex
         super.onCatalystInstanceDestroy()
         instance = null
     }
-} 
+}

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

@@ -1,176 +1,187 @@
 package com.unifiedplayer
 
-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.graphics.Bitmap
+import android.util.Base64
 import android.util.Log
-import com.facebook.react.bridge.UiThreadUtil
-import android.view.View
+import com.facebook.react.bridge.*
+import com.facebook.react.uimanager.UIManagerModule
+import com.facebook.react.uimanager.UIBlock
+import com.facebook.react.uimanager.NativeViewHierarchyManager
+import java.io.ByteArrayOutputStream
 
 class UnifiedPlayerModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
-    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? {
+    private var isModuleReady = false
+
+    override fun initialize() {
+        super.initialize()
         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}")
+            reactContext.getNativeModule(UIManagerModule::class.java)?.let {
+                isModuleReady = true
+                Log.d(TAG, "Module successfully initialized")
             }
         } catch (e: Exception) {
-            Log.e(TAG, "Error finding view with tag $viewTag: ${e.message}", e)
+            Log.e(TAG, "Initialization failed", 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 playerView = getPlayerViewByTag(viewTag)
-            if (playerView != null) {
-                UiThreadUtil.runOnUiThread {
-                    try {
-                        playerView.play()
-                        Log.d(TAG, "Play command executed successfully")
+            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()
                         promise.resolve(true)
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Error during play: ${e.message}", e)
-                        promise.reject("PLAY_ERROR", "Error during play: ${e.message}", e)
+                    } else {
+                        promise.reject("INVALID_VIEW", "View with tag $viewTag not found")
                     }
+                } 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.message}", e)
-            promise.reject("PLAY_ERROR", "Error in play method: ${e.message}", e)
+            Log.e(TAG, "Error in play method", e)
+            promise.reject("UIMANAGER_ERROR", "UIManagerModule not available", 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")
+            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()
                         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 {
+                        promise.reject("INVALID_VIEW", "View with tag $viewTag not found")
                     }
+                } 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.message}", e)
-            promise.reject("PAUSE_ERROR", "Error in pause method: ${e.message}", e)
+            Log.e(TAG, "Error in pause method", e)
+            promise.reject("UIMANAGER_ERROR", "UIManagerModule not available", e)
         }
     }
 
     @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")
+            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)
                         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 {
+                        promise.reject("INVALID_VIEW", "View with tag $viewTag not found")
                     }
+                } 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.message}", e)
-            promise.reject("SEEK_ERROR", "Error in seekTo method: ${e.message}", e)
+            Log.e(TAG, "Error in seekTo method", e)
+            promise.reject("UIMANAGER_ERROR", "UIManagerModule not available", e)
         }
     }
 
     @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)
+        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")
                     }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error in getCurrentTime method", e)
+                    promise.reject("GET_TIME_ERROR", "Error in getCurrentTime 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 getCurrentTime method: ${e.message}", e)
-            promise.reject("GET_TIME_ERROR", "Error in getCurrentTime method: ${e.message}", e)
+            })
+        } ?: run {
+            promise.reject("ERROR", "UIManagerModule not available")
         }
     }
 
     @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)
+        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")
                     }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error in getDuration method", e)
+                    promise.reject("GET_DURATION_ERROR", "Error in getDuration 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 getDuration method: ${e.message}", e)
-            promise.reject("GET_DURATION_ERROR", "Error in getDuration method: ${e.message}", e)
+            })
+        } ?: run {
+            promise.reject("ERROR", "UIManagerModule not available")
         }
     }
 
     @ReactMethod
-    fun testMethod(message: String) {
-        Log.d(TAG, "Test method called with message: $message")
+    fun capture(viewTag: Int, promise: Promise) {
+        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")
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error in capture method", e)
+                    promise.reject("CAPTURE_ERROR", "Error in capture method", e)
+                }
+            })
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in capture method", e)
+            promise.reject("UIMANAGER_ERROR", "UIManagerModule not available", e)
+        }
     }
 }

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

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

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

@@ -4,9 +4,13 @@ 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.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
 import com.google.android.exoplayer2.ExoPlayer
@@ -19,6 +23,15 @@ import com.google.android.exoplayer2.video.VideoSize
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.events.RCTEventEmitter
+import com.unifiedplayer.UnifiedPlayerEventEmitter.Companion.EVENT_COMPLETE
+import com.unifiedplayer.UnifiedPlayerEventEmitter.Companion.EVENT_ERROR
+import com.unifiedplayer.UnifiedPlayerEventEmitter.Companion.EVENT_LOAD_START
+import com.unifiedplayer.UnifiedPlayerEventEmitter.Companion.EVENT_PAUSED
+import com.unifiedplayer.UnifiedPlayerEventEmitter.Companion.EVENT_PLAYING
+import com.unifiedplayer.UnifiedPlayerEventEmitter.Companion.EVENT_PROGRESS
+import com.unifiedplayer.UnifiedPlayerEventEmitter.Companion.EVENT_READY
+import com.unifiedplayer.UnifiedPlayerEventEmitter.Companion.EVENT_RESUMED
+import com.unifiedplayer.UnifiedPlayerEventEmitter.Companion.EVENT_STALLED
 
 class UnifiedPlayerView(context: Context) : FrameLayout(context) {
     companion object {
@@ -50,7 +63,7 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
                     event.putDouble("duration", duration.toDouble())
                     
                     Log.d(TAG, "Sending progress event: currentTime=$currentTime, duration=$duration")
-                    sendEvent("topProgress", event)
+                    sendEvent(EVENT_PROGRESS, event)
                 } else {
                     Log.d(TAG, "Not sending progress event because duration is $duration (raw: ${it.duration})")
                 }
@@ -89,14 +102,15 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
                 when (playbackState) {
                     Player.STATE_READY -> {
                         Log.d(TAG, "ExoPlayer STATE_READY")
-                        sendEvent("topReadyToPlay", Arguments.createMap())
+                        sendEvent(EVENT_READY, Arguments.createMap())
                     }
                     Player.STATE_ENDED -> {
                         Log.d(TAG, "ExoPlayer STATE_ENDED")
-                        sendEvent("topPlaybackComplete", Arguments.createMap())
+                        sendEvent(EVENT_COMPLETE, Arguments.createMap())
                     }
                     Player.STATE_BUFFERING -> {
                         Log.d(TAG, "ExoPlayer STATE_BUFFERING")
+                        sendEvent(EVENT_STALLED, Arguments.createMap())
                     }
                     Player.STATE_IDLE -> {
                         Log.d(TAG, "ExoPlayer STATE_IDLE")
@@ -105,29 +119,28 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
             }
 
             override fun onIsPlayingChanged(isPlaying: Boolean) {
-                Log.d(TAG, "onIsPlayingChanged: $isPlaying")
+                Log.d(TAG, "onIsPlayingChanged: $isPlaying") // Added log
                 if (isPlaying) {
-                    Log.d(TAG, "ExoPlayer isPlaying")
-                    // Use the defined event constant for playback resumed
-                    sendEvent("topPlaybackResumed", Arguments.createMap())
+                    Log.d(TAG, "ExoPlayer is now playing")
+                    sendEvent(EVENT_RESUMED, Arguments.createMap())
+                    sendEvent(EVENT_PLAYING, Arguments.createMap())
                 } else {
-                    Log.d(TAG, "ExoPlayer isPaused")
-                    // Add event emission for pause state
-                    sendEvent("topPlaybackPaused", Arguments.createMap())
+                    Log.d(TAG, "ExoPlayer is now paused")
+                    sendEvent(EVENT_PAUSED, Arguments.createMap())
                 }
             }
 
             override fun onPlayerError(error: PlaybackException) {
-                Log.d(TAG, "ExoPlayer onPlayerError: ${error.message}")
-                val event = Arguments.createMap().apply {
-                    putString("error", error.message)
-                }
-                sendEvent("topError", event)
+                Log.e(TAG, "ExoPlayer error: $error")
+                val event = Arguments.createMap()
+                event.putString("code", "PLAYBACK_ERROR")
+                event.putString("message", error.message ?: "Unknown playback error")
+                sendEvent(EVENT_ERROR, event)
             }
 
             override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
-                Log.d(TAG, "ExoPlayer onMediaItemTransition")
-                sendEvent("topLoadStart", Arguments.createMap())
+                Log.d(TAG, "onMediaItemTransition with reason: $reason")
+                sendEvent(EVENT_LOAD_START, Arguments.createMap())
             }
 
             override fun onPlaybackSuppressionReasonChanged(playbackSuppressionReason: Int) {
@@ -238,8 +251,9 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
             
             // Send error event
             val event = Arguments.createMap()
-            event.putString("error", "Failed to load video: ${e.message}")
-            sendEvent("topError", event)
+            event.putString("code", "SOURCE_ERROR")
+            event.putString("message", "Failed to load video source: $url")
+            sendEvent(EVENT_ERROR, event)
         }
     }
 
@@ -302,17 +316,41 @@ 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 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
     }
+}
 
     // Add a getter for the ExoPlayer instance
     val exoPlayer: ExoPlayer?
@@ -323,10 +361,24 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
             // Log the event for debugging
             Log.d(TAG, "Sending direct event: $eventName with params: $params")
             
+            // Map event names to their corresponding top event names
+            val topEventName = when (eventName) {
+                EVENT_READY -> "topReadyToPlay"
+                EVENT_ERROR -> "topError"
+                EVENT_PROGRESS -> "topProgress"
+                EVENT_COMPLETE -> "topPlaybackComplete"
+                EVENT_STALLED -> "topPlaybackStalled"
+                EVENT_RESUMED -> "topPlaybackResumed"
+                EVENT_PLAYING -> "topPlaying"
+                EVENT_PAUSED -> "topPlaybackPaused"
+                EVENT_LOAD_START -> "topLoadStart"
+                else -> "top${eventName.substring(2)}" // Fallback for any other events
+            }
+            
             // Use the ReactContext to dispatch the event directly to the view
             val reactContext = context as ReactContext
             reactContext.getJSModule(RCTEventEmitter::class.java)
-                .receiveEvent(id, eventName, params)
+                .receiveEvent(id, topEventName, params)
         } catch (e: Exception) {
             Log.e(TAG, "Error sending event $eventName: ${e.message}", e)
         }

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

@@ -37,6 +37,8 @@ class UnifiedPlayerViewManager : SimpleViewManager<UnifiedPlayerView>() {
   fun setIsPaused(view: UnifiedPlayerView, isPaused: Boolean) {
     view.setIsPaused(isPaused)
   }
+
+
   
   // Register direct events
   override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any> {
@@ -49,7 +51,9 @@ class UnifiedPlayerViewManager : SimpleViewManager<UnifiedPlayerView>() {
       .put("topProgress", MapBuilder.of("registrationName", "onProgress"))
       .put("topPlaybackComplete", MapBuilder.of("registrationName", "onPlaybackComplete"))
       .put("topPlaybackResumed", MapBuilder.of("registrationName", "onPlaybackResumed"))
-      .put("topPlaybackPaused", MapBuilder.of("registrationName", "onPlaybackPaused"))
+      .put("topPlaybackStalled", MapBuilder.of("registrationName", "onPlaybackStalled"))
+      .put("topPlaybackPaused", MapBuilder.of("registrationName", "onPaused"))
+      .put("topPlaying", MapBuilder.of("registrationName", "onPlaying"))
       .put("topLoadStart", MapBuilder.of("registrationName", "onLoadStart"))
       .build()
   }

package/ios/UnifiedPlayerModule.h

@@ -1,5 +1,9 @@
 #import <React/RCTEventEmitter.h>
 #import <React/RCTBridgeModule.h>
+#import <MobileVLCKit/MobileVLCKit.h> // Import MobileVLCKit
+
+// Forward declaration for UnifiedPlayerUIView
+@class UnifiedPlayerUIView;
 
 @interface UnifiedPlayerModule : RCTEventEmitter <RCTBridgeModule>
-@end 
+@end