Merge pull request #1209 from DimensionDev/feature/native_media_viewer

switch to native media viewer

Author: Tlaster

compose-ui/build.gradle.kts

@@ -87,7 +87,6 @@ kotlin {
                 implementation(project.dependencies.platform(libs.koin.bom))
                 implementation(libs.fluent.ui)
                 implementation(libs.koin.compose)
-                implementation(libs.composemediaplayer)
                 implementation(libs.androidx.collection)
             }
         }

compose-ui/src/jvmMain/kotlin/dev/dimension/flare/ui/component/platform/PlatformVideoPlayer.jvm.kt

@@ -1,34 +1,10 @@
 package dev.dimension.flare.ui.component.platform
 
-import androidx.collection.lruCache
 import androidx.compose.foundation.ExperimentalFoundationApi
-import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.BoxScope
-import androidx.compose.foundation.layout.aspectRatio
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.wrapContentSize
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableLongStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clipToBounds
-import androidx.compose.ui.geometry.Size
 import androidx.compose.ui.layout.ContentScale
-import androidx.compose.ui.layout.layout
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.unit.Density
-import androidx.compose.ui.unit.Dp
-import io.github.kdroidfilter.composemediaplayer.VideoPlayerState
-import io.github.kdroidfilter.composemediaplayer.VideoPlayerSurface
-import kotlinx.coroutines.delay
-import kotlin.concurrent.timer
-import kotlin.math.roundToInt
-import kotlin.time.Duration.Companion.minutes
 
 @OptIn(ExperimentalFoundationApi::class)
 @Composable
@@ -49,187 +25,4 @@ internal actual fun PlatformVideoPlayer(
     errorContent: @Composable BoxScope.() -> Unit,
     loadingPlaceholder: @Composable BoxScope.() -> Unit,
 ) {
-    val playerPool: VideoPlayerPool = org.koin.compose.koinInject()
-    val player =
-        remember(uri) {
-            playerPool
-                .get(uri)
-                .apply {
-                    if (autoPlay) {
-                        play()
-                    }
-//                    volume = if (muted) 0f else 1f
-                }
-        }
-    DisposableEffect(uri) {
-        onDispose {
-            playerPool.release(uri)
-        }
-    }
-    var remainingTime by remember { mutableLongStateOf(0L) }
-    val density = LocalDensity.current
-    val size =
-        remember(player.metadata) {
-            val height = player.metadata.height
-            val width = player.metadata.width
-            if (height != null && width != null) {
-                with(density) {
-                    Size(
-                        width = width.toFloat(),
-                        height = height.toFloat(),
-                    )
-                }
-            } else {
-                null
-            }
-        }
-    LaunchedEffect(player.isPlaying) {
-        if (player.isPlaying) {
-            player.volume = 0f
-        }
-    }
-    LaunchedEffect(player) {
-        while (true) {
-            val duration = player.metadata.duration
-            if (remainingTimeContent != null && duration != null) {
-                val position = player.sliderPos / 1000f
-                remainingTime = (duration * 1000 * (1f - position)).toLong()
-            }
-            delay(500)
-        }
-    }
-
-    Box(modifier) {
-        VideoPlayerSurface(
-            playerState = player,
-            modifier =
-                Modifier
-                    .clipToBounds()
-                    .resizeWithContentScale(
-                        contentScale = contentScale,
-                        sourceSizeDp = size,
-                    ).let {
-                        if (aspectRatio != null) {
-                            it.aspectRatio(
-                                aspectRatio,
-                            )
-                        } else {
-                            it
-                        }
-                    }.let {
-                        if (onClick != null) {
-                            it.combinedClickable(
-                                onClick = onClick,
-                                onLongClick = onLongClick,
-                            )
-                        } else {
-                            it
-                        }
-                    }.matchParentSize(),
-        )
-        if (player.error != null) {
-            errorContent.invoke(this)
-        } else if (player.isLoading) {
-            loadingPlaceholder()
-        } else {
-            remainingTimeContent?.invoke(this, remainingTime)
-        }
-    }
-}
-
-@Composable
-private fun Modifier.resizeWithContentScale(
-    contentScale: ContentScale,
-    sourceSizeDp: Size?,
-    density: Density = LocalDensity.current,
-): Modifier =
-    then(
-        Modifier
-            .fillMaxSize()
-            .wrapContentSize()
-            .then(
-                sourceSizeDp?.let { srcSizeDp ->
-                    Modifier.layout { measurable, constraints ->
-                        val srcSizePx =
-                            with(density) { Size(Dp(srcSizeDp.width).toPx(), Dp(srcSizeDp.height).toPx()) }
-                        val dstSizePx = Size(constraints.maxWidth.toFloat(), constraints.maxHeight.toFloat())
-                        val scaleFactor = contentScale.computeScaleFactor(srcSizePx, dstSizePx)
-                        val placeable =
-                            measurable.measure(
-                                constraints.copy(
-                                    maxWidth =
-                                        (srcSizePx.width * scaleFactor.scaleX)
-                                            .takeIf { !it.isNaN() }
-                                            ?.roundToInt()
-                                            ?: constraints.maxWidth,
-                                    maxHeight =
-                                        (srcSizePx.height * scaleFactor.scaleY)
-                                            .takeIf { !it.isNaN() }
-                                            ?.roundToInt()
-                                            // or keep 16:9
-                                            ?: (constraints.maxWidth * 9 / 16),
-                                ),
-                            )
-                        layout(placeable.width, placeable.height) { placeable.place(0, 0) }
-                    }
-                } ?: Modifier,
-            ),
-    )
-
-public class VideoPlayerPool {
-    private val positionPool = mutableMapOf<String, Float>()
-    private val lockCount = linkedMapOf<String, Long>()
-    private val pool =
-        lruCache<String, VideoPlayerState>(
-            maxSize = 10,
-            create = { uri ->
-                VideoPlayerState()
-                    .apply {
-                        loop = true
-                        openUri(uri)
-                    }
-            },
-            onEntryRemoved = { evicted, key, oldValue, newValue ->
-                if (evicted) {
-                    positionPool.put(key, oldValue.sliderPos)
-                    oldValue.dispose()
-                } else if (newValue != null) {
-                    val position = positionPool.get(key)
-                    if (position != null) {
-                        newValue.seekTo(position)
-                        positionPool.remove(key)
-                    }
-                }
-            },
-        )
-
-    private val clearTimer =
-        timer(period = 1.minutes.inWholeMilliseconds) {
-            pool.snapshot().forEach { (uri, _) ->
-                if (lockCount.getOrElse(uri) { 0 } == 0L) {
-                    pool.remove(uri)?.dispose()
-                }
-            }
-        }
-
-    public fun peek(uri: String): VideoPlayerState? = pool.get(uri)
-
-    public fun get(uri: String): VideoPlayerState {
-        lock(uri)
-        return pool.get(uri)!!
-    }
-
-    public fun lock(uri: String) {
-        lockCount.put(uri, lockCount.getOrElse(uri) { 0 } + 1)
-    }
-
-    public fun release(uri: String): Boolean {
-        lockCount.put(uri, lockCount.getOrElse(uri) { 0 } - 1)
-        val count = lockCount.getOrElse(uri) { 0 }
-        if (count == 0L) {
-            pool.get(uri)?.pause()
-        }
-
-        return count == 0L
-    }
 }

desktopApp/build-swift.gradle.kts

@@ -1,14 +1,15 @@
 import java.nio.file.Files
 
-val swiftSource = layout.projectDirectory.dir("src/main/swift/macosBridge.xcodeproj").asFile
+val swiftSource = layout.projectDirectory.dir("src/main/swift/macosBridge").asFile
+val xcodeproj = layout.projectDirectory.dir("src/main/swift/macosBridge.xcodeproj").asFile
 val buildOutput = layout.projectDirectory.file("src/main/swift/build/Release/libmacosBridge.dylib")
 val targetLib = layout.projectDirectory.dir("resources/macos-arm64").file("libmacosBridge.dylib").asFile
 val isMac = org.gradle.internal.os.OperatingSystem.current().isMacOsX
 
-tasks.register<Exec>("compileWebviewBridgeArm64") {
+tasks.register<Exec>("compileMacosBridgeArm64") {
     onlyIf { isMac }
 
-//    inputs.file(swiftSource)
+    inputs.files(swiftSource)
     outputs.file(targetLib)
 
     doFirst {
@@ -17,9 +18,10 @@ tasks.register<Exec>("compileWebviewBridgeArm64") {
 
     commandLine(
         "xcodebuild",
-        "-project", swiftSource.absolutePath,
-        "-target", "macosBridge",
+        "-project", xcodeproj.absolutePath,
+        "-scheme", "macosBridge",
         "-configuration", "Release",
+        "BUILD_DIR=${xcodeproj.parentFile}/build",
     )
 
     doLast {
@@ -33,9 +35,9 @@ tasks.register<Exec>("compileWebviewBridgeArm64") {
 
 afterEvaluate {
     tasks.named("compileKotlin").configure {
-        dependsOn("compileWebviewBridgeArm64")
+        dependsOn("compileMacosBridgeArm64")
     }
     tasks.named("prepareAppResources").configure {
-        dependsOn("compileWebviewBridgeArm64")
+        dependsOn("compileMacosBridgeArm64")
     }
 }

desktopApp/build.gradle.kts

@@ -1,5 +1,6 @@
-import java.util.Properties
+
 import org.jetbrains.compose.desktop.application.dsl.TargetFormat
+import java.util.Properties
 
 plugins {
     alias(libs.plugins.kotlin.jvm)
@@ -54,7 +55,7 @@ compose.desktop {
                 val hasSigningProps = file.exists()
                 packageBuildVersion = System.getenv("BUILD_NUMBER") ?: "21"
                 bundleID = "dev.dimension.flare"
-                minimumSystemVersion = "12.0"
+                minimumSystemVersion = "14.0"
                 appStore = hasSigningProps
 
                 jvmArgs(
@@ -135,9 +136,9 @@ val macExtraPlistKeys: String
 
 extra["sqliteVersion"] = libs.versions.sqlite.get()
 extra["sqliteOsArch"] = "osx_arm64"
-extra["composeMediaPlayerVersion"] = libs.versions.composemediaplayer.get()
 extra["jnaVersion"] = libs.versions.jna.get()
 extra["nativeDestDir"] = "resources/macos-arm64"
 
 apply(from = File(projectDir, "install-native-libs.gradle.kts"))
 apply(from = File(projectDir, "build-swift.gradle.kts"))
+

desktopApp/install-native-libs.gradle.kts

@@ -135,43 +135,6 @@ val sqliteTask =
         entryPathInJar = sqliteEntry,
         destFile = nativeDestDir.resolve(sqliteFileName),
     )
-
-val cmpVersion = (findProperty("composeMediaPlayerVersion") as String?) ?: "0.8.1"
-val cmpJarName = "composemediaplayer-jvm-$cmpVersion.jar"
-val cmpJarUrl =
-    "https://repo1.maven.org/maven2/io/github/kdroidfilter/composemediaplayer-jvm/$cmpVersion/$cmpJarName"
-
-val cmpDirName =
-    when {
-        currentOs.isMacOsX && isArm -> "darwin-aarch64"
-        currentOs.isMacOsX && isX64 -> "darwin-x86-64"
-        currentOs.isLinux && isArm -> "linux-aarch64"
-        currentOs.isLinux && isX64 -> "linux-x86-64"
-        currentOs.isWindows && isX64 -> "win32-x86-64"
-        currentOs.isWindows && isArm -> "win32-arm64"
-        else -> throw GradleException("Unsupported OS or architecture: ${currentOs.name} $currentArch")
-    }
-
-val cmpLibName =
-    when {
-        currentOs.isMacOsX -> "libNativeVideoPlayer.dylib"
-        currentOs.isLinux -> "libNativeVideoPlayer.so"
-        currentOs.isWindows -> "NativeVideoPlayer.dll"
-        else -> throw GradleException("Unsupported OS: ${currentOs.name}")
-    }
-
-val cmpEntry = "$cmpDirName/$cmpLibName"
-
-val cmpTask =
-    registerExtractFromJarTask(
-        taskName = "installNativeVideoPlayer_$cmpVersion",
-        jarUrl = cmpJarUrl,
-        cacheSubDir = "composeMediaPlayer/$cmpVersion",
-        jarFileName = cmpJarName,
-        entryPathInJar = cmpEntry,
-        destFile = nativeDestDir.resolve(cmpLibName),
-    )
-
 val jnaVersion = (findProperty("jnaVersion") as String?) ?: "5.17.0"
 val jnaJarName = "jna-$jnaVersion.jar"
 val jnaJarUrl = "https://repo1.maven.org/maven2/net/java/dev/jna/jna/$jnaVersion/$jnaJarName"
@@ -211,9 +174,9 @@ val jnaTask =
 
 afterEvaluate {
     tasks.named("compileKotlin").configure {
-        dependsOn(sqliteTask, cmpTask, jnaTask)
+        dependsOn(sqliteTask, jnaTask)
     }
     tasks.named("prepareAppResources").configure {
-        dependsOn(sqliteTask, cmpTask, jnaTask)
+        dependsOn(sqliteTask, jnaTask)
     }
 }

desktopApp/src/main/kotlin/dev/dimension/flare/Main.kt

@@ -16,6 +16,7 @@ import coil3.ImageLoader
 import coil3.compose.setSingletonImageLoaderFactory
 import coil3.request.crossfade
 import dev.dimension.flare.common.DeeplinkHandler
+import dev.dimension.flare.common.NativeWindowBridge
 import dev.dimension.flare.common.SandboxHelper
 import dev.dimension.flare.di.KoinHelper
 import dev.dimension.flare.di.composeUiModule
@@ -28,6 +29,7 @@ import dev.dimension.flare.ui.theme.ProvideThemeSettings
 import org.apache.commons.lang3.SystemUtils
 import org.jetbrains.compose.resources.painterResource
 import org.jetbrains.compose.resources.stringResource
+import org.koin.compose.koinInject
 import org.koin.core.context.startKoin
 import java.awt.Desktop
 
@@ -49,12 +51,17 @@ fun main(args: Array<String>) {
                 .build()
         }
         val extraWindowRoutes = remember { mutableStateMapOf<String, FloatingWindowState>() }
+        val nativeWindowBridge = koinInject<NativeWindowBridge>()
 
         fun openWindow(
             key: String,
             route: Route.WindowRoute,
         ) {
-            if (extraWindowRoutes.containsKey(key)) {
+            if (route is Route.RawImage) {
+                nativeWindowBridge.openImageImageViewer(route.rawImage)
+            } else if (route is Route.StatusMedia) {
+                nativeWindowBridge.openStatusImageViewer(route)
+            } else if (extraWindowRoutes.containsKey(key)) {
                 extraWindowRoutes[key]?.bringToFront?.invoke()
             } else {
                 extraWindowRoutes.put(