refactor video playback components and unify under InlineVideoPlayer

- introduce `InlineVideoPlayer` as a shared component for efficient inline video and GIF playback
- refactor `VideoNoteBubble` to use `InlineVideoPlayer`, replacing manual `ExoPlayer` management and reducing boilerplate logic
- simplify `AvatarPlayer` by delegating playback and thumbnail loading to `InlineVideoPlayer`
- extend `VideoStickerPlayer` and `AlphaVideoPlayer` with additional callbacks for `onFirstFrameRendered` and `onPlaybackError`
- improve state handling in `VideoNoteBubble` by using a `canRenderInlineVideo` check to toggle between player and thumbnail states
- ensure consistent video scaling and progress reporting across chat bubble and avatar components

Author: gdlbo

presentation/src/main/java/org/monogram/presentation/features/chats/currentChat/components/AlphaVideoPlayer.kt

@@ -110,6 +110,8 @@ fun VideoStickerPlayer(
     onProgressUpdate: (Long) -> Unit = {},
     onDurationKnown: (Long) -> Unit = {},
     onPlaybackEnded: () -> Unit = {},
+    onFirstFrameRendered: () -> Unit = {},
+    onPlaybackError: (PlaybackException) -> Unit = {},
     reportProgress: Boolean = false,
     fileId: Int = 0,
     thumbnailData: Any? = null
@@ -262,6 +264,7 @@ fun VideoStickerPlayer(
                         override fun onRenderedFirstFrame() {
                             if (!isDisposed.get()) {
                                 isVideoFrameReady = true
+                                onFirstFrameRendered()
                                 if (isGif) {
                                     Log.d(
                                         GIF_PLAYER_TAG,
@@ -275,6 +278,7 @@ fun VideoStickerPlayer(
                             if (error.cause is FileNotFoundException) {
                                 isVideoFrameReady = false
                             }
+                            onPlaybackError(error)
                             if (isGif) {
                                 Log.e(
                                     GIF_PLAYER_TAG,

presentation/src/main/java/org/monogram/presentation/features/chats/currentChat/components/AvatarPlayer.kt

@@ -1,122 +1,19 @@
 package org.monogram.presentation.features.chats.currentChat.components
 
-import android.net.Uri
-import android.view.ViewGroup
-import android.widget.FrameLayout
-import androidx.annotation.OptIn
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.core.tween
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.runtime.*
+import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.layout.ContentScale
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalInspectionMode
-import androidx.compose.ui.viewinterop.AndroidView
-import androidx.core.net.toUri
-import androidx.media3.common.MediaItem
-import androidx.media3.common.PlaybackException
-import androidx.media3.common.Player
-import androidx.media3.common.util.UnstableApi
-import androidx.media3.ui.AspectRatioFrameLayout
-import androidx.media3.ui.PlayerView
-import coil3.compose.AsyncImage
-import coil3.request.ImageRequest
-import coil3.request.crossfade
-import coil3.video.VideoFrameDecoder
-import coil3.video.videoFrameMillis
-import org.monogram.presentation.core.util.LocalVideoPlayerPool
-import java.io.File
 
-@OptIn(UnstableApi::class)
 @Composable
 fun AvatarPlayer(
     path: String,
     modifier: Modifier = Modifier,
     contentScale: ContentScale = ContentScale.Crop
 ) {
-    if (LocalInspectionMode.current) {
-        Box(modifier = modifier)
-        return
-    }
-    val videoPlayerPool = LocalVideoPlayerPool.current
-
-    val context = LocalContext.current
-    var isVideoFrameReady by remember { mutableStateOf(false) }
-
-    val exoPlayer = remember(path) {
-        videoPlayerPool.acquire().apply {
-            val uri = if (path.startsWith("http") || path.startsWith("content") || path.startsWith("file")) {
-                path.toUri()
-            } else {
-                Uri.fromFile(File(path))
-            }
-            val mediaSource = videoPlayerPool.getMediaSourceFactory()
-                .createMediaSource(MediaItem.fromUri(uri))
-            setMediaSource(mediaSource)
-            prepare()
-            repeatMode = Player.REPEAT_MODE_ONE
-            playWhenReady = true
-            volume = 0f
-        }
-    }
-
-    DisposableEffect(exoPlayer) {
-        val listener = object : Player.Listener {
-            override fun onRenderedFirstFrame() {
-                isVideoFrameReady = true
-            }
-
-            override fun onPlayerError(error: PlaybackException) {
-                isVideoFrameReady = false
-            }
-        }
-        exoPlayer.addListener(listener)
-        onDispose {
-            exoPlayer.removeListener(listener)
-            exoPlayer.setVideoSurface(null)
-            videoPlayerPool.release(exoPlayer)
-        }
-    }
-
-    Box(modifier = modifier) {
-        AndroidView(
-            factory = { ctx ->
-                PlayerView(ctx).apply {
-                    player = exoPlayer
-                    useController = false
-                    resizeMode = AspectRatioFrameLayout.RESIZE_MODE_ZOOM
-                    layoutParams = FrameLayout.LayoutParams(
-                        ViewGroup.LayoutParams.MATCH_PARENT,
-                        ViewGroup.LayoutParams.MATCH_PARENT
-                    )
-                }
-            },
-            modifier = Modifier.fillMaxSize()
-        )
-
-        AnimatedVisibility(
-            visible = !isVideoFrameReady,
-            enter = fadeIn(tween(100)),
-            exit = fadeOut(tween(250)),
-            modifier = Modifier.fillMaxSize()
-        ) {
-            AsyncImage(
-                model = ImageRequest.Builder(context)
-                    .data(path)
-                    .decoderFactory(VideoFrameDecoder.Factory())
-                    .videoFrameMillis(0)
-                    .memoryCacheKey(path)
-                    .diskCacheKey(path)
-                    .crossfade(true)
-                    .build(),
-                contentDescription = null,
-                contentScale = contentScale,
-                modifier = Modifier.fillMaxSize()
-            )
-        }
-    }
-}
+    InlineVideoPlayer(
+        path = path,
+        modifier = modifier,
+        contentScale = contentScale,
+        placeholderData = path
+    )
+}

presentation/src/main/java/org/monogram/presentation/features/chats/currentChat/components/InlineVideoPlayer.kt

@@ -0,0 +1,41 @@
+package org.monogram.presentation.features.chats.currentChat.components
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.layout.ContentScale
+import androidx.media3.common.PlaybackException
+
+@Composable
+fun InlineVideoPlayer(
+    path: String,
+    modifier: Modifier = Modifier,
+    contentScale: ContentScale = ContentScale.Crop,
+    animate: Boolean = true,
+    volume: Float = 0f,
+    placeholderData: Any? = null,
+    fileId: Int = 0,
+    reportProgress: Boolean = false,
+    onProgressUpdate: (Long) -> Unit = {},
+    onDurationKnown: (Long) -> Unit = {},
+    onPlaybackEnded: () -> Unit = {},
+    onFirstFrameRendered: () -> Unit = {},
+    onPlaybackError: (PlaybackException) -> Unit = {}
+) {
+    VideoStickerPlayer(
+        path = path,
+        type = VideoType.Gif,
+        modifier = modifier,
+        animate = animate,
+        shouldLoop = true,
+        volume = volume,
+        contentScale = contentScale,
+        onProgressUpdate = onProgressUpdate,
+        onDurationKnown = onDurationKnown,
+        onPlaybackEnded = onPlaybackEnded,
+        onFirstFrameRendered = onFirstFrameRendered,
+        onPlaybackError = onPlaybackError,
+        reportProgress = reportProgress,
+        fileId = fileId,
+        thumbnailData = placeholderData
+    )
+}