refactor: inject Exopalyer with hilt on viewModel

Author: git-jr

app/src/main/java/com/paradoxo/materialgram/data/VideoLocalDataSource.kt

@@ -10,7 +10,7 @@ class VideoLocalDataSource {
             "https://raw.githubusercontent.com/git-jr/sample-files/main/images/android%20invaders.png"
         ),
         Video(
-            "https://www.learningcontainer.com/wp-content/uploads/2020/05/sample-mp4-file.mp4",
+            "https://github.com/K6pkus/sample-api/raw/main/lv_0_20230929192816.mp4",
             "Video 1",
             "https://raw.githubusercontent.com/git-jr/sample-files/main/images/torta.png"
         ),

app/src/main/java/com/paradoxo/materialgram/di/VideoModule.kt

@@ -1,5 +1,8 @@
 package com.paradoxo.materialgram.di
 
+import android.app.Application
+import androidx.media3.common.Player
+import androidx.media3.exoplayer.ExoPlayer
 import com.paradoxo.materialgram.data.VideoLocalDataSource
 import com.paradoxo.materialgram.data.VideoRepository
 import com.paradoxo.materialgram.data.VideoRepositoryImpl
@@ -32,4 +35,14 @@ object VideoModule {
     fun provideVideoDataSource(): VideoLocalDataSource {
         return VideoLocalDataSource()
     }
+
+
+    @Provides
+    fun provideExpoVideoPlayer(application: Application): Player {
+        return ExoPlayer.Builder(application)
+            .build().apply {
+                playWhenReady = true
+                repeatMode = Player.REPEAT_MODE_ALL
+            }
+    }
 }

app/src/main/java/com/paradoxo/materialgram/presentation/screens/reels/ReelsScreen.kt

@@ -1,7 +1,12 @@
 package com.paradoxo.materialgram.presentation.screens.reels
 
+import android.view.ViewGroup
 import android.view.ViewGroup.LayoutParams.MATCH_PARENT
 import android.widget.FrameLayout
+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.ExperimentalFoundationApi
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Box
@@ -12,6 +17,7 @@ import androidx.compose.foundation.pager.VerticalPager
 import androidx.compose.foundation.pager.rememberPagerState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -28,27 +34,45 @@ import androidx.lifecycle.viewmodel.compose.viewModel
 import androidx.media3.common.C
 import androidx.media3.common.MediaItem
 import androidx.media3.common.Player.REPEAT_MODE_ALL
+import androidx.media3.common.util.UnstableApi
 import androidx.media3.exoplayer.ExoPlayer
 import androidx.media3.ui.AspectRatioFrameLayout
 import androidx.media3.ui.PlayerView
 import com.paradoxo.materialgram.domain.model.Video
 
-
+@UnstableApi
 @OptIn(ExperimentalFoundationApi::class)
 @Composable
 fun ReelsScreen() {
     val viewModel = viewModel<ReelsViewModel>()
     val state by viewModel.uiState.collectAsState()
 
-    val pagerState = rememberPagerState(pageCount = {
-        state.videos.size
-    })
+    Box(
+        modifier = Modifier
+            .fillMaxSize()
+    ) {
+        VideoPlayer(viewModel)
+
+        LoadOverlay(state)
 
-    VerticalPager(state = pagerState) {
-        Column {
-            ItemReels(
-                video = state.videos[pagerState.currentPage]
-            )
+        Column(Modifier.fillMaxSize()) {
+            val pagerState = rememberPagerState(pageCount = {
+                state.videos.size
+            })
+
+            LaunchedEffect(pagerState.getOffsetFractionForPage(0)) {
+                val pageIsTotalVisible = pagerState.currentPageOffsetFraction == 0.0f
+                if (pageIsTotalVisible) {
+                    viewModel.playVideo(state.videos[pagerState.currentPage].url)
+                    viewModel.showLoadAnimation()
+                }
+            }
+
+            VerticalPager(
+                state = pagerState,
+            ) {
+                VideoHud()
+            }
         }
     }
 }
@@ -123,3 +147,69 @@ private fun ItemReels(video: Video) {
         }
     }
 }
+
+@UnstableApi
+@Composable
+private fun VideoPlayer(viewModel: ReelsViewModel) {
+    var lifecycle by remember {
+        mutableStateOf(Lifecycle.Event.ON_CREATE)
+    }
+    val lifecycleOwner = LocalLifecycleOwner.current
+    DisposableEffect(lifecycleOwner) {
+        val observer = LifecycleEventObserver { _, event ->
+            lifecycle = event
+        }
+        lifecycleOwner.lifecycle.addObserver(observer)
+
+        onDispose {
+            lifecycleOwner.lifecycle.removeObserver(observer)
+        }
+    }
+
+    Column(Modifier.fillMaxSize()) {
+        AndroidView(
+            factory = { context ->
+                PlayerView(context).apply {
+                    player = viewModel.player
+                    useController = false
+                    resizeMode = AspectRatioFrameLayout.RESIZE_MODE_FILL
+                    layoutParams = FrameLayout.LayoutParams(
+                        ViewGroup.LayoutParams.MATCH_PARENT,
+                        ViewGroup.LayoutParams.MATCH_PARENT
+                    )
+                }
+            },
+            update = {
+                when (lifecycle) {
+                    Lifecycle.Event.ON_PAUSE -> {
+                        it.onPause()
+                        it.player?.pause()
+                    }
+
+                    Lifecycle.Event.ON_RESUME -> {
+                        it.onResume()
+                        it.player?.play()
+                    }
+
+                    else -> Unit
+                }
+            }
+        )
+
+    }
+}
+
+@Composable
+private fun LoadOverlay(state: ReelsUiState) {
+    AnimatedVisibility(
+        visible = state.showLoadAnimation,
+        enter = fadeIn(tween(state.loadAnimationTime / 3)),
+        exit = fadeOut(tween(state.loadAnimationTime)),
+    ) {
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .background(Color.Black)
+        )
+    }
+}

app/src/main/java/com/paradoxo/materialgram/presentation/screens/reels/ReelsUiState.kt

@@ -0,0 +1,9 @@
+package com.paradoxo.materialgram.presentation.screens.reels
+
+import com.paradoxo.materialgram.domain.model.Video
+
+data class ReelsUiState(
+    val videos: List<Video>,
+    val showLoadAnimation: Boolean = false,
+    val loadAnimationTime: Int = 800
+)

app/src/main/java/com/paradoxo/materialgram/presentation/screens/reels/VideoHud.kt renamed to app/src/main/java/com/paradoxo/materialgram/presentation/screens/reels/ReelsVideoHud.kt

@@ -2,39 +2,73 @@ package com.paradoxo.materialgram.presentation.screens.reels
 
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
 import com.paradoxo.materialgram.domain.VideoUseCase
 import com.paradoxo.materialgram.domain.model.Video
 import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 @HiltViewModel
 class ReelsViewModel @Inject constructor(
-    private val videoUseCase: VideoUseCase
+    private val videoUseCase: VideoUseCase,
+    val player: Player
 ) : ViewModel() {
 
     private val _uiState = MutableStateFlow(ReelsUiState(emptyList()))
     val uiState = _uiState.asStateFlow()
 
     init {
+        player.prepare()
+
         viewModelScope.launch {
             loadVideos()
         }
     }
 
-
     private suspend fun loadVideos() {
         videoUseCase.getVideos().collect { videos ->
             _uiState.value = _uiState.value.copy(
                 videos = videos
             )
         }
     }
-}
 
+    fun playVideo(path: String) {
+        val mediaItem = MediaItem.Builder()
+            .setUri(path)
+            .build()
+        player.setMediaItem(mediaItem)
+    }
+
+
+    private fun resetLoadAnimation() {
+        _uiState.value = _uiState.value.copy(
+            showLoadAnimation = !_uiState.value.showLoadAnimation
+        )
+    }
+
+    fun showLoadAnimation() {
+        _uiState.value = _uiState.value.copy(
+            showLoadAnimation = true
+        )
+
+        viewModelScope.launch {
+            with(_uiState.value) {
+                if (showLoadAnimation) {
+                    delay(loadAnimationTime.toLong())
+                    resetLoadAnimation()
+                }
+            }
+        }
+    }
 
-data class ReelsUiState(
-    val videos: List<Video>
-)
+    override fun onCleared() {
+        super.onCleared()
+        player.release()
+    }
+}