react-native-unified-player 0.3.9 → 0.4.0

package/README.md

@@ -82,13 +82,14 @@ export default MyPlayerComponent;
 
 | Prop | Type | Required | Description |
 |------|------|----------|-------------|
-| `videoUrl` | `string` | Yes | Video source URL |
+| `videoUrl` | `string` \| `string[]` | Yes | Video source URL or an array of URLs for a playlist. |
 | `style` | `ViewStyle` | Yes | Apply custom styling |
 | `autoplay` | `boolean` | No | Autoplay video when loaded |
-| `loop` | `boolean` | No | Should video loop when finished |
+| `loop` | `boolean` | No | Should the video/playlist loop when finished. **Note:** Playlist advancement and looping are handled in the JavaScript layer via the `onPlaybackComplete` callback. The native player only loops single videos based on this prop. |
+| `onLoadStart` | `(event: { nativeEvent?: { index?: number } }) => void` | No | Callback when video begins loading. The `event.nativeEvent` may contain an `index` property on Android when playing a playlist. |
 | `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 |
+| `onPlaybackComplete` | `() => void` | No | Callback when video playback finishes. Use this callback to implement playlist advancement logic in your JavaScript code. |
 | `onProgress` | `(data: { currentTime: number; duration: number }) => void` | No | Callback for playback progress |
 
 ## Events

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

@@ -21,7 +21,8 @@ class UnifiedPlayerEventEmitter(private val reactContext: ReactApplicationContex
         const val EVENT_RESUMED = "onPlaybackResumed"
         const val EVENT_PLAYING = "onPlaying"
         const val EVENT_PAUSED = "onPaused"
-        
+        const val EVENT_FULLSCREEN_CHANGED = "onFullscreenChanged"
+
         // Singleton instance for access from other classes
         private var instance: UnifiedPlayerEventEmitter? = null
         

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

@@ -238,6 +238,32 @@ class UnifiedPlayerModule(private val reactContext: ReactApplicationContext) : R
         }
     }
     
+    @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)
+        }
+    }
+
     @ReactMethod
     fun stopRecording(viewTag: Int, promise: Promise) {
         Log.d(TAG, "Native stopRecording method called with viewTag: $viewTag")

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

@@ -2,6 +2,8 @@ package com.unifiedplayer
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.app.Activity
+import android.content.pm.ActivityInfo
 import android.graphics.Bitmap
 import android.graphics.Canvas
 import android.graphics.Color
@@ -13,6 +15,7 @@ import android.os.Handler
 import android.os.Looper
 import android.view.Gravity
 import android.view.View
+import android.view.Surface
 import android.widget.FrameLayout
 import android.widget.ImageView
 import com.bumptech.glide.Glide
@@ -30,11 +33,11 @@ import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.events.RCTEventEmitter
 import java.io.File
 import java.io.IOException
+import java.util.Collections // Import for Collections.emptyList()
 import android.media.MediaCodec
 import android.media.MediaCodecInfo
 import android.media.MediaFormat
 import android.media.MediaMuxer
-import android.view.Surface
 import java.nio.ByteBuffer
 import android.os.Environment
 import com.unifiedplayer.UnifiedPlayerEventEmitter.Companion.EVENT_COMPLETE
@@ -46,6 +49,10 @@ 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
+import com.unifiedplayer.UnifiedPlayerEventEmitter.Companion.EVENT_FULLSCREEN_CHANGED
+import android.view.ViewGroup
+import android.view.WindowManager
+import android.os.Build
 
 class UnifiedPlayerView(context: Context) : FrameLayout(context) {
     // Recording related variables
@@ -61,7 +68,11 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
         private const val TAG = "UnifiedPlayerView"
     }
 
-    private var videoUrl: String? = null
+    // Player state
+    private var videoUrl: String? = null // Single video URL
+    private var videoUrls: List<String> = emptyList() // Playlist URLs
+    private var currentVideoIndex: Int = 0
+    private var isPlaylist: Boolean = false
     private var thumbnailUrl: String? = null
     private var autoplay: Boolean = true
     private var loop: Boolean = false
@@ -70,6 +81,13 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
     internal var player: ExoPlayer? = null
     private var currentProgress = 0
     private var isPaused = false
+    private var isFullscreen = false
+    private var originalOrientation: Int = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+    private var originalSystemUiVisibility: Int = 0
+    private var originalLayoutParams: ViewGroup.LayoutParams? = null
+    private var originalParent: ViewGroup? = null
+    private var originalIndex: Int = 0
+    private var fullscreenContainer: ViewGroup? = null
 
     private val progressHandler = Handler(Looper.getMainLooper())
     private val progressRunnable: Runnable = object : Runnable {
@@ -79,7 +97,7 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
                 val duration = it.duration.toFloat() / 1000f
 
                 // Log the actual values for debugging
-                Log.d(TAG, "Progress values - currentTime: $currentTime, duration: $duration, raw duration: ${it.duration}")
+                // Log.d(TAG, "Progress values - currentTime: $currentTime, duration: $duration, raw duration: ${it.duration}")
 
                 // Only send valid duration values
                 if (it.duration > 0) {
@@ -87,10 +105,10 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
                     event.putDouble("currentTime", currentTime.toDouble())
                     event.putDouble("duration", duration.toDouble())
                     
-                    Log.d(TAG, "Sending progress event: currentTime=$currentTime, duration=$duration")
+                    // Log.d(TAG, "Sending progress event: currentTime=$currentTime, duration=$duration")
                     sendEvent(EVENT_PROGRESS, event)
                 } else {
-                    Log.d(TAG, "Not sending progress event because duration is $duration (raw: ${it.duration})")
+                    // Log.d(TAG, "Not sending progress event because duration is $duration (raw: ${it.duration})")
                 }
             } ?: Log.e(TAG, "Cannot send progress event: player is null")
             
@@ -137,15 +155,52 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
 
         player?.addListener(object : Player.Listener {
             override fun onPlaybackStateChanged(playbackState: Int) {
-                Log.d(TAG, "onPlaybackStateChanged: $playbackState") // Added log
+                Log.d(TAG, "onPlaybackStateChanged: $playbackState")
                 when (playbackState) {
                     Player.STATE_READY -> {
                         Log.d(TAG, "ExoPlayer STATE_READY")
+                        // Ensure thumbnail is hidden when ready (might be needed if autoplay=false)
+                        if (player?.isPlaying == false) { // Check if not already playing
+                             thumbnailImageView?.visibility = View.GONE
+                        }
                         sendEvent(EVENT_READY, Arguments.createMap())
+                        // Start progress updates when ready
+                        startProgressUpdates()
                     }
                     Player.STATE_ENDED -> {
                         Log.d(TAG, "ExoPlayer STATE_ENDED")
-                        sendEvent(EVENT_COMPLETE, Arguments.createMap())
+                        if (isPlaylist) {
+                            // Playlist logic
+                            val nextIndex = currentVideoIndex + 1
+                            if (nextIndex < videoUrls.size) {
+                                // Play next video in the list
+                                Log.d(TAG, "Playlist: Loading next video at index $nextIndex")
+                                loadVideoAtIndex(nextIndex)
+                                // Don't send EVENT_COMPLETE for individual items in playlist
+                            } else {
+                                // Reached the end of the playlist
+                                if (loop) {
+                                    // Loop playlist: Go back to the first video
+                                    Log.d(TAG, "Playlist: Looping back to start")
+                                    loadVideoAtIndex(0)
+                                    // Don't send EVENT_COMPLETE when looping playlist
+                                } else {
+                                    // End of playlist, not looping
+                                    Log.d(TAG, "Playlist: Reached end, not looping")
+                                    currentVideoIndex = 0 // Reset index for potential future play
+                                    sendEvent(EVENT_COMPLETE, Arguments.createMap()) // Send completion for the whole list
+                                }
+                            }
+                        } else {
+                            // Single video logic (ExoPlayer handles looping via repeatMode)
+                            if (!loop) {
+                                // Send completion event only if not looping a single video
+                                sendEvent(EVENT_COMPLETE, Arguments.createMap())
+                            } else {
+                                Log.d(TAG, "Single video ended and loop is ON - ExoPlayer will repeat.")
+                                // Optionally send an event here if needed for single loop cycle completion
+                            }
+                        }
                     }
                     Player.STATE_BUFFERING -> {
                         Log.d(TAG, "ExoPlayer STATE_BUFFERING")
@@ -225,55 +280,34 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
         })
     }
 
-    fun setVideoUrl(url: String?) {
-        Log.d(TAG, "Setting video URL: $url")
-        
-        if (url == null || url.isEmpty()) {
-            Log.e(TAG, "Empty or null URL provided")
-            return
-        }
-        
-        videoUrl = url
-        
+    // Helper function to load and prepare a video URL
+    private fun loadVideoSource(url: String) {
+        Log.d(TAG, "Loading video source: $url")
         try {
-            // Create a MediaItem
             val mediaItem = MediaItem.fromUri(url)
-            
-            // Reset the player to ensure clean state
-            player?.stop()
-            player?.clearMediaItems()
-            
-            // Set the media item
+            player?.stop() // Stop previous playback
+            player?.clearMediaItems() // Clear previous items
             player?.setMediaItem(mediaItem)
-            
-            // Prepare the player (this will start loading the media)
             player?.prepare()
+            player?.playWhenReady = autoplay && !isPaused // Apply autoplay and paused state
             
-            // Set playWhenReady based on autoplay setting
-            player?.playWhenReady = autoplay && !isPaused
-            
-            // Set repeat mode based on loop setting
-            player?.repeatMode = if (loop) Player.REPEAT_MODE_ALL else Player.REPEAT_MODE_OFF
-            
-            // Log that we've set up the player
-            Log.d(TAG, "ExoPlayer configured with URL: $url, autoplay: $autoplay, loop: $loop")
-            
-            // Add a listener to check when the player is ready and has duration
-            player?.addListener(object : Player.Listener {
-                override fun onPlaybackStateChanged(state: Int) {
-                    if (state == Player.STATE_READY) {
-                        val duration = player?.duration ?: 0
-                        Log.d(TAG, "Player ready with duration: ${duration / 1000f} seconds")
-                        
-                        // Force a progress update immediately
-                        progressRunnable.run()
-                    }
-                }
-            })
+            // Explicitly set repeat mode here based on current state
+            if (isPlaylist) {
+                 player?.repeatMode = Player.REPEAT_MODE_OFF // Force OFF for playlists
+            } else {
+                 player?.repeatMode = if (loop) Player.REPEAT_MODE_ONE else Player.REPEAT_MODE_OFF // Use loop prop for single videos
+             }
+
+            Log.d(TAG, "ExoPlayer configured with URL: $url, autoplay: $autoplay, loop: $loop, isPaused: $isPaused, repeatMode: ${player?.repeatMode}")
+            // Send load start event, include index if it's a playlist
+            val loadStartEvent = Arguments.createMap()
+            if (isPlaylist) {
+                loadStartEvent.putInt("index", currentVideoIndex)
+            }
+            sendEvent(EVENT_LOAD_START, loadStartEvent) 
+
         } catch (e: Exception) {
-            Log.e(TAG, "Error setting video URL: ${e.message}", e)
-            
-            // Send error event
+            Log.e(TAG, "Error setting video source: ${e.message}", e)
             val event = Arguments.createMap()
             event.putString("code", "SOURCE_ERROR")
             event.putString("message", "Failed to load video source: $url")
@@ -281,14 +315,71 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
         }
     }
 
+    // Method to load a specific video from the playlist
+    private fun loadVideoAtIndex(index: Int) {
+        if (index >= 0 && index < videoUrls.size) {
+            currentVideoIndex = index
+            val url = videoUrls[index]
+            Log.d(TAG, "Loading playlist item at index $index: $url")
+            loadVideoSource(url)
+        } else {
+            Log.e(TAG, "Invalid index $index for playlist size ${videoUrls.size}")
+        }
+    }
+
+    // Called by ViewManager for single URL
+    fun setVideoUrl(url: String?) {
+        Log.d(TAG, "Setting single video URL: $url")
+        isPlaylist = false // Mark as not a playlist
+        videoUrls = emptyList() // Clear any previous playlist
+        currentVideoIndex = 0
+
+        if (url != null && url.isNotEmpty()) { // Check for non-null and non-empty
+            videoUrl = url // Store the non-null url
+            loadVideoSource(url) // Call loadVideoSource only when url is guaranteed non-null
+        } else {
+            Log.w(TAG, "Received null or empty URL for single video.")
+            player?.stop()
+            player?.clearMediaItems()
+            videoUrl = null // Ensure internal state is cleared
+            // Optionally show thumbnail or placeholder if URL is cleared
+        }
+    }
+
+    // Called by ViewManager for URL list (playlist)
+    fun setVideoUrls(urls: List<String>) {
+        Log.d(TAG, "Setting video URL list (playlist) with ${urls.size} items.")
+        if (urls.isEmpty()) {
+            Log.w(TAG, "Received empty URL list.")
+            setVideoUrl(null) // Treat empty list as clearing the source
+            return
+        }
+        isPlaylist = true // Mark as a playlist
+        videoUrl = null // Clear single video URL
+        videoUrls = urls
+        currentVideoIndex = 0 // Start from the beginning
+
+        // Load the first video in the playlist
+        loadVideoAtIndex(currentVideoIndex)
+    }
+
     fun setAutoplay(value: Boolean) {
         autoplay = value
         player?.playWhenReady = value
     }
 
     fun setLoop(value: Boolean) {
+        Log.d(TAG, "Setting loop to: $value, isPlaylist: $isPlaylist")
         loop = value
-        player?.repeatMode = if (loop) Player.REPEAT_MODE_ALL else Player.REPEAT_MODE_OFF
+        // Only set ExoPlayer's repeatMode if NOT in playlist mode.
+        // Playlist looping is handled manually in onPlaybackStateChanged.
+        if (!isPlaylist) {
+             // Use REPEAT_MODE_ONE for single item looping
+             player?.repeatMode = if (loop) Player.REPEAT_MODE_ONE else Player.REPEAT_MODE_OFF
+        } else {
+             // Ensure repeat mode is off when handling playlists manually
+             player?.repeatMode = Player.REPEAT_MODE_OFF
+        }
     }
 
     fun setThumbnailUrl(url: String?) {
@@ -328,6 +419,89 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
         }
     }
 
+    fun setIsFullscreen(fullscreen: Boolean) {
+        Log.d(TAG, "setIsFullscreen called with value: $fullscreen")
+        if (this.isFullscreen == fullscreen) {
+            return // Already in the requested state
+        }
+
+        this.isFullscreen = fullscreen
+        val reactContext = context as? ReactContext ?: return
+        val activity = reactContext.currentActivity ?: return
+
+        if (fullscreen) {
+            enterFullscreen(activity)
+        } else {
+            exitFullscreen(activity)
+        }
+
+        // Send event about fullscreen state change
+        val event = Arguments.createMap()
+        event.putBoolean("isFullscreen", fullscreen)
+        sendEvent(EVENT_FULLSCREEN_CHANGED, event)
+    }
+
+    private fun enterFullscreen(activity: Activity) {
+        Log.d(TAG, "Entering fullscreen mode")
+
+        // Save current orientation
+        originalOrientation = activity.requestedOrientation
+
+        // Force landscape orientation
+        activity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
+
+        // Hide system UI for fullscreen
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            activity.window.insetsController?.let { controller ->
+                controller.hide(android.view.WindowInsets.Type.statusBars())
+                controller.hide(android.view.WindowInsets.Type.navigationBars())
+                controller.systemBarsBehavior = android.view.WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+            }
+        } else {
+            @Suppress("DEPRECATION")
+            originalSystemUiVisibility = activity.window.decorView.systemUiVisibility
+            @Suppress("DEPRECATION")
+            activity.window.decorView.systemUiVisibility = (
+                android.view.View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
+                or android.view.View.SYSTEM_UI_FLAG_FULLSCREEN
+                or android.view.View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+                or android.view.View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+                or android.view.View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                or android.view.View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+            )
+        }
+
+        // Add FLAG_KEEP_SCREEN_ON to prevent screen from turning off during playback
+        activity.window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+
+        // Simply inform React Native that we want fullscreen
+        // The React Native side should handle hiding other UI elements
+        Log.d(TAG, "Fullscreen mode activated - orientation changed to landscape")
+    }
+
+    private fun exitFullscreen(activity: Activity) {
+        Log.d(TAG, "Exiting fullscreen mode")
+
+        // Force back to portrait orientation
+        activity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+
+        // Restore system UI
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            activity.window.insetsController?.let { controller ->
+                controller.show(android.view.WindowInsets.Type.statusBars())
+                controller.show(android.view.WindowInsets.Type.navigationBars())
+            }
+        } else {
+            @Suppress("DEPRECATION")
+            activity.window.decorView.systemUiVisibility = originalSystemUiVisibility
+        }
+
+        // Remove FLAG_KEEP_SCREEN_ON
+        activity.window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+
+        Log.d(TAG, "Fullscreen mode exited - orientation restored")
+    }
+
     fun play() {
         Log.d(TAG, "Play method called")
         player?.playWhenReady = true
@@ -346,7 +520,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")
     }
 
@@ -381,7 +555,7 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
     private fun sendEvent(eventName: String, params: WritableMap) {
         try {
             // Log the event for debugging
-            Log.d(TAG, "Sending direct event: $eventName with params: $params")
+            // Log.d(TAG, "Sending direct event: $eventName with params: $params")
             
             // Map event names to their corresponding top event names
             val topEventName = when (eventName) {
@@ -394,6 +568,7 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
                 EVENT_PLAYING -> "topPlaying"
                 EVENT_PAUSED -> "topPlaybackPaused"
                 EVENT_LOAD_START -> "topLoadStart"
+                EVENT_FULLSCREEN_CHANGED -> "topFullscreenChanged"
                 else -> "top${eventName.substring(2)}" // Fallback for any other events
             }
             
@@ -406,13 +581,22 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
         }
     }
     
-    // Add a method to explicitly start progress updates
+    // Method to explicitly start progress updates
     private fun startProgressUpdates() {
-        Log.d(TAG, "Starting progress updates")
-        // Remove any existing callbacks to avoid duplicates
+        // Only start if player is ready and has duration
+        if (player?.playbackState == Player.STATE_READY && (player?.duration ?: 0) > 0) {
+             Log.d(TAG, "Starting progress updates")
+             progressHandler.removeCallbacks(progressRunnable) // Remove existing callbacks
+             progressHandler.post(progressRunnable) // Post the runnable
+        } else {
+             Log.d(TAG, "Skipping progress updates start: Player not ready or duration is 0")
+        }
+    }
+
+    // Method to stop progress updates
+    private fun stopProgressUpdates() {
+        Log.d(TAG, "Stopping progress updates")
         progressHandler.removeCallbacks(progressRunnable)
-        // Post the runnable to start updates
-        progressHandler.post(progressRunnable)
     }
 
     override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
@@ -453,14 +637,17 @@ class UnifiedPlayerView(context: Context) : FrameLayout(context) {
         // Log.d(TAG, "TextureView onSurfaceTextureUpdated")
     }
 }
-        startProgressUpdates() // Use the new method to start progress updates
+        // Don't start progress updates here automatically, wait for STATE_READY
+        // startProgressUpdates()
     }
 
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
         Log.d(TAG, "UnifiedPlayerView onDetachedFromWindow")
-        progressHandler.removeCallbacks(progressRunnable) // Stop progress updates
+        stopProgressUpdates() // Stop progress updates
         player?.release()
+        player = null // Ensure player is nullified
+        cleanupRecording() // Clean up recording resources if any
     }
 
     fun capture(): String {

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

@@ -6,6 +6,8 @@ import com.facebook.react.uimanager.annotations.ReactProp
 import com.facebook.react.common.MapBuilder
 import android.util.Log
 import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.Dynamic // Import Dynamic
+import com.facebook.react.bridge.ReadableType // Import ReadableType
 import com.facebook.react.uimanager.events.RCTEventEmitter
 
 class UnifiedPlayerViewManager : SimpleViewManager<UnifiedPlayerView>() {
@@ -19,8 +21,38 @@ class UnifiedPlayerViewManager : SimpleViewManager<UnifiedPlayerView>() {
   }
 
   @ReactProp(name = "videoUrl")
-  fun setVideoUrl(view: UnifiedPlayerView, url: String?) {
-    view.setVideoUrl(url)
+  fun setVideoUrl(view: UnifiedPlayerView, videoUrl: Dynamic?) {
+    if (videoUrl == null) {
+      view.setVideoUrl(null)
+      return
+    }
+
+    when (videoUrl.type) {
+      ReadableType.String -> {
+        view.setVideoUrl(videoUrl.asString())
+      }
+      ReadableType.Array -> {
+        val urlList = mutableListOf<String>()
+        val array = videoUrl.asArray()
+        for (i in 0 until array.size()) {
+          if (array.getType(i) == ReadableType.String) {
+            val urlString = array.getString(i) // Get nullable string
+            if (urlString != null) { // Check if it's not null
+                 urlList.add(urlString) // Add the non-null string
+            } else {
+                 Log.w(TAG, "Null string found in videoUrl array at index $i.")
+            }
+          } else {
+            Log.w(TAG, "Invalid type in videoUrl array at index $i. Expected String.")
+          }
+        }
+        view.setVideoUrls(urlList) // Call the new method for playlists
+      }
+      else -> {
+        Log.w(TAG, "Invalid type for videoUrl prop. Expected String or Array.")
+        view.setVideoUrl(null) // Or handle error appropriately
+      }
+    }
   }
 
   @ReactProp(name = "thumbnailUrl")
@@ -43,6 +75,11 @@ class UnifiedPlayerViewManager : SimpleViewManager<UnifiedPlayerView>() {
     view.setIsPaused(isPaused)
   }
 
+  @ReactProp(name = "isFullscreen")
+  fun setIsFullscreen(view: UnifiedPlayerView, isFullscreen: Boolean) {
+    view.setIsFullscreen(isFullscreen)
+  }
+
 
   
   // Register direct events
@@ -60,6 +97,7 @@ class UnifiedPlayerViewManager : SimpleViewManager<UnifiedPlayerView>() {
       .put("topPlaybackPaused", MapBuilder.of("registrationName", "onPaused"))
       .put("topPlaying", MapBuilder.of("registrationName", "onPlaying"))
       .put("topLoadStart", MapBuilder.of("registrationName", "onLoadStart"))
+      .put("topFullscreenChanged", MapBuilder.of("registrationName", "onFullscreenChanged"))
       .build()
   }
 }

package/ios/UnifiedPlayerModule.m

@@ -248,6 +248,25 @@ RCT_EXPORT_METHOD(startRecording:(nonnull NSNumber *)reactTag
     }];
 }
 
+RCT_EXPORT_METHOD(toggleFullscreen:(nonnull NSNumber *)reactTag
+                  isFullscreen:(BOOL)isFullscreen
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        UIView *view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[UnifiedPlayerUIView class]]) {
+            RCTLogError(@"Invalid view returned from registry, expecting UnifiedPlayerUIView, got: %@", view);
+            reject(@"E_INVALID_VIEW", @"Expected UnifiedPlayerUIView", nil);
+            return;
+        }
+
+        UnifiedPlayerUIView *playerView = (UnifiedPlayerUIView *)view;
+        [playerView toggleFullscreen:isFullscreen];
+        resolve(@(YES));
+    }];
+}
+
 RCT_EXPORT_METHOD(stopRecording:(nonnull NSNumber *)reactTag
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)

package/ios/UnifiedPlayerUIView.h

@@ -10,11 +10,15 @@ NS_ASSUME_NONNULL_BEGIN
 @interface UnifiedPlayerUIView : UIView <VLCMediaPlayerDelegate>
 
 @property (nonatomic, strong) VLCMediaPlayer *player;
-@property (nonatomic, copy) NSString *videoUrlString;
-@property (nonatomic, copy) NSString *thumbnailUrlString;
+@property (nonatomic, copy, nullable) NSString *videoUrlString; // Single URL
+@property (nonatomic, copy, nullable) NSArray<NSString *> *videoUrlArray; // Playlist URLs
+@property (nonatomic, assign) NSInteger currentVideoIndex;
+@property (nonatomic, assign) BOOL isPlaylist;
+@property (nonatomic, copy, nullable) NSString *thumbnailUrlString;
 @property (nonatomic, assign) BOOL autoplay;
 @property (nonatomic, assign) BOOL loop;
 @property (nonatomic, assign) BOOL isPaused;
+@property (nonatomic, assign) BOOL isFullscreen;
 @property (nonatomic, strong) NSArray *mediaOptions;
 @property (nonatomic, weak) RCTBridge *bridge;
 @property (nonatomic, assign) VLCMediaPlayerState previousState;
@@ -38,10 +42,13 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, copy) RCTDirectEventBlock onPlaybackResumed;
 @property (nonatomic, copy) RCTDirectEventBlock onPlaying;
 @property (nonatomic, copy) RCTDirectEventBlock onPaused;
+@property (nonatomic, copy) RCTDirectEventBlock onFullscreenChanged;
 
 // Method declarations
-- (void)setupWithVideoUrlString:(NSString *)videoUrlString;
-- (void)setupThumbnailWithUrlString:(NSString *)thumbnailUrlString;
+- (void)toggleFullscreen:(BOOL)fullscreen;
+- (void)setupWithVideoUrlString:(nullable NSString *)videoUrlString;
+- (void)setupWithVideoUrlArray:(NSArray<NSString *> *)urlArray; // New method for playlists
+- (void)setupThumbnailWithUrlString:(nullable NSString *)thumbnailUrlString;
 - (void)play;
 - (void)pause;
 - (void)seekToTime:(NSNumber *)timeNumber;