expo-libmpv 0.1.0

package/README.md

@@ -0,0 +1,46 @@
+# expo-libmpv
+
+A libmpv native component for Android
+
+# Usage
+
+I only plan on supporting Android.
+
+iOS support contributions are welcome, but I have no way to test it.
+
+It uses the new Fabric architecture. This replaces react-native-libmpv's Native Module.
+
+The component will display video. Controls are handled by the app, not this library.
+
+Take a look at https://github.com/XBigTK13X/snowstream for a real app using the library.
+
+## Updating the AAR
+
+Pull down the fork of libmpv-android.
+
+Make the needed changes.
+
+Update the version in the kotlin file.
+
+Run `buildscripts/docker-build.sh`
+
+Run `buildscripts/prep-reposlite.sh VERSION`
+
+Copy the versioned aar and pom to ~/maven-repo
+
+Update the version in gradle.build
+
+
+# Dev docs
+
+https://docs.expo.dev/modules/native-view-tutorial/#add-an-event-to-notify-when-the-page-has-loaded
+
+https://docs.expo.dev/modules/module-api/#events
+
+https://docs.expo.dev/modules/module-api/#view
+
+# Credits
+
+I built this wrapper. But the library that drives the interactions with mpv comes from https://github.com/jarnedemeulemeester/libmpv-android.
+
+That repo is the baseline, I merged in a PR that handle multi instance support and tweaked some things to my liking.

package/android/build.gradle

@@ -0,0 +1,52 @@
+apply plugin: 'com.android.library'
+
+group = 'com.libmpv'
+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 {
+      repositories {
+      google()
+      mavenCentral()
+      maven { url "/home/kretst/maven-repo" }
+    }
+    // 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 26
+      targetSdkVersion safeExtGet("targetSdkVersion", 34)
+    }
+  }
+}
+
+dependencies {
+  implementation "com.libmpv:android-libmpv:0.5.10"
+}
+
+android {
+  namespace "com.libmpv"
+  defaultConfig {
+    versionCode 1
+    versionName "0.1.0"
+  }
+  lintOptions {
+    abortOnError false
+  }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest>
+</manifest>

package/android/src/main/java/com/libmpv/LibmpvVideoModule.kt

@@ -0,0 +1,105 @@
+package com.libmpv
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class LibmpvVideoModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("LibmpvVideo")
+    View(LibmpvVideoView::class) {
+      Events("onLibmpvLog", "onLibmpvEvent")
+
+      AsyncFunction("runCommand") { view: LibmpvVideoView, orders: String ->
+        view.runCommand(orders)
+      }
+
+      AsyncFunction("setOptionString") { view: LibmpvVideoView, options: String ->
+        view.setOptionString(options)
+      }
+
+      Prop("playUrl") { view: LibmpvVideoView, playUrl: String ->
+          view.playUrl = playUrl
+          if (view.isSurfaceReady()) {
+              view.mpv.play(playUrl)
+          } else {
+              view.attemptCreation()
+          }
+          view.log("setPlayUrl", playUrl)
+      }
+
+      Prop("useHardwareDecoder") { view: LibmpvVideoView, useHardwareDecoder: Boolean ->
+          view.useHardwareDecoder = useHardwareDecoder
+          if (view.isSurfaceReady()) {
+              view.setHardwareDecoder(useHardwareDecoder)
+          } else {
+              view.attemptCreation()
+          }
+          view.log("setUseHardwareDecoder", "$useHardwareDecoder")
+      }
+
+      Prop("surfaceWidth") { view: LibmpvVideoView, surfaceWidth: Int ->
+          view.surfaceWidth = surfaceWidth
+          if (view.isSurfaceReady()) {
+              view.mpv.setSurfaceWidth(surfaceWidth)
+          } else {
+              view.attemptCreation()
+          }
+          view.log("setSurfaceWidth", "$surfaceWidth")
+      }
+
+      Prop("surfaceHeight") { view: LibmpvVideoView, surfaceHeight: Int ->
+          view.surfaceHeight = surfaceHeight
+          if (view.isSurfaceReady()) {
+              view.mpv.setSurfaceHeight(surfaceHeight)
+          } else {
+              view.attemptCreation()
+          }
+          view.log("setSurfaceHeight", "$surfaceHeight")
+      }
+
+      Prop("selectedAudioTrack") { view: LibmpvVideoView, audioTrackIndex: Int ->
+          view.audioIndex = audioTrackIndex
+          if (view.isSurfaceReady()) {
+              val mpvIndex = if (audioTrackIndex != -1) (audioTrackIndex + 1).toString() else "no"
+              view.mpv.setOptionString("aid", mpvIndex)
+          } else {
+              view.attemptCreation()
+          }
+          view.log("selectAudioTrack", "$audioTrackIndex")
+      }
+
+      Prop("selectedSubtitleTrack") { view: LibmpvVideoView, subtitleTrackIndex: Int ->
+          view.subtitleIndex = subtitleTrackIndex
+          if (view.isSurfaceReady()) {
+              val mpvIndex = if (subtitleTrackIndex != -1) (subtitleTrackIndex + 1).toString() else "no"
+              view.mpv.setOptionString("sid", mpvIndex)
+          } else {
+              view.attemptCreation()
+          }
+          view.log("selectSubtitleTrack", "$subtitleTrackIndex")
+      }
+
+      Prop("seekToSeconds") { view: LibmpvVideoView, seconds: Int ->
+          if (view.isSurfaceReady()) {
+              view.mpv.seekToSeconds(seconds)
+          }
+          view.log("seekToSeconds", "$seconds")
+      }
+
+      Prop("isPlaying") { view: LibmpvVideoView, isPlaying: Boolean ->
+          if (view.isSurfaceReady() && view.mpv.hasPlayedOnce()) {
+              when {
+                  isPlaying && !view.mpv.isPlaying() -> {
+                      view.mpv.unpause()
+                  }
+                  !isPlaying && view.mpv.isPlaying() -> {
+                      view.mpv.pause()
+                  }
+              }
+          } else {
+              view.attemptCreation()
+          }
+      }
+    }
+  }
+}

package/android/src/main/java/com/libmpv/LibmpvVideoView.kt

@@ -0,0 +1,240 @@
+package com.libmpv
+
+import android.content.Context
+import android.view.SurfaceHolder
+import android.view.SurfaceView
+import android.widget.FrameLayout
+import dev.jdtech.mpv.MPVLib
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.views.ExpoView
+import expo.modules.kotlin.viewevent.EventDispatcher
+
+class LibmpvVideoView(context: Context, appContext: AppContext) :
+  ExpoView(context,appContext),
+  SurfaceHolder.Callback,
+  MPVLib.LogObserver,
+  MPVLib.EventObserver {
+
+  companion object {
+    const val HARDWARE_OPTIONS = "mediacodec-copy"
+    const val ACCELERATED_CODECS = "h264,hevc,mpeg4,mpeg2video,vp8,vp9,av1"
+  }
+
+  private val onLibmpvLog by EventDispatcher()
+  private val onLibmpvEvent by EventDispatcher()
+
+  private var isSurfaceCreated: Boolean = false
+  val mpv: LibmpvWrapper = LibmpvWrapper(context)
+  private val surfaceView: SurfaceView = SurfaceView(context)
+
+  // JavaScript props
+  var playUrl: String? = null
+  var surfaceWidth: Int? = null
+  var surfaceHeight: Int? = null
+  var audioIndex: Int? = null
+  var subtitleIndex: Int? = null
+  var useHardwareDecoder: Boolean? = null
+
+  init {
+    surfaceView.holder.addCallback(this)
+    val layoutParams = FrameLayout.LayoutParams(
+        FrameLayout.LayoutParams.MATCH_PARENT,
+        FrameLayout.LayoutParams.MATCH_PARENT
+    )
+    addView(surfaceView, layoutParams)
+  }
+
+  fun cleanup() {
+    surfaceView.holder.removeCallback(this)
+    mpv.cleanup()
+  }
+
+  fun isSurfaceReady(): Boolean = isSurfaceCreated
+
+  fun attemptCreation(){
+        val allPropsReady = playUrl != null &&
+                            surfaceWidth != null &&
+                            surfaceHeight != null &&
+                            audioIndex != null &&
+                            subtitleIndex != null &&
+                            useHardwareDecoder != null
+
+        if (allPropsReady) {
+            log("LibmpvVideoView.attemptCreation", "Initializing MPV instance")
+            createNativePlayer()
+        } else {
+          log("LibmpvVideoView.attemptCreation", "attemptCreation wasn't ready")
+        }
+  }
+
+  fun createNativePlayer() {
+    mpv.create()
+    prepareMpvSettings()
+    log("LibmpvVideoView.createNativePlayer", "mpv settings prepared. Waiting on surface creation.")
+  }
+
+  fun runCommand(orders: String){
+    mpv.command(orders.split("|").toTypedArray())
+  }
+
+  fun setOptionString(options: String){
+    val parts = options.split("|").toTypedArray()
+    mpv.setOptionString(parts[0],parts[1])
+  }
+
+  private fun prepareMpvSettings() {
+    mpv.addLogObserver(this)
+    mpv.addEventObserver(this)
+    mpv.setOptionString("force-window", "no")
+
+    mpv.setOptionString("config", "yes")
+    val mpvDir = mpv.getMpvDirectoryPath()
+    mpvDir?.let{
+      mpv.setOptionString("config-dir", mpvDir)
+      mpv.setOptionString("sub-font-dir", mpvDir)
+    }
+
+    mpv.setOptionString("keep-open", "always")
+    mpv.setOptionString("save-position-on-quit", "no")
+    mpv.setOptionString("ytdl", "no")
+    mpv.setOptionString("msg-level", "all=no")
+
+    mpv.setOptionString("profile", "fast")
+    mpv.setOptionString("vo", "gpu-next")
+
+    if (useHardwareDecoder == true) {
+      mpv.setOptionString("hwdec", HARDWARE_OPTIONS)
+      mpv.setOptionString("hwdec-codecs", ACCELERATED_CODECS)
+    } else {
+      mpv.setOptionString("hwdec", "no")
+    }
+
+    mpv.setOptionString("gpu-context", "android")
+    mpv.setOptionString("opengl-es", "yes")
+    mpv.setOptionString("video-sync", "audio")
+
+    mpv.setOptionString("ao", "audiotrack")
+    mpv.setOptionString("alang", "")
+
+    mpv.setOptionString("sub-font-provider", "none")
+    mpv.setOptionString("slang", "")
+    mpv.setOptionString("sub-scale-with-window", "yes")
+    mpv.setOptionString("sub-use-margins", "no")
+
+    mpv.setOptionString("cache", "yes")
+    mpv.setOptionString("cache-pause-initial", "yes")
+    mpv.setOptionString("cache-secs", "5")
+    mpv.setOptionString("demuxer-readahead-secs", "5")
+  }
+
+  fun log(method: String, argument: String) {
+    onLibmpvLog(mapOf(
+      "method" to method,
+      "argument" to argument
+    ))
+  }
+
+  override fun surfaceCreated(holder: SurfaceHolder) {
+    val width = surfaceWidth ?: 0
+    val height = surfaceHeight ?: 0
+    // In the new Fabric version, this is stretching the content
+    //holder.setFixedSize(width, height)
+    //mpv.setPropertyString("android-surface-size", "${width}x${height}")
+    mpv.attachSurface(surfaceView)
+    prepareMpvPlayback()
+    isSurfaceCreated = true
+    log("LibmpvVideoView.surfaceCreated", "Surface created and MPV should be playing")
+  }
+
+  private fun prepareMpvPlayback() {
+    mpv.init()
+    mpv.setOptionString("force-window", "yes")
+    var options = "vid=1"
+    options += if (audioIndex == -1) {
+      ",aid=no"
+    } else {
+      ",aid=${(audioIndex ?: 0) + 1}"
+    }
+    options += if (subtitleIndex == -1) {
+      ",sid=no"
+    } else {
+      ",sid=${(subtitleIndex ?: 0) + 1}"
+    }
+    val url: String = (playUrl as? String) ?: ""
+    mpv.play(url, options)
+  }
+
+  fun setHardwareDecoder(useHardware: Boolean) {
+    useHardwareDecoder = useHardware
+    if (useHardwareDecoder == true) {
+      mpv.setOptionString("hwdec", HARDWARE_OPTIONS)
+      mpv.setOptionString("hwdec-codecs", ACCELERATED_CODECS)
+    } else {
+      mpv.setOptionString("hwdec", "no")
+    }
+  }
+
+  override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {}
+
+  override fun surfaceDestroyed(holder: SurfaceHolder) {
+    mpv.setPropertyString("vo", "null")
+    mpv.setPropertyString("force-window", "no")
+    mpv.detachSurface()
+  }
+
+  // MPVLib.LogObserver
+  override fun logMessage(prefix: String, level: Int, text: String) {
+    onLibmpvLog(mapOf(
+      "prefix" to prefix,
+      "level" to "$level",
+      "text" to text
+    ))
+  }
+
+  // MPVLib.EventObserver
+  override fun eventProperty(property: String) {
+    onLibmpvEvent(mapOf(
+      "property" to property,
+      "kind" to "none"
+    ))
+  }
+
+  override fun eventProperty(property: String, value: Long) {
+    onLibmpvEvent(mapOf(
+      "property" to property,
+      "kind" to "long",
+      "value" to "$value"
+    ))
+  }
+
+  override fun eventProperty(property: String, value: Double) {
+    onLibmpvEvent(mapOf(
+      "property" to property,
+      "kind" to "double",
+      "value" to "$value"
+    ))
+  }
+
+  override fun eventProperty(property: String, value: Boolean) {
+    onLibmpvEvent(mapOf(
+      "property" to property,
+      "kind" to "boolean",
+      "value" to if (value) "true" else "false"
+    ))
+  }
+
+  override fun eventProperty(property: String, value: String) {
+    onLibmpvEvent(mapOf(
+      "property" to property,
+      "kind" to "string",
+      "value" to value
+    ))
+  }
+
+  override fun event(eventId: Int) {
+    onLibmpvEvent(mapOf(
+      "eventId" to "$eventId",
+      "kind" to "eventId"
+    ))
+  }
+}