expo-libvlc-player 0.1.0

package/android/.idea/deviceManager.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="DeviceTable">
+    <option name="columnSorters">
+      <list>
+        <ColumnSorterState>
+          <option name="column" value="Name" />
+          <option name="order" value="ASCENDING" />
+        </ColumnSorterState>
+      </list>
+    </option>
+  </component>
+</project>

package/android/.idea/gradle.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
+  <component name="GradleSettings">
+    <option name="linkedExternalProjectsSettings">
+      <GradleProjectSettings>
+        <option name="testRunner" value="CHOOSE_PER_TEST" />
+        <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="gradleJvm" value="#GRADLE_LOCAL_JAVA_HOME" />
+      </GradleProjectSettings>
+    </option>
+  </component>
+</project>

package/android/.idea/misc.xml

@@ -0,0 +1,3 @@
+<project version="4">
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
+</project>

package/android/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/android.iml" filepath="$PROJECT_DIR$/.idea/android.iml" />
+    </modules>
+  </component>
+</project>

package/android/.idea/runConfigurations.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RunConfigurationProducerService">
+    <option name="ignoredProducers">
+      <set>
+        <option value="com.intellij.execution.junit.AbstractAllInDirectoryConfigurationProducer" />
+        <option value="com.intellij.execution.junit.AllInPackageConfigurationProducer" />
+        <option value="com.intellij.execution.junit.PatternConfigurationProducer" />
+        <option value="com.intellij.execution.junit.TestInClassConfigurationProducer" />
+        <option value="com.intellij.execution.junit.UniqueIdConfigurationProducer" />
+        <option value="com.intellij.execution.junit.testDiscovery.JUnitTestDiscoveryConfigurationProducer" />
+        <option value="org.jetbrains.kotlin.idea.junit.KotlinJUnitRunConfigurationProducer" />
+        <option value="org.jetbrains.kotlin.idea.junit.KotlinPatternConfigurationProducer" />
+      </set>
+    </option>
+  </component>
+</project>

package/android/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>

package/android/.idea/workspace.xml

@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="NONE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="ce1cf2d7-3e2c-41b3-ae06-62438ddceca7" name="Changes" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="ClangdSettings">
+    <option name="formatViaClangd" value="false" />
+  </component>
+  <component name="ExternalProjectsManager">
+    <system id="GRADLE">
+      <state>
+        <projects_view>
+          <tree_state>
+            <expand />
+            <select />
+          </tree_state>
+        </projects_view>
+      </state>
+    </system>
+  </component>
+  <component name="FormatOnSaveOptions">
+    <option name="myRunOnSave" value="true" />
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$/.." />
+  </component>
+  <component name="ProblemsViewState">
+    <option name="selectedTabId" value="ProjectErrors" />
+  </component>
+  <component name="ProjectColorInfo">{
+  &quot;associatedIndex&quot;: 0
+}</component>
+  <component name="ProjectId" id="2z2OVb2mI7QaoiYFjJWlUUfJ6HB" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "ModuleVcsDetector.initialDetectionPerformed": "true",
+    "RunOnceActivity.ShowReadmeOnStart": "true",
+    "RunOnceActivity.cidr.known.project.marker": "true",
+    "RunOnceActivity.git.unshallow": "true",
+    "RunOnceActivity.readMode.enableVisualFormatting": "true",
+    "android.gradle.sync.needed": "true",
+    "cf.first.check.clang-format": "false",
+    "cidr.known.project.marker": "true",
+    "git-widget-placeholder": "0.1.0",
+    "ignore.virus.scanning.warn.message": "true",
+    "kotlin-language-version-configured": "true",
+    "last_opened_file_path": "//wsl.localhost/Ubuntu/home/rarbit/dev/expo-libvlc-player/android",
+    "settings.editor.selected.configurable": "preferences.sourceCode"
+  }
+}]]></component>
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="ce1cf2d7-3e2c-41b3-ae06-62438ddceca7" name="Changes" comment="" />
+      <created>1750925729512</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1750925729512</updated>
+    </task>
+    <servers />
+  </component>
+</project>

package/android/build.gradle

@@ -0,0 +1,53 @@
+apply plugin: 'com.android.library'
+
+group = 'expo.modules.libvlcplayer'
+version = '0.1.0'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useExpoPublishing()
+
+// If you want to use the managed Android SDK versions from expo-modules-core, set this to true.
+// The Android SDK versions will be bumped from time to time in SDK releases and may introduce breaking changes in your module code.
+// Most of the time, you may like to manage the Android SDK versions yourself.
+def useManagedAndroidSdkVersions = false
+if (useManagedAndroidSdkVersions) {
+    useDefaultAndroidSdkVersions()
+} else {
+    buildscript {
+        // Simple helper that allows the root project to override versions declared by this library.
+        ext.safeExtGet = { prop, fallback ->
+            rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+        }
+    }
+    project.android {
+        compileSdkVersion safeExtGet("compileSdkVersion", 34)
+        defaultConfig {
+            minSdkVersion safeExtGet("minSdkVersion", 21)
+            targetSdkVersion safeExtGet("targetSdkVersion", 34)
+        }
+    }
+}
+
+android {
+    namespace "expo.modules.libvlcplayer"
+    defaultConfig {
+        versionCode 1
+        versionName "0.1.0"
+        consumerProguardFiles("proguard-rules.pro")
+    }
+    lintOptions {
+        abortOnError false
+    }
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-native:+'
+    implementation 'org.videolan.android:libvlc-all:3.6.2'
+}

package/android/local.properties

@@ -0,0 +1,8 @@
+## This file must *NOT* be checked into Version Control Systems,
+# as it contains information specific to your local configuration.
+#
+# Location of the SDK. This is only used by Gradle.
+# For customization when using a Version Control System, please read the
+# header note.
+#Thu Jun 26 02:15:26 CST 2025
+sdk.dir=C\:\\Users\\rarbit\\AppData\\Local\\Android\\Sdk

package/android/proguard-rules.pro

@@ -0,0 +1,19 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /home/tom/work/android/sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+-keep class org.videolan.libvlc.** { *; }

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+</manifest>

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

@@ -0,0 +1,210 @@
+package expo.modules.libvlcplayer
+
+import kotlinx.coroutines.launch
+
+import java.lang.ref.WeakReference
+
+import expo.modules.libvlcplayer.enums.AudioMixingMode
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioFocusRequest
+import android.media.AudioManager
+import android.os.Build
+
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.types.Enumerable
+
+import org.videolan.libvlc.MediaPlayer
+
+class AudioFocusManager(
+    private val appContext: AppContext,
+    private var views: MutableList<WeakReference<VlcPlayerView>>
+) :
+    AudioManager.OnAudioFocusChangeListener {
+    private val audioManager by lazy {
+        appContext.reactContext?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager ?: run {
+            throw CodedException("Failed to get AudioFocusManager service")
+        }
+    }
+
+    private var currentFocusRequest: AudioFocusRequest? = null
+    private var currentMixingMode: AudioMixingMode = AudioMixingMode.MIX_WITH_OTHERS
+    private val anyPlayerRequiresFocus: Boolean
+        get() = views.toList().any { weakView ->
+            weakView.get()?.let { view ->
+                playerRequiresFocus(view.mediaPlayer)
+            } ?: false
+        }
+
+    private var previousVolume: Int = MAX_PLAYER_VOLUME
+
+    private fun playerRequiresFocus(player: MediaPlayer?): Boolean {
+        val mPlayer = player ?: return false
+        return mPlayer.isPlaying() && mPlayer.getVolume() > MIN_PLAYER_VOLUME
+    }
+
+    private fun findAudioMixingMode(): AudioMixingMode {
+        val mixingModes = views.toList().mapNotNull { view ->
+            view.get()?.takeIf { it.mediaPlayer?.isPlaying() == true }?.audioMixingMode
+        }
+
+        if (mixingModes.isEmpty()) {
+            return AudioMixingMode.MIX_WITH_OTHERS
+        }
+
+        return mixingModes.reduce { currentAudioMixingMode, next ->
+            next.takeIf { it.priority > currentAudioMixingMode.priority } ?: currentAudioMixingMode
+        }
+    }
+
+    private fun requestAudioFocus() {
+        val audioMixingMode = findAudioMixingMode()
+
+        if (audioMixingMode == AudioMixingMode.MIX_WITH_OTHERS || !anyPlayerRequiresFocus) {
+            abandonAudioFocus()
+            currentMixingMode = audioMixingMode
+            return
+        }
+
+        val audioFocusType = when (currentMixingMode) {
+            AudioMixingMode.DUCK_OTHERS -> AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK
+            AudioMixingMode.AUTO -> AudioManager.AUDIOFOCUS_GAIN
+            AudioMixingMode.DO_NOT_MIX -> AudioManager.AUDIOFOCUS_GAIN
+            else -> AudioManager.AUDIOFOCUS_GAIN
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            currentFocusRequest?.let {
+                if (it.focusGain == audioFocusType) {
+                    return
+                }
+            }
+
+            val newFocusRequest = AudioFocusRequest.Builder(audioFocusType).run {
+                setAudioAttributes(
+                    AudioAttributes.Builder().run {
+                        setUsage(AudioAttributes.USAGE_MEDIA)
+                        setContentType(AudioAttributes.CONTENT_TYPE_MOVIE)
+                        setOnAudioFocusChangeListener(this@AudioFocusManager)
+                        build()
+                    }
+                ).build()
+            }
+
+            currentFocusRequest = newFocusRequest
+            audioManager.requestAudioFocus(newFocusRequest)
+        } else {
+            @Suppress("DEPRECATION")
+            audioManager.requestAudioFocus(this, AudioManager.STREAM_MUSIC, audioFocusType)
+        }
+
+        currentMixingMode = audioMixingMode
+    }
+
+    private fun abandonAudioFocus() {
+        currentFocusRequest?.let {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                audioManager.abandonAudioFocusRequest(it)
+            } else {
+                @Suppress("DEPRECATION")
+                audioManager.abandonAudioFocus(this)
+            }
+        }
+
+        currentFocusRequest = null
+    }
+
+    fun updateAudioFocus() {
+        if (anyPlayerRequiresFocus || findAudioMixingMode() != currentMixingMode) {
+            requestAudioFocus()
+        } else {
+            abandonAudioFocus()
+        }
+    }
+
+    override fun onAudioFocusChange(focusChange: Int) {
+        when (focusChange) {
+            AudioManager.AUDIOFOCUS_LOSS -> {
+                appContext.mainQueue.launch {
+                    views.forEach { view ->
+                        pausePlayerIfUnmuted(view.get()?.mediaPlayer)
+                    }
+
+                    currentFocusRequest = null
+                }
+            }
+
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+                val audioMixingMode = findAudioMixingMode()
+
+                if (audioMixingMode == AudioMixingMode.MIX_WITH_OTHERS) {
+                    return
+                }
+
+                appContext.mainQueue.launch {
+                    views.forEach { view ->
+                        pausePlayerIfUnmuted(view.get()?.mediaPlayer)
+                    }
+
+                    currentFocusRequest = null
+                }
+            }
+
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+                val audioMixingMode = findAudioMixingMode()
+
+                appContext.mainQueue.launch {
+                    views.forEach { view ->
+                        view.get()?.mediaPlayer?.let { player ->
+                            if (audioMixingMode == AudioMixingMode.DO_NOT_MIX) {
+                                pausePlayerIfUnmuted(player)
+                            } else {
+                                duckPlayer(player)
+                            }
+                        }
+                    }
+                }
+            }
+
+            AudioManager.AUDIOFOCUS_GAIN -> {
+                appContext.mainQueue.launch {
+                    views.forEach { view ->
+                        unduckPlayer(view.get()?.mediaPlayer)
+                    }
+                }
+            }
+        }
+    }
+
+    private fun pausePlayerIfUnmuted(player: MediaPlayer?) {
+        player?.let { mediaPlayer ->
+            if (mediaPlayer.getVolume() > MIN_PLAYER_VOLUME) {
+                appContext.mainQueue.launch {
+                    mediaPlayer.pause()
+                }
+            }
+        }
+    }
+
+    private fun duckPlayer(player: MediaPlayer?) {
+        player?.let { weakPlayer ->
+            appContext.mainQueue.launch {
+                val volume = weakPlayer.getVolume() / 20
+                weakPlayer.setVolume(volume)
+                previousVolume = volume
+            }
+        }
+    }
+
+    private fun unduckPlayer(player: MediaPlayer?) {
+        player?.let { weakPlayer ->
+            if (weakPlayer.getVolume() > MIN_PLAYER_VOLUME) {
+                appContext.mainQueue.launch {
+                    weakPlayer.setVolume(previousVolume)
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,82 @@
+package expo.modules.libvlcplayer
+
+import java.lang.ref.WeakReference
+
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.exception.Exceptions
+
+import org.videolan.libvlc.MediaPlayer
+
+object VlcPlayerManager {
+    private var views: MutableList<WeakReference<VlcPlayerView>> = mutableListOf()
+
+    lateinit var audioFocusManager: AudioFocusManager
+
+    fun onModuleCreated(appContext: AppContext) {
+        val context = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+
+        if (!this::audioFocusManager.isInitialized) {
+            audioFocusManager = AudioFocusManager(appContext, views)
+        }
+    }
+
+    fun registerView(view: VlcPlayerView) {
+        views.find { it.get() == view } ?: run { views.add(WeakReference(view)) }
+        audioFocusManager.updateAudioFocus()
+    }
+
+    fun unregisterView(view: VlcPlayerView) {
+        views.removeAll { it.get() == view }
+        audioFocusManager.updateAudioFocus()
+    }
+
+    fun onAppDestroyed() {
+        views.forEach { view ->
+            view.get()?.destroyPlayer()
+        }
+    }
+
+    fun onViewDestroyed(view: VlcPlayerView) {
+        view.destroyPlayer()
+    }
+
+    fun onAppForegrounded() {
+        views.forEach { view ->
+            view.get()?.let { playerView ->
+                playerView.mediaPlayer?.let { player ->
+                    player.attachViews(
+                        playerView.videoLayout,
+                        null,
+                        ENABLE_SUBTITLES,
+                        USE_TEXTURE_VIEW
+                    )
+
+                    if (!player.isPlaying()) {
+                        val time = player.getTime()
+                        val error = (-1).toLong()
+
+                        if (time != error) {
+                            player.setTime(time)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fun onAppBackgrounded() {
+        views.forEach { view ->
+            view.get()?.let { playerView ->
+                playerView.onBackground(mapOf())
+
+                playerView.mediaPlayer?.let { player ->
+                    if (!playerView.playInBackground && player.isPlaying()) {
+                        player.pause()
+                    }
+
+                    player.detachViews()
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,129 @@
+package expo.modules.libvlcplayer
+
+import expo.modules.libvlcplayer.enums.AudioMixingMode
+
+import com.facebook.react.bridge.ReadableMap
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+private const val BUFFERING_EVENT = "onBuffering"
+private const val PLAYING_EVENT = "onPlaying"
+private const val PAUSED_EVENT = "onPaused"
+private const val STOPPED_EVENT = "onStopped"
+private const val ENDED_EVENT = "onEnded"
+private const val REPEAT_EVENT = "onRepeat"
+private const val WARN_EVENT = "onWarn"
+private const val ERROR_EVENT = "onError"
+private const val POSITION_CHANGED_EVENT = "onPositionChanged"
+private const val LOAD_EVENT = "onLoad"
+private const val BACKGROUND_EVENT = "onBackground"
+
+val playerEvents = arrayOf(
+    BUFFERING_EVENT,
+    PLAYING_EVENT,
+    PAUSED_EVENT,
+    STOPPED_EVENT,
+    ENDED_EVENT,
+    REPEAT_EVENT,
+    WARN_EVENT,
+    ERROR_EVENT,
+    POSITION_CHANGED_EVENT,
+    LOAD_EVENT,
+    BACKGROUND_EVENT
+)
+
+class VlcPlayerModule : Module() {
+    override fun definition() = ModuleDefinition {
+        Name("ExpoLibVlcPlayer")
+
+        OnCreate {
+            VlcPlayerManager.onModuleCreated(appContext)
+        }
+
+        OnDestroy {
+            VlcPlayerManager.onAppDestroyed()
+        }
+
+        View(VlcPlayerView::class) {
+            Events(playerEvents)
+
+            Prop("uri") { view: VlcPlayerView, uri: String ->
+                view.uri = uri
+            }
+
+            Prop("subtitle") { view: VlcPlayerView, subtitle: ReadableMap? ->
+                view.setSubtitle(subtitle)
+            }
+
+            Prop("options") { view: VlcPlayerView, options: ArrayList<String>? ->
+                view.options = options ?: ArrayList<String>()
+            }
+
+            Prop("volume") { view: VlcPlayerView, volume: Int? ->
+                view.setVolume(volume ?: MAX_PLAYER_VOLUME)
+            }
+
+            Prop("mute") { view: VlcPlayerView, mute: Boolean? ->
+                view.setMute(mute ?: false)
+            }
+
+            Prop("rate") { view: VlcPlayerView, rate: Float? ->
+                view.setRate(rate ?: DEFAULT_PLAYER_RATE)
+            }
+
+            Prop("tracks") { view: VlcPlayerView, tracks: ReadableMap? ->
+                view.setTracks(tracks)
+            }
+
+            Prop("repeat") { view: VlcPlayerView, repeat: Boolean? ->
+                view.setRepeat(repeat ?: false)
+            }
+
+            Prop("aspectRatio") { view: VlcPlayerView, aspectRatio: String? ->
+                view.setAspectRatio(aspectRatio)
+            }
+
+            Prop("audioMixingMode") { view: VlcPlayerView, audioMixingMode: AudioMixingMode ->
+                view.audioMixingMode = audioMixingMode
+            }
+
+            Prop("playInBackground") { view: VlcPlayerView, playInBackground: Boolean? ->
+                view.playInBackground = playInBackground ?: false
+            }
+
+            Prop("autoplay") { view: VlcPlayerView, autoplay: Boolean? ->
+                view.setAutoplay(autoplay ?: true)
+            }
+
+            OnViewDestroys { view: VlcPlayerView ->
+                VlcPlayerManager.onViewDestroyed(view)
+                VlcPlayerManager.unregisterView(view)
+            }
+
+            AsyncFunction("play") { view: VlcPlayerView ->
+                view.play()
+            }
+
+            AsyncFunction("pause") { view: VlcPlayerView ->
+                view.pause()
+            }
+
+            AsyncFunction("stop") { view: VlcPlayerView ->
+                view.stop()
+            }
+
+            AsyncFunction("seek") { view: VlcPlayerView, position: Float ->
+                view.seek(position)
+            }
+        }
+
+        OnActivityEntersForeground {
+            VlcPlayerManager.onAppForegrounded()
+        }
+
+        OnActivityEntersBackground {
+            VlcPlayerManager.onAppBackgrounded()
+        }
+    }
+}