Merge pull request #9 from alsterverse/feature/robustify-player

Robustify player

build.gradle.kts

@@ -1,6 +1,7 @@
 plugins {
     //trick: for the same plugin versions in all sub-modules
-    alias(libs.plugins.androidLibrary).apply(false)
-    alias(libs.plugins.kotlinMultiplatform).apply(false)
-    id("com.vanniktech.maven.publish") version "0.25.3" apply false
+    alias(libs.plugins.androidLibrary) apply false
+    alias(libs.plugins.kotlinMultiplatform) apply false
+    alias(libs.plugins.compose.compiler) apply false
+    alias(libs.plugins.vanniktechPublish) apply false
 }

gradle/libs.versions.toml

@@ -1,11 +1,13 @@
 [versions]
 agp = "8.5.2"
 kotlin = "2.0.20"
+compose-multiplatform = "1.7.0"
 compose = "1.5.4"
 compose-material3 = "1.1.2"
 androidx-activityCompose = "1.8.0"
 media3Exoplayer = "1.4.1"
 kotlinxCoroutinesCore = "1.8.1"
+vanniktechPublish = "0.25.3"
 
 [libraries]
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
@@ -31,3 +33,5 @@ kotlinAndroid = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
 kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
 kotlinCocoapods = { id = "org.jetbrains.kotlin.native.cocoapods", version.ref = "kotlin" }
 compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+composeMultiplatform = { id = "org.jetbrains.compose", version.ref = "compose-multiplatform" }
+vanniktechPublish = { id = "com.vanniktech.maven.publish", version.ref = "vanniktechPublish" }

player/build.gradle.kts

@@ -7,6 +7,9 @@ val githubProperties = Properties().apply {
 plugins {
     alias(libs.plugins.kotlinMultiplatform)
     alias(libs.plugins.androidLibrary)
+    alias(libs.plugins.compose.compiler)
+    alias(libs.plugins.composeMultiplatform)
+
     id("com.vanniktech.maven.publish")
 }
 
@@ -43,9 +46,11 @@ kotlin {
             implementation(libs.androidx.media3.exoplayer)
             implementation(libs.androidx.media3.exoplayer.hls)
             implementation(libs.androidx.media3.exoplayer.dash)
+            implementation(libs.androidx.media3.ui)
         }
         commonMain.dependencies {
             implementation(libs.kotlinx.coroutines.core)
+            implementation(compose.foundation)
         }
         iosMain.dependencies {
         }

player/src/androidMain/kotlin/se/alster/player/PlayerController.android.kt

@@ -0,0 +1,12 @@
+package se.alster.player
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.platform.LocalContext
+
+@Composable
+actual fun rememberPlayerController(): PlayerController {
+    val context = LocalContext.current
+    val playerController = remember { PlayerControllerAndroid(context) }
+    return playerController
+}

player/src/androidMain/kotlin/se/alster/player/ui/VideoView.android.kt

@@ -0,0 +1,50 @@
+package se.alster.player.ui
+
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.annotation.OptIn
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clipToBounds
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.ui.AspectRatioFrameLayout
+import androidx.media3.ui.PlayerView
+import se.alster.player.PlayerProvider
+import se.alster.player.R
+
+@OptIn(UnstableApi::class)
+@Composable
+internal actual fun InternalVideoView(
+    modifier: Modifier,
+    showControls: Boolean,
+    aspectRatio: AspectRatio,
+    playerProvider: PlayerProvider
+) {
+    val player = playerProvider.player
+    val currentView = LocalView.current as ViewGroup
+
+    AndroidView(
+        modifier = modifier.clipToBounds(),
+        factory = { ctx ->
+            (LayoutInflater.from(ctx).inflate(
+                R.layout.video_texture_view,
+                currentView,
+                false
+            ) as PlayerView)
+                .also {
+                    it.resizeMode = aspectRatio.toResizeMode()
+                    it.useController = showControls
+                    it.player = player
+                }
+        },
+    )
+}
+
+@OptIn(UnstableApi::class)
+private fun AspectRatio.toResizeMode(): Int = when (this) {
+    AspectRatio.ScaleToFit -> AspectRatioFrameLayout.RESIZE_MODE_FIT
+    AspectRatio.ScaleToFill -> AspectRatioFrameLayout.RESIZE_MODE_ZOOM
+    AspectRatio.FillStretch -> AspectRatioFrameLayout.RESIZE_MODE_FILL
+}

player/src/androidMain/res/layout/video_texture_view.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.media3.ui.PlayerView xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    app:keep_content_on_player_reset="true"
+    app:resize_mode="zoom"
+    app:surface_type="texture_view"
+    app:use_controller="false" />

player/src/commonMain/kotlin/se/alster/player/PlayerController.kt

@@ -1,8 +1,15 @@
 package se.alster.player
 
+import androidx.compose.runtime.Composable
 import kotlinx.coroutines.flow.Flow
 import kotlin.time.Duration
+import se.alster.player.ui.VideoView
 
+/**
+ * A controller for a video player. The controller is responsible for loading and playing videos.
+ * The controller also provides information about the current state of the video player. The controller
+ * is not responsible for rendering the video player. The rendering is done by the [VideoView].
+ */
 interface PlayerController {
     val playerProvider: PlayerProvider
     val currentProgress: Flow<Duration>
@@ -18,4 +25,7 @@ interface PlayerController {
     fun pause()
     fun scrub(delta: Duration)
     fun seekTo(position: Duration)
-}
+}
+
+@Composable
+expect fun rememberPlayerController(): PlayerController

player/src/commonMain/kotlin/se/alster/player/PlayerProvider.kt

@@ -1,3 +1,6 @@
 package se.alster.player
 
+/**
+ * Provides a player instance.
+ */
 expect interface PlayerProvider

player/src/commonMain/kotlin/se/alster/player/ui/AspectRatio.kt

@@ -0,0 +1,25 @@
+package se.alster.player.ui
+
+/**
+ * The aspect ratio of the video.
+ *
+ * [ScaleToFit] - The video is scaled to fit inside the view. The aspect ratio is preserved.
+ * [ScaleToFill] - The video is scaled to fill the view. The aspect ratio is preserved.
+ * [FillStretch] - The video is stretched to fill the view. The aspect ratio is not preserved.
+ */
+enum class AspectRatio {
+    /**
+     * The video is scaled to fit inside the view. The aspect ratio is preserved.
+     */
+    ScaleToFit,
+
+    /**
+     * The video is scaled to fill the view. The aspect ratio is preserved.
+     */
+    ScaleToFill,
+
+    /**
+     * The video is stretched to fill the view. The aspect ratio is not preserved.
+     */
+    FillStretch,
+}

player/src/commonMain/kotlin/se/alster/player/ui/VideoView.kt

@@ -0,0 +1,41 @@
+package se.alster.player.ui
+
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import se.alster.player.PlayerProvider
+
+/**
+ * A composable that displays a video player. The player is provided by the [playerProvider].
+ * Note: The [VideoView] does not handle the lifecycle of the player. The player should be
+ * released when it is no longer needed.
+ *
+ * Example usage:
+ * ```kotlin
+ * val playerProvider = rememberPlayerProvider()
+ * LaunchedEffect(playerProvider) {
+ *    playerProvider.loadVideo("https://example.com/video.mp4")
+ *    playerProvider.play()
+ * }
+ * VideoView(
+ *    modifier = Modifier.fillMaxSize(),
+ *    playerProvider = playerProvider
+ *    showControls = true
+ * )
+ * ```
+ */
+@Composable
+fun VideoView(
+    modifier: Modifier = Modifier.fillMaxSize(),
+    showControls: Boolean = true,
+    aspectRatio: AspectRatio = AspectRatio.ScaleToFill,
+    playerProvider: PlayerProvider,
+) = InternalVideoView(modifier, showControls, aspectRatio, playerProvider)
+
+@Composable
+internal expect fun InternalVideoView(
+    modifier: Modifier,
+    showControls: Boolean,
+    aspectRatio: AspectRatio,
+    playerProvider: PlayerProvider
+)

player/src/iosMain/kotlin/se/alster/player/PlayerController.ios.kt

@@ -0,0 +1,10 @@
+package se.alster.player
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+
+@Composable
+actual fun rememberPlayerController(): PlayerController {
+    val playerController = remember { PlayerControllerIOS() }
+    return playerController
+}

player/src/iosMain/kotlin/se/alster/player/PlayerProvider.ios.kt

@@ -4,4 +4,4 @@ import platform.AVFoundation.AVPlayer
 
 actual interface PlayerProvider {
     val player: AVPlayer
-}
+}

player/src/iosMain/kotlin/se/alster/player/ui/VideoView.ios.kt

@@ -0,0 +1,40 @@
+package se.alster.player.ui
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.viewinterop.UIKitView
+import platform.AVFoundation.AVLayerVideoGravity
+import platform.AVFoundation.AVLayerVideoGravityResize
+import platform.AVFoundation.AVLayerVideoGravityResizeAspect
+import platform.AVFoundation.AVLayerVideoGravityResizeAspectFill
+import platform.AVKit.AVPlayerViewController
+import se.alster.player.PlayerProvider
+
+@Composable
+internal actual fun InternalVideoView(
+    modifier: Modifier,
+    showControls: Boolean,
+    aspectRatio: AspectRatio,
+    playerProvider: PlayerProvider
+) {
+    val player = playerProvider.player
+
+    val avPlayerViewController = remember { AVPlayerViewController() }
+    UIKitView(
+        factory = {
+            avPlayerViewController.player = player
+            avPlayerViewController.videoGravity = aspectRatio.toVideoGravity()
+            avPlayerViewController.showsPlaybackControls = showControls
+
+            avPlayerViewController.view
+        },
+        modifier = modifier,
+    )
+}
+
+private fun AspectRatio.toVideoGravity(): AVLayerVideoGravity = when (this) {
+    AspectRatio.ScaleToFit -> AVLayerVideoGravityResizeAspect
+    AspectRatio.ScaleToFill -> AVLayerVideoGravityResizeAspectFill
+    AspectRatio.FillStretch -> AVLayerVideoGravityResize
+}