expo-libvlc-player 3.4.13 → 3.4.15

package/android/build.gradle

@@ -1,7 +1,7 @@
 apply plugin: 'com.android.library'
 
 group = 'expo.modules.libvlcplayer'
-version = '3.4.13'
+version = '3.4.15'
 
 def expoModulesCorePlugin = new File(project(':expo-modules-core').projectDir.absolutePath, 'ExpoModulesCorePlugin.gradle')
 apply from: expoModulesCorePlugin
@@ -25,7 +25,7 @@ android {
         targetSdkVersion safeExtGet('targetSdkVersion', 35)
 
         versionCode 1
-        versionName '3.4.13'
+        versionName '3.4.15'
 
         consumerProguardFiles('proguard-rules.pro')
     }

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

@@ -5,8 +5,10 @@ import android.os.PowerManager
 import expo.modules.kotlin.exception.Exceptions
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.libvlcplayer.constants.MediaPlayerConstants
 import expo.modules.libvlcplayer.enums.AudioMixingMode
 import expo.modules.libvlcplayer.enums.VideoContentFit
+import expo.modules.libvlcplayer.managers.MediaPlayerManager
 import expo.modules.libvlcplayer.records.Slave
 import expo.modules.libvlcplayer.records.Tracks
 
@@ -83,56 +85,56 @@ class LibVlcPlayerModule : Module() {
                     view.source = source
                 }
 
-                Prop("options") { view: LibVlcPlayerView, options: ArrayList<String>? ->
-                    view.options = options ?: ArrayList<String>()
+                Prop("options", ArrayList<String>()) { view: LibVlcPlayerView, options: ArrayList<String> ->
+                    view.options = options
                 }
 
                 Prop("tracks") { view: LibVlcPlayerView, tracks: Tracks? ->
                     view.tracks = tracks
                 }
 
-                Prop("slaves") { view: LibVlcPlayerView, slaves: ArrayList<Slave>? ->
-                    view.slaves = slaves ?: ArrayList<Slave>()
+                Prop("slaves", ArrayList<Slave>()) { view: LibVlcPlayerView, slaves: ArrayList<Slave> ->
+                    view.slaves = slaves
                 }
 
-                Prop("scale") { view: LibVlcPlayerView, scale: Float? ->
-                    view.scale = scale ?: DEFAULT_PLAYER_SCALE
+                Prop("scale", MediaPlayerConstants.DEFAULT_PLAYER_SCALE) { view: LibVlcPlayerView, scale: Float ->
+                    view.scale = scale
                 }
 
-                Prop("contentFit") { view: LibVlcPlayerView, contentFit: VideoContentFit? ->
-                    view.contentFit = contentFit ?: VideoContentFit.CONTAIN
+                Prop("contentFit", VideoContentFit.CONTAIN) { view: LibVlcPlayerView, contentFit: VideoContentFit ->
+                    view.contentFit = contentFit
                 }
 
-                Prop("rate") { view: LibVlcPlayerView, rate: Float? ->
-                    view.rate = rate ?: DEFAULT_PLAYER_RATE
+                Prop("rate", MediaPlayerConstants.DEFAULT_PLAYER_RATE) { view: LibVlcPlayerView, rate: Float ->
+                    view.rate = rate
                 }
 
-                Prop("time") { view: LibVlcPlayerView, time: Int? ->
-                    view.time = time ?: DEFAULT_PLAYER_TIME
+                Prop("time", MediaPlayerConstants.DEFAULT_PLAYER_TIME) { view: LibVlcPlayerView, time: Int ->
+                    view.time = time
                 }
 
-                Prop("volume") { view: LibVlcPlayerView, volume: Int? ->
-                    view.volume = volume ?: MAX_PLAYER_VOLUME
+                Prop("volume", MediaPlayerConstants.MAX_PLAYER_VOLUME) { view: LibVlcPlayerView, volume: Int ->
+                    view.volume = volume
                 }
 
-                Prop("mute") { view: LibVlcPlayerView, mute: Boolean? ->
-                    view.mute = mute ?: false
+                Prop("mute", false) { view: LibVlcPlayerView, mute: Boolean ->
+                    view.mute = mute
                 }
 
-                Prop("audioMixingMode") { view: LibVlcPlayerView, audioMixingMode: AudioMixingMode? ->
-                    view.audioMixingMode = audioMixingMode ?: AudioMixingMode.AUTO
+                Prop("audioMixingMode", AudioMixingMode.AUTO) { view: LibVlcPlayerView, audioMixingMode: AudioMixingMode ->
+                    view.audioMixingMode = audioMixingMode
                 }
 
-                Prop("playInBackground") { view: LibVlcPlayerView, playInBackground: Boolean? ->
-                    view.playInBackground = playInBackground ?: false
+                Prop("playInBackground", false) { view: LibVlcPlayerView, playInBackground: Boolean ->
+                    view.playInBackground = playInBackground
                 }
 
-                Prop("repeat") { view: LibVlcPlayerView, repeat: Boolean? ->
-                    view.repeat = repeat ?: false
+                Prop("repeat", false) { view: LibVlcPlayerView, repeat: Boolean ->
+                    view.repeat = repeat
                 }
 
-                Prop("autoplay") { view: LibVlcPlayerView, autoplay: Boolean? ->
-                    view.autoplay = autoplay ?: true
+                Prop("autoplay", true) { view: LibVlcPlayerView, autoplay: Boolean ->
+                    view.autoplay = autoplay
                 }
 
                 OnViewDidUpdateProps { view: LibVlcPlayerView ->

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

@@ -12,8 +12,10 @@ import android.view.TextureView
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.viewevent.EventDispatcher
 import expo.modules.kotlin.views.ExpoView
+import expo.modules.libvlcplayer.constants.MediaPlayerConstants
 import expo.modules.libvlcplayer.enums.AudioMixingMode
 import expo.modules.libvlcplayer.enums.VideoContentFit
+import expo.modules.libvlcplayer.managers.MediaPlayerManager
 import expo.modules.libvlcplayer.records.Dialog
 import expo.modules.libvlcplayer.records.MediaInfo
 import expo.modules.libvlcplayer.records.MediaTracks
@@ -24,6 +26,8 @@ import expo.modules.libvlcplayer.records.Tracks
 import org.videolan.libvlc.LibVLC
 import org.videolan.libvlc.Media
 import org.videolan.libvlc.MediaPlayer
+import org.videolan.libvlc.MediaPlayer.Event
+import org.videolan.libvlc.MediaPlayer.EventListener
 import org.videolan.libvlc.interfaces.IMedia
 import org.videolan.libvlc.util.DisplayManager
 import org.videolan.libvlc.util.VLCVideoLayout
@@ -34,14 +38,6 @@ import java.text.SimpleDateFormat
 import java.util.Calendar
 import org.videolan.libvlc.Dialog as VLCDialog
 
-const val DEFAULT_PLAYER_RATE: Float = 1f
-const val DEFAULT_PLAYER_TIME: Int = 0
-const val DEFAULT_PLAYER_SCALE: Float = 0f
-
-const val MIN_PLAYER_VOLUME: Int = 0
-const val MAX_PLAYER_VOLUME: Int = 100
-const val PLAYER_VOLUME_STEP: Int = 10
-
 private val DISPLAY_MANAGER: DisplayManager? = null
 private val ENABLE_SUBTITLES: Boolean = true
 private val USE_TEXTURE_VIEW: Boolean = true
@@ -62,7 +58,7 @@ class LibVlcPlayerView(
 
     var mediaLength: Long? = null
 
-    private var shouldCreate: Boolean = false
+    private var shouldCreate: Boolean = true
     var firstPlay: Boolean = false
     var firstTime: Boolean = false
 
@@ -120,9 +116,10 @@ class LibVlcPlayerView(
 
         val source = source ?: return
 
-        options.toggleStartPausedOption(autoplay)
+        var initOptions = options
+        initOptions.toggleStartPausedOption(autoplay)
 
-        libVLC = LibVLC(context, options)
+        libVLC = LibVLC(context, initOptions)
         setDialogCallbacks()
         mediaPlayer = MediaPlayer(libVLC)
         setMediaPlayerListener()
@@ -167,12 +164,12 @@ class LibVlcPlayerView(
     }
 
     fun destroyPlayer() {
-        vlcDialog = null
-        media = null
-        mediaPlayer?.release()
-        mediaPlayer = null
         libVLC?.release()
         libVLC = null
+        mediaPlayer?.release()
+        mediaPlayer = null
+        media = null
+        vlcDialog = null
         removeAllViews()
     }
 
@@ -347,22 +344,22 @@ class LibVlcPlayerView(
         mediaPlayer?.let { player ->
             setPlayerTracks()
 
-            if (scale != DEFAULT_PLAYER_SCALE) {
+            if (scale != MediaPlayerConstants.DEFAULT_PLAYER_SCALE) {
                 player.setScale(scale)
             }
 
-            if (rate != DEFAULT_PLAYER_RATE) {
+            if (rate != MediaPlayerConstants.DEFAULT_PLAYER_RATE) {
                 player.setRate(rate)
             }
 
-            if (time != DEFAULT_PLAYER_TIME) {
+            if (time != MediaPlayerConstants.DEFAULT_PLAYER_TIME) {
                 player.setTime(time.toLong())
             }
 
-            if (volume != MAX_PLAYER_VOLUME || mute) {
+            if (volume != MediaPlayerConstants.MAX_PLAYER_VOLUME || mute) {
                 val newVolume =
                     if (mute) {
-                        MIN_PLAYER_VOLUME
+                        MediaPlayerConstants.MIN_PLAYER_VOLUME
                     } else {
                         volume
                     }
@@ -370,7 +367,7 @@ class LibVlcPlayerView(
                 player.setVolume(newVolume)
             }
 
-            time = DEFAULT_PLAYER_TIME
+            time = MediaPlayerConstants.DEFAULT_PLAYER_TIME
         }
     }
 
@@ -378,14 +375,14 @@ class LibVlcPlayerView(
         set(value) {
             val old = field
             field = value
-            shouldCreate = value != old
+            shouldCreate = true
         }
 
     var options: ArrayList<String> = ArrayList()
         set(value) {
             val old = field
             field = value
-            shouldCreate = value != old
+            shouldCreate = true
         }
 
     var tracks: Tracks? = null
@@ -405,7 +402,7 @@ class LibVlcPlayerView(
             }
         }
 
-    var scale: Float = DEFAULT_PLAYER_SCALE
+    var scale: Float = MediaPlayerConstants.DEFAULT_PLAYER_SCALE
         set(value) {
             field = value
             mediaPlayer?.setScale(value)
@@ -417,23 +414,19 @@ class LibVlcPlayerView(
             setContentFit()
         }
 
-    var rate: Float = DEFAULT_PLAYER_RATE
+    var rate: Float = MediaPlayerConstants.DEFAULT_PLAYER_RATE
         set(value) {
             field = value
             mediaPlayer?.setRate(value)
         }
 
-    var time: Int = DEFAULT_PLAYER_TIME
+    var time: Int = MediaPlayerConstants.DEFAULT_PLAYER_TIME
 
-    var volume: Int = MAX_PLAYER_VOLUME
+    var volume: Int = MediaPlayerConstants.MAX_PLAYER_VOLUME
         set(value) {
             field = value
 
-            if (options.hasAudioOption()) {
-                onEncounteredError(mapOf("error" to "Audio disabled via options"))
-            }
-
-            val newVolume = value.coerceIn(MIN_PLAYER_VOLUME, MAX_PLAYER_VOLUME)
+            val newVolume = value.coerceIn(MediaPlayerConstants.MIN_PLAYER_VOLUME, MediaPlayerConstants.MAX_PLAYER_VOLUME)
             MediaPlayerManager.audioFocusManager.oldVolume = newVolume
 
             if (!mute) {
@@ -446,13 +439,9 @@ class LibVlcPlayerView(
         set(value) {
             field = value
 
-            if (options.hasAudioOption()) {
-                onEncounteredError(mapOf("error" to "Audio disabled via options"))
-            }
-
             val newVolume =
                 if (value) {
-                    MIN_PLAYER_VOLUME
+                    MediaPlayerConstants.MIN_PLAYER_VOLUME
                 } else {
                     MediaPlayerManager.audioFocusManager.oldVolume
                 }
@@ -476,10 +465,6 @@ class LibVlcPlayerView(
     var repeat: Boolean = false
         set(value) {
             field = value
-
-            if (options.hasRepeatOption()) {
-                onEncounteredError(mapOf("error" to "Repeat enabled via options"))
-            }
         }
 
     var autoplay: Boolean = true
@@ -600,56 +585,188 @@ class LibVlcPlayerView(
             vlcDialog = null
         }
     }
+}
 
-    private fun ArrayList<String>.hasAudioOption(): Boolean {
-        val options =
-            setOf(
-                "--no-audio",
-                "-no-audio",
-                ":no-audio",
-            )
+fun LibVlcPlayerView.setMediaPlayerListener() {
+    mediaPlayer?.let { player ->
+        player.setEventListener(
+            EventListener { event ->
+                when (event.type) {
+                    Event.Buffering -> {
+                        onBuffering(Unit)
+                    }
 
-        return this.any { option -> option in options }
-    }
+                    Event.Playing -> {
+                        onPlaying(Unit)
 
-    fun ArrayList<String>.hasRepeatOption(): Boolean {
-        val options =
-            setOf(
-                "--input-repeat=",
-                "-input-repeat=",
-                ":input-repeat=",
-            )
-
-        return this.any { option ->
-            options.any { value ->
-                option.startsWith(value)
-            }
-        }
+                        if (firstPlay) {
+                            attachPlayer()
+
+                            setupPlayer()
+
+                            onFirstPlay(getMediaInfo())
+
+                            firstPlay = false
+                        }
+
+                        MediaPlayerManager.keepAwakeManager.activateKeepAwake()
+                        MediaPlayerManager.audioFocusManager.updateAudioFocus()
+                    }
+
+                    Event.Paused -> {
+                        onPaused(Unit)
+
+                        MediaPlayerManager.keepAwakeManager.deactivateKeepAwake()
+                        MediaPlayerManager.audioFocusManager.updateAudioFocus()
+                    }
+
+                    Event.Stopped -> {
+                        onStopped(Unit)
+
+                        detachPlayer()
+
+                        MediaPlayerManager.keepAwakeManager.deactivateKeepAwake()
+                        MediaPlayerManager.audioFocusManager.updateAudioFocus()
+
+                        firstPlay = true
+                        firstTime = true
+                    }
+
+                    Event.EndReached -> {
+                        onEndReached(Unit)
+
+                        player.stop()
+
+                        if (repeat) {
+                            player.play()
+                        }
+                    }
+
+                    Event.EncounteredError -> {
+                        onEncounteredError(mapOf("error" to "Media player encountered an error"))
+
+                        MediaPlayerManager.keepAwakeManager.deactivateKeepAwake()
+                        MediaPlayerManager.audioFocusManager.updateAudioFocus()
+
+                        firstPlay = true
+                        firstTime = true
+                    }
+
+                    Event.TimeChanged -> {
+                        onTimeChanged(mapOf("time" to player.getTime().toInt()))
+
+                        if (firstTime) {
+                            if (mediaLength == null) {
+                                onFirstPlay(getMediaInfo())
+                            }
+
+                            setContentFit()
+
+                            MediaPlayerManager.audioFocusManager.updateAudioFocus()
+
+                            firstTime = false
+                        }
+                    }
+
+                    Event.PositionChanged -> {
+                        onPositionChanged(mapOf("position" to player.getPosition()))
+                    }
+
+                    Event.ESAdded -> {
+                        onESAdded(getMediaTracks())
+                    }
+
+                    Event.RecordChanged -> {
+                        val recording =
+                            Recording(
+                                path = event.getRecordPath(),
+                                isRecording = event.getRecording(),
+                            )
+
+                        onRecordChanged(recording)
+                    }
+                }
+            },
+        )
     }
+}
+
+fun LibVlcPlayerView.setDialogCallbacks() {
+    libVLC?.let {
+        VLCDialog.setCallbacks(
+            it,
+            object : VLCDialog.Callbacks {
+                override fun onDisplay(dialog: VLCDialog.ErrorMessage) {
+                    vlcDialog = dialog
+
+                    val dialog =
+                        Dialog(
+                            title = dialog.getTitle(),
+                            text = dialog.getText(),
+                        )
+
+                    onDialogDisplay(dialog)
+                }
+
+                override fun onDisplay(dialog: VLCDialog.LoginDialog) {
+                    vlcDialog = dialog
+
+                    val dialog =
+                        Dialog(
+                            title = dialog.getTitle(),
+                            text = dialog.getText(),
+                        )
+
+                    onDialogDisplay(dialog)
+                }
+
+                override fun onDisplay(dialog: VLCDialog.QuestionDialog) {
+                    vlcDialog = dialog
 
-    private fun ArrayList<String>.hasStartPausedOption(): Boolean {
-        val options =
-            setOf(
-                "--start-paused",
-                "-start-paused",
-                ":start-paused",
-            )
+                    val dialog =
+                        Dialog(
+                            title = dialog.getTitle(),
+                            text = dialog.getText(),
+                            cancelText = dialog.getCancelText(),
+                            action1Text = dialog.getAction1Text(),
+                            action2Text = dialog.getAction2Text(),
+                        )
 
-        return this.any { option -> option in options }
+                    onDialogDisplay(dialog)
+                }
+
+                override fun onDisplay(dialog: VLCDialog.ProgressDialog) {}
+
+                override fun onCanceled(dialog: VLCDialog) {}
+
+                override fun onProgressUpdate(dialog: VLCDialog.ProgressDialog) {}
+            },
+        )
     }
+}
 
-    private fun ArrayList<String>.toggleStartPausedOption(autoplay: Boolean) {
-        val options =
-            setOf(
-                "--start-paused",
-                "-start-paused",
-                ":start-paused",
-            )
+private fun ArrayList<String>.hasStartPausedOption(): Boolean {
+    val options =
+        setOf(
+            "--start-paused",
+            "-start-paused",
+            ":start-paused",
+        )
 
-        this.removeAll(options)
+    return this.any { option -> option in options }
+}
 
-        if (!autoplay) {
-            this.add("--start-paused")
-        }
+private fun ArrayList<String>.toggleStartPausedOption(autoplay: Boolean) {
+    val options =
+        setOf(
+            "--start-paused",
+            "-start-paused",
+            ":start-paused",
+        )
+
+    this.removeAll(options)
+
+    if (!autoplay) {
+        this.add("--start-paused")
     }
 }

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

@@ -0,0 +1,9 @@
+package expo.modules.libvlcplayer.constants
+
+object MediaPlayerConstants {
+    const val DEFAULT_PLAYER_SCALE: Float = 0f
+    const val DEFAULT_PLAYER_RATE: Float = 1f
+    const val DEFAULT_PLAYER_TIME: Int = 0
+    const val MIN_PLAYER_VOLUME: Int = 0
+    const val MAX_PLAYER_VOLUME: Int = 100
+}

package/android/src/main/java/expo/modules/libvlcplayer/{AudioFocusManager.kt → managers/AudioFocusManager.kt}

@@ -1,4 +1,4 @@
-package expo.modules.libvlcplayer
+package expo.modules.libvlcplayer.managers
 
 import android.content.Context
 import android.media.AudioAttributes
@@ -7,6 +7,7 @@ import android.media.AudioManager
 import android.os.Build
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.exception.Exceptions
+import expo.modules.libvlcplayer.constants.MediaPlayerConstants
 import expo.modules.libvlcplayer.enums.AudioMixingMode
 import kotlinx.coroutines.launch
 import org.videolan.libvlc.MediaPlayer
@@ -23,23 +24,21 @@ class AudioFocusManager(
         }
     }
 
-    private val playerViews = MediaPlayerManager.playerViews
-
     private var currentFocusRequest: AudioFocusRequest? = null
 
     private val anyPlayerRequiresFocus: Boolean
         get() =
-            playerViews.toList().any { view ->
+            MediaPlayerManager.playerViews.toList().any { view ->
                 playerRequiresFocus(view.get()?.mediaPlayer)
             }
 
     var currentMixingMode: AudioMixingMode = AudioMixingMode.AUTO
 
-    var oldVolume: Int = MAX_PLAYER_VOLUME
+    var oldVolume: Int = MediaPlayerConstants.MAX_PLAYER_VOLUME
 
     private fun playerRequiresFocus(player: MediaPlayer?): Boolean {
         if (player != null) {
-            return player.isPlaying() && player.getVolume() > MIN_PLAYER_VOLUME
+            return player.isPlaying() && player.getVolume() > MediaPlayerConstants.MIN_PLAYER_VOLUME
         } else {
             return false
         }
@@ -47,7 +46,7 @@ class AudioFocusManager(
 
     private fun findAudioMixingMode(): AudioMixingMode {
         val mixingModes =
-            playerViews.toList().mapNotNull { playerView ->
+            MediaPlayerManager.playerViews.toList().mapNotNull { playerView ->
                 playerView
                     .get()
                     ?.takeIf { view ->
@@ -103,6 +102,7 @@ class AudioFocusManager(
             currentFocusRequest = newFocusRequest
             audioManager.requestAudioFocus(newFocusRequest)
         } else {
+            @Suppress("DEPRECATION")
             audioManager.requestAudioFocus(this, AudioManager.STREAM_MUSIC, audioFocusType)
         }
 
@@ -114,6 +114,7 @@ class AudioFocusManager(
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                 audioManager.abandonAudioFocusRequest(it)
             } else {
+                @Suppress("DEPRECATION")
                 audioManager.abandonAudioFocus(this)
             }
         }
@@ -131,7 +132,7 @@ class AudioFocusManager(
 
     private fun pausePlayerIfUnmuted(player: MediaPlayer?) {
         player?.let { mediaPlayer ->
-            if (mediaPlayer.getVolume() > MIN_PLAYER_VOLUME) {
+            if (mediaPlayer.getVolume() > MediaPlayerConstants.MIN_PLAYER_VOLUME) {
                 mediaPlayer.pause()
             }
         }
@@ -147,7 +148,7 @@ class AudioFocusManager(
 
     private fun unduckPlayer(player: MediaPlayer?) {
         player?.let { mediaPlayer ->
-            if (mediaPlayer.getVolume() > MIN_PLAYER_VOLUME) {
+            if (mediaPlayer.getVolume() > MediaPlayerConstants.MIN_PLAYER_VOLUME) {
                 mediaPlayer.setVolume(oldVolume)
             }
         }
@@ -157,7 +158,7 @@ class AudioFocusManager(
         when (focusChange) {
             AudioManager.AUDIOFOCUS_LOSS -> {
                 appContext.mainQueue.launch {
-                    playerViews.forEach { view ->
+                    MediaPlayerManager.playerViews.forEach { view ->
                         pausePlayerIfUnmuted(view.get()?.mediaPlayer)
                     }
 
@@ -173,7 +174,7 @@ class AudioFocusManager(
                 }
 
                 appContext.mainQueue.launch {
-                    playerViews.forEach { view ->
+                    MediaPlayerManager.playerViews.forEach { view ->
                         pausePlayerIfUnmuted(view.get()?.mediaPlayer)
                     }
 
@@ -185,7 +186,7 @@ class AudioFocusManager(
                 val audioMixingMode = findAudioMixingMode()
 
                 appContext.mainQueue.launch {
-                    playerViews.forEach { view ->
+                    MediaPlayerManager.playerViews.forEach { view ->
                         view.get()?.mediaPlayer?.let { player ->
                             if (audioMixingMode == AudioMixingMode.DO_NOT_MIX) {
                                 pausePlayerIfUnmuted(player)
@@ -199,7 +200,7 @@ class AudioFocusManager(
 
             AudioManager.AUDIOFOCUS_GAIN -> {
                 appContext.mainQueue.launch {
-                    playerViews.forEach { view ->
+                    MediaPlayerManager.playerViews.forEach { view ->
                         unduckPlayer(view.get()?.mediaPlayer)
                     }
                 }

package/android/src/main/java/expo/modules/libvlcplayer/{KeepAwakeManager.kt → managers/KeepAwakeManager.kt}

@@ -1,4 +1,4 @@
-package expo.modules.libvlcplayer
+package expo.modules.libvlcplayer.managers
 
 import android.app.Activity
 import android.view.WindowManager

package/android/src/main/java/expo/modules/libvlcplayer/{MediaPlayerManager.kt → managers/MediaPlayerManager.kt}

@@ -1,6 +1,7 @@
-package expo.modules.libvlcplayer
+package expo.modules.libvlcplayer.managers
 
 import expo.modules.kotlin.AppContext
+import expo.modules.libvlcplayer.LibVlcPlayerView
 import java.lang.ref.WeakReference
 
 object MediaPlayerManager {

package/ios/Constants/MediaPlayerConstants.swift

@@ -0,0 +1,7 @@
+enum MediaPlayerConstants {
+    static let defaultPlayerScale: Float = 0.0
+    static let defaultPlayerRate: Float = 1.0
+    static let defaultPlayerTime: Int = 0
+    static let minPlayerVolume: Int = 0
+    static let maxPlayerVolume: Int = 100
+}