expo-libvlc-player 6.0.0 → 6.0.2

package/android/build.gradle

@@ -29,5 +29,5 @@ repositories {
 }
 
 dependencies {
-  implementation 'org.videolan.android:libvlc-all:3.6.5'
+  implementation 'org.videolan.android:libvlc-all:3.7.0'
 }

package/android/src/main/java/expo/modules/libvlcplayer/LibVlcPlayerModule.kt

@@ -110,7 +110,7 @@ class LibVlcPlayerModule : Module() {
                 }
 
                 OnViewDestroys { view: LibVlcPlayerView ->
-                    MediaPlayerManager.unregisterPlayerView(view)
+                    MediaPlayerManager.unregisterExpoView(view)
                     view.destroyPlayer()
                 }
 
@@ -127,7 +127,7 @@ class LibVlcPlayerModule : Module() {
                 }
 
                 AsyncFunction("seek") { view: LibVlcPlayerView, value: Double, type: String? ->
-                    view.seek(value, type ?: "time")
+                    view.seek(value, type)
                 }
 
                 AsyncFunction("record") { view: LibVlcPlayerView, path: String? ->

package/android/src/main/java/expo/modules/libvlcplayer/LibVlcPlayerView.kt

@@ -6,9 +6,11 @@ import android.graphics.Matrix
 import android.net.Uri
 import android.os.Handler
 import android.os.Looper
+import android.util.Size
 import android.view.PixelCopy
 import android.view.Surface
 import android.view.TextureView
+import android.view.ViewGroup
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.viewevent.EventDispatcher
 import expo.modules.kotlin.views.ExpoView
@@ -42,17 +44,14 @@ private val DISPLAY_MANAGER: DisplayManager? = null
 private val ENABLE_SUBTITLES: Boolean = true
 private val USE_TEXTURE_VIEW: Boolean = true
 
-private val MAX_RETRY_COUNT: Int = 5
-
 class LibVlcPlayerView(
     context: Context,
     appContext: AppContext,
 ) : ExpoView(context, appContext) {
-    private val playerView = VLCVideoLayout(context)
+    private val playerView: VLCVideoLayout = VLCVideoLayout(context)
 
     var libVLC: LibVLC? = null
     var mediaPlayer: MediaPlayer? = null
-    var media: Media? = null
     var vlcDialog: VLCDialog? = null
 
     var firstPlay: Boolean = true
@@ -74,20 +73,20 @@ class LibVlcPlayerView(
     val onBackground by EventDispatcher<Unit>()
 
     init {
-        MediaPlayerManager.registerPlayerView(this)
-        addView(playerView)
+        MediaPlayerManager.registerExpoView(this)
+        addPlayerView()
     }
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
 
-        attachPlayer()
+        attachPlayerView()
     }
 
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
 
-        detachPlayer()
+        detachPlayerView()
     }
 
     override fun onSizeChanged(
@@ -114,11 +113,15 @@ class LibVlcPlayerView(
     }
 
     fun createPlayer() {
-        libVLC = LibVLC(context, options)
+        var args = options
+        args.toggleStartPausedOption(autoplay)
+
+        libVLC = LibVLC(context, args)
         setDialogCallbacks(libVLC!!)
 
         mediaPlayer = MediaPlayer(libVLC!!)
         setPlayerListener(mediaPlayer!!)
+        attachPlayerView()
 
         try {
             URI(source)
@@ -127,26 +130,32 @@ class LibVlcPlayerView(
             return
         }
 
-        media = Media(libVLC!!, Uri.parse(source!!))
-        mediaPlayer!!.setMedia(media!!)
-        media!!.release()
-
-        if (autoplay) {
-            mediaPlayer!!.play()
-        }
+        val media = Media(libVLC!!, Uri.parse(source!!))
+        mediaPlayer!!.setMedia(media)
+        media.release()
+        mediaPlayer!!.play()
 
         firstPlay = true
         shouldInit = false
     }
 
+    fun resetPlayer() {
+        detachPlayer()
+        attachPlayer()
+    }
+
     fun attachPlayer() {
-        mediaPlayer?.let { player ->
-            val parent = playerView.getParent()
+        attachPlayerView()
+        addPlayerView()
+    }
 
-            if (parent == null) {
-                addView(playerView)
-            }
+    fun detachPlayer() {
+        detachPlayerView()
+        removePlayerView()
+    }
 
+    fun attachPlayerView() {
+        mediaPlayer?.let { player ->
             val attached = player.getVLCVout().areViewsAttached()
 
             if (!attached) {
@@ -155,9 +164,30 @@ class LibVlcPlayerView(
         }
     }
 
-    fun detachPlayer() {
-        mediaPlayer?.detachViews()
-        removeAllViews()
+    fun detachPlayerView() {
+        mediaPlayer?.let { player ->
+            val attached = player.getVLCVout().areViewsAttached()
+
+            if (attached) {
+                player.detachViews()
+            }
+        }
+    }
+
+    fun addPlayerView() {
+        val parent = playerView.parent as? ViewGroup
+
+        if (parent == null) {
+            addView(playerView)
+        }
+    }
+
+    fun removePlayerView() {
+        val parent = playerView.parent as? ViewGroup
+
+        if (parent != null) {
+            removeView(playerView)
+        }
     }
 
     fun destroyPlayer() {
@@ -165,7 +195,6 @@ class LibVlcPlayerView(
         libVLC = null
         mediaPlayer?.release()
         mediaPlayer = null
-        media = null
         removeAllViews()
     }
 
@@ -210,9 +239,9 @@ class LibVlcPlayerView(
             val matrix = Matrix()
 
             mediaPlayer?.let { player ->
-                val video = player.getCurrentVideoTrack() ?: return@post
+                val video = getVideoSize()
 
-                if (hasVideoSize()) {
+                if (hasVideoSize) {
                     val viewWidth = view.width.toFloat()
                     val viewHeight = view.height.toFloat()
 
@@ -367,28 +396,29 @@ class LibVlcPlayerView(
         return mediaInfo
     }
 
-    fun hasAudioVideo(): Boolean {
-        val tracks = getMediaTracks()
-        val length = getMediaLength()
-
-        val hasAudio = tracks.audio.any { track -> track.id != -1 }
-        val hasVideo = tracks.video.any { track -> track.id != -1 }
+    fun getVideoSize(): Size {
+        val video = mediaPlayer?.getCurrentVideoTrack()
 
-        val hasAudioOnly = hasAudio && !hasVideo && length > 0L
-        val hasAudioAndVideo = hasAudio && hasVideo && hasVideoSize() && length > 0L
+        if (video != null) {
+            return Size(video.width, video.height)
+        }
 
-        return hasAudioOnly || hasAudioAndVideo
+        return Size(0, 0)
     }
 
-    fun hasVideoSize(): Boolean {
-        val video = mediaPlayer?.getCurrentVideoTrack()
+    val hasVideoOut: Boolean
+        get() {
+            val tracks = getMediaTracks()
+            val length = getMediaLength()
+            val hasVideo = tracks.video.any { track -> track.id != -1 }
+            return hasVideo && hasVideoSize && length > 0L
+        }
 
-        return if (video != null) {
-            video.width > 0 && video.height > 0
-        } else {
-            false
+    val hasVideoSize: Boolean
+        get() {
+            val video = getVideoSize()
+            return video.width > 0 && video.height > 0
         }
-    }
 
     var source: String? = null
         set(value) {
@@ -485,20 +515,33 @@ class LibVlcPlayerView(
         }
 
     fun play() {
-        mediaPlayer?.play()
+        mediaPlayer?.let { player ->
+            if (!autoplay) {
+                player.play()
+            }
+
+            player.play()
+        }
     }
 
     fun pause() {
         mediaPlayer?.pause()
     }
 
+    fun pauseIf(condition: Boolean? = true) {
+        mediaPlayer?.let { player ->
+            val shouldPause = condition == true && player.isPlaying()
+            if (shouldPause) player.pause()
+        }
+    }
+
     fun stop() {
         mediaPlayer?.stop()
     }
 
     fun seek(
         value: Double,
-        type: String,
+        type: String? = "time",
     ) {
         mediaPlayer?.let { player ->
             if (player.isSeekable()) {
@@ -537,9 +580,9 @@ class LibVlcPlayerView(
         mediaPlayer?.let { player ->
             try {
                 val view = getTextureView() ?: throw Exception()
-                val video = player.getCurrentVideoTrack() ?: throw Exception()
+                val video = getVideoSize()
 
-                if (!hasVideoSize()) throw Exception()
+                if (!hasVideoSize) throw Exception()
 
                 val surface = Surface(view.surfaceTexture)
                 val bitmap = Bitmap.createBitmap(video.width, video.height, Bitmap.Config.ARGB_8888)
@@ -588,169 +631,199 @@ class LibVlcPlayerView(
     }
 
     fun retryUntil(
-        maxRetries: Int = MAX_RETRY_COUNT,
+        maxRetries: Int = MediaPlayerConstants.MAX_RETRY_COUNT,
         retry: Int = 0,
-        delay: Long = 100L,
-        block: () -> Boolean,
+        delay: Long = MediaPlayerConstants.RETRY_DELAY_MS,
+        block: (isLastAttempt: Boolean) -> Boolean,
     ) {
-        if (block() || retry >= maxRetries) return
+        val isLastAttempt = retry >= maxRetries
+
+        if (block(isLastAttempt) || isLastAttempt) return
 
-        val expDelay = delay.toDouble() * 1.5
+        val expDelay = (delay.toDouble() * 1.5).toLong()
 
         postDelayed({
-            retryUntil(
-                maxRetries,
-                retry + 1,
-                expDelay.toLong(),
-                block,
-            )
+            retryUntil(maxRetries, retry + 1, expDelay, block)
         }, delay)
     }
 }
 
-fun LibVlcPlayerView.setPlayerListener(player: MediaPlayer) {
-    player.setEventListener(
-        EventListener { event ->
-            when (event.type) {
-                Event.Buffering -> {
-                    onBuffering(Unit)
-                }
+fun LibVlcPlayerView.setPlayerListener(mediaPlayer: MediaPlayer?) {
+    mediaPlayer?.let { player ->
+        player.setEventListener(
+            EventListener { event ->
+                val type = event.type
 
-                Event.Playing -> {
-                    onPlaying(Unit)
+                @Suppress("ktlint")
+                when (type) {
+                    Event.Buffering -> {
+                        onBuffering(Unit)
+                    }
 
-                    if (firstPlay) {
-                        retryUntil {
-                            onFirstPlay(getMediaInfo())
-                            return@retryUntil hasAudioVideo()
-                        }
+                    Event.Playing,
+                    Event.Paused,
+                    Event.Stopped -> {
+                        if (type == Event.Playing) {
+                            onPlaying(Unit)
 
-                        retryUntil {
-                            setContentFit()
-                            return@retryUntil hasVideoSize()
-                        }
+                            if (firstPlay) {
+                                setupPlayer()
 
-                        setupPlayer()
+                                firstPlay = false
 
-                        firstPlay = false
-                    }
+                                retryUntil { isLastAttempt ->
+                                    val shouldSendEvent = hasVideoOut || isLastAttempt
 
-                    attachPlayer()
+                                    if (shouldSendEvent) {
+                                        onFirstPlay(getMediaInfo())
+                                    }
 
-                    MediaPlayerManager.keepAwakeManager.toggleKeepAwake()
+                                    return@retryUntil hasVideoOut
+                                }
 
-                    retryUntil {
-                        val volume = player.getVolume()
-                        val hasVolume = volume > MediaPlayerConstants.MIN_PLAYER_VOLUME
-                        MediaPlayerManager.audioFocusManager.updateAudioFocus()
-                        return@retryUntil hasVolume
-                    }
-                }
+                                retryUntil { isLastAttempt ->
+                                    val shouldFitContent = hasVideoSize || isLastAttempt
 
-                Event.Paused -> {
-                    onPaused(Unit)
+                                    if (shouldFitContent) {
+                                        setContentFit()
+                                    }
 
-                    MediaPlayerManager.keepAwakeManager.toggleKeepAwake()
-                    MediaPlayerManager.audioFocusManager.updateAudioFocus()
-                }
+                                    return@retryUntil hasVideoSize
+                                }
+                            }
+                        }
+
+                        if (type == Event.Paused) {
+                            onPaused(Unit)
+                        }
 
-                Event.Stopped -> {
-                    onStopped(Unit)
+                        if (type == Event.Stopped) {
+                            onStopped(Unit)
 
-                    detachPlayer()
+                            resetPlayer()
 
-                    MediaPlayerManager.keepAwakeManager.toggleKeepAwake()
-                    MediaPlayerManager.audioFocusManager.updateAudioFocus()
-                }
+                            if (repeat) {
+                                player.play()
+                            }
+                        }
+
+                        MediaPlayerManager.keepAwakeManager.toggleKeepAwake()
+
+                        retryUntil { isLastAttempt ->
+                            val volume = player.getVolume()
+                            val hasVolume = volume > MediaPlayerConstants.MIN_PLAYER_VOLUME
+                            val shouldUpdateFocus = hasVolume || isLastAttempt
 
-                Event.EndReached -> {
-                    player.stop()
+                            if (shouldUpdateFocus) {
+                                MediaPlayerManager.audioFocusManager.updateAudioFocus()
+                            }
 
-                    if (repeat) {
-                        player.play()
+                            return@retryUntil hasVolume
+                        }
                     }
-                }
 
-                Event.EncounteredError -> {
-                    onEncounteredError(mapOf("error" to "Player encountered an error"))
+                    Event.EndReached -> {
+                        player.stop()
+                    }
 
-                    player.stop()
-                }
+                    Event.EncounteredError -> {
+                        onEncounteredError(mapOf("error" to "Player encountered an error"))
 
-                Event.TimeChanged -> {
-                    onTimeChanged(mapOf("time" to player.getTime().toInt()))
-                }
+                        player.stop()
+                    }
 
-                Event.PositionChanged -> {
-                    onPositionChanged(mapOf("position" to player.getPosition()))
-                }
+                    Event.TimeChanged -> {
+                        onTimeChanged(mapOf("time" to player.getTime().toInt()))
+                    }
+
+                    Event.PositionChanged -> {
+                        onPositionChanged(mapOf("position" to player.getPosition()))
+                    }
+
+                    Event.ESAdded -> {
+                        onESAdded(getMediaTracks())
+                    }
+
+                    Event.RecordChanged -> {
+                        val recording =
+                            Recording(
+                                path = event.getRecordPath(),
+                                isRecording = event.getRecording(),
+                            )
 
-                Event.ESAdded -> {
-                    onESAdded(getMediaTracks())
+                        onRecordChanged(recording)
+                    }
                 }
+            },
+        )
+    }
+}
 
-                Event.RecordChanged -> {
-                    val recording =
-                        Recording(
-                            path = event.getRecordPath(),
-                            isRecording = event.getRecording(),
+fun LibVlcPlayerView.setDialogCallbacks(ILibVLC: LibVLC?) {
+    ILibVLC?.let { libVLC ->
+        VLCDialog.setCallbacks(
+            libVLC,
+            object : VLCDialog.Callbacks {
+                override fun onDisplay(dialog: VLCDialog.ErrorMessage) {
+                    vlcDialog = dialog
+
+                    val dialog =
+                        Dialog(
+                            title = dialog.getTitle(),
+                            text = dialog.getText(),
                         )
 
-                    onRecordChanged(recording)
+                    onDialogDisplay(dialog)
                 }
-            }
-        },
-    )
-}
 
-fun LibVlcPlayerView.setDialogCallbacks(libVLC: LibVLC) {
-    VLCDialog.setCallbacks(
-        libVLC,
-        object : VLCDialog.Callbacks {
-            override fun onDisplay(dialog: VLCDialog.ErrorMessage) {
-                vlcDialog = dialog
+                override fun onDisplay(dialog: VLCDialog.LoginDialog) {
+                    vlcDialog = dialog
 
-                val dialog =
-                    Dialog(
-                        title = dialog.getTitle(),
-                        text = dialog.getText(),
-                    )
+                    val dialog =
+                        Dialog(
+                            title = dialog.getTitle(),
+                            text = dialog.getText(),
+                        )
 
-                onDialogDisplay(dialog)
-            }
+                    onDialogDisplay(dialog)
+                }
 
-            override fun onDisplay(dialog: VLCDialog.LoginDialog) {
-                vlcDialog = dialog
+                override fun onDisplay(dialog: VLCDialog.QuestionDialog) {
+                    vlcDialog = dialog
 
-                val dialog =
-                    Dialog(
-                        title = dialog.getTitle(),
-                        text = dialog.getText(),
-                    )
+                    val dialog =
+                        Dialog(
+                            title = dialog.getTitle(),
+                            text = dialog.getText(),
+                            cancelText = dialog.getCancelText(),
+                            action1Text = dialog.getAction1Text(),
+                            action2Text = dialog.getAction2Text(),
+                        )
 
-                onDialogDisplay(dialog)
-            }
+                    onDialogDisplay(dialog)
+                }
 
-            override fun onDisplay(dialog: VLCDialog.QuestionDialog) {
-                vlcDialog = dialog
+                override fun onDisplay(dialog: VLCDialog.ProgressDialog) {}
 
-                val dialog =
-                    Dialog(
-                        title = dialog.getTitle(),
-                        text = dialog.getText(),
-                        cancelText = dialog.getCancelText(),
-                        action1Text = dialog.getAction1Text(),
-                        action2Text = dialog.getAction2Text(),
-                    )
+                override fun onCanceled(dialog: VLCDialog) {}
 
-                onDialogDisplay(dialog)
-            }
+                override fun onProgressUpdate(dialog: VLCDialog.ProgressDialog) {}
+            },
+        )
+    }
+}
 
-            override fun onDisplay(dialog: VLCDialog.ProgressDialog) {}
+private fun MutableList<String>.toggleStartPausedOption(autoplay: Boolean) {
+    val options =
+        setOf(
+            "--start-paused",
+            "-start-paused",
+            ":start-paused",
+        )
 
-            override fun onCanceled(dialog: VLCDialog) {}
+    removeAll { option -> option in options }
 
-            override fun onProgressUpdate(dialog: VLCDialog.ProgressDialog) {}
-        },
-    )
+    if (!autoplay) {
+        add("--start-paused")
+    }
 }

package/android/src/main/java/expo/modules/libvlcplayer/constants/MediaPlayerConstants.kt

@@ -6,4 +6,7 @@ object MediaPlayerConstants {
     const val DEFAULT_PLAYER_TIME: Int = 0
     const val MIN_PLAYER_VOLUME: Int = 0
     const val MAX_PLAYER_VOLUME: Int = 100
+
+    const val RETRY_DELAY_MS: Long = 200L
+    const val MAX_RETRY_COUNT: Int = 5
 }