refactor(player): improve EmptyValueTimedVisibility and ValueChangeTimedVisibility components

app/src/main/java/hu/bbara/purefin/ui/screen/player/PlayerScreen.kt

@@ -192,30 +192,30 @@ fun PlayerScreen(
 
         EmptyValueTimedVisibility(
             value = horizontalSeekFeedback,
-            hideAfterMillis = 1_000
+            hideAfterMillis = 1_000,
+            modifier = Modifier
+                .align(Alignment.Center)
         ) {
             SeekAmountIndicator(
                 deltaMs = it,
-                modifier = Modifier
-                    .align(Alignment.Center)
             )
         }
 
         EmptyValueTimedVisibility(
             value = horizontalSeekPreviewPositionMs,
-            hideAfterMillis = 1_000
+            hideAfterMillis = 1_000,
+            modifier = Modifier
+                .align(Alignment.BottomCenter)
+                .padding(horizontal = 24.dp, vertical = 28.dp)
         ) { previewPositionMs ->
-            if (controlsVisible) {
+            if (!controlsVisible) {
                 HiddenSeekTimeline(
                     positionMs = previewPositionMs,
                     durationMs = uiState.durationMs,
                     bufferedMs = uiState.bufferedMs,
                     chapterMarkers = uiState.chapters,
                     adMarkers = uiState.ads,
-                    isLive = uiState.isLive,
+                    isLive = uiState.isLive
-                    modifier = Modifier
-                        .align(Alignment.BottomCenter)
-                        .padding(horizontal = 24.dp, vertical = 28.dp)
                 )
             }
         }

core-ui/src/main/java/hu/bbara/purefin/ui/common/visual/TimedVisibility.kt

@@ -8,29 +8,37 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
 
 @Composable
 fun <T> EmptyValueTimedVisibility(
     value: T?,
     hideAfterMillis: Long = 1_000,
+    enterTransition: EnterTransition = EnterTransition.None,
+    exitTransition: ExitTransition = ExitTransition.None,
     modifier: Modifier = Modifier,
     content: @Composable (T) -> Unit
 ) {
-    val shownValue = remember { mutableStateOf<T?>(null) }
+    var displayedValue by remember { mutableStateOf(value) }
-
     LaunchedEffect(value) {
-        if (value == null) {
+        if (value != null) {
-            delay(hideAfterMillis)
+            displayedValue = value
-            shownValue.value = null
         }
-        shownValue.value = value
     }
-
+    if (displayedValue != null) {
-    shownValue.value?.let {
+        ValueChangeTimedVisibility(
-        content(it)
+            value = displayedValue!!,
+            hideAfterMillis = hideAfterMillis,
+            enterTransition = enterTransition,
+            exitTransition = exitTransition,
+            modifier = modifier,
+            content = content
+        )
     }
 }
 
@@ -38,30 +46,40 @@ fun <T> EmptyValueTimedVisibility(
 fun <T> ValueChangeTimedVisibility(
     value: T,
     hideAfterMillis: Long = 1_000,
+    enterTransition: EnterTransition = EnterTransition.None,
+    exitTransition: ExitTransition = ExitTransition.None,
     modifier: Modifier = Modifier,
     content: @Composable (T) -> Unit
 ) {
     var displayedValue by remember { mutableStateOf(value) }
-    var isVisible by remember { mutableStateOf(false) }
     var hasInitialValue by remember { mutableStateOf(false) }
+    var isVisible by remember { mutableStateOf(false) }
+
+    val coroutineScope = rememberCoroutineScope()
+    var hideJob: Job? by remember { mutableStateOf(null) }
+    fun restartHideJob() {
+        hideJob?.cancel()
+        hideJob = coroutineScope.launch {
+            delay(hideAfterMillis)
+            isVisible = false
+        }
+    }
 
     LaunchedEffect(value) {
-        displayedValue = value
         if (!hasInitialValue) {
             hasInitialValue = true
             return@LaunchedEffect
         }
-
+        displayedValue = value
         isVisible = true
-        delay(hideAfterMillis)
+        restartHideJob()
-        isVisible = false
     }
 
     AnimatedVisibility(
         visible = isVisible,
         modifier = modifier,
-        enter = EnterTransition.None,
+        enter = enterTransition,
-        exit = ExitTransition.None
+        exit = exitTransition
     ) {
         content(displayedValue)
     }