lifecycle preimplementation

app/src/main/kotlin/org/mjdev/tvapp/base/helpers/LifeCycle.kt

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) Milan Jurkulák 2023.
+ *  Contact:
+ *  e: mimoccc@gmail.com
+ *  e: mj@mjdev.org
+ *  w: https://mjdev.org
+ */
+
+@file:Suppress("unused")
+
+package org.mjdev.tvapp.base.helpers
+
+import android.annotation.SuppressLint
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.ui.platform.LocalLifecycleOwner
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.LifecycleOwner
+
+@SuppressLint("ComposableNaming")
+@Composable
+fun rememberLifeCycleHandler(
+    lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current,
+    onEvent: (Lifecycle.Event) -> Unit
+) {
+    val lifecycleEvent = remember {
+        mutableStateOf(Lifecycle.Event.ON_ANY)
+    }
+    DisposableEffect(lifecycleOwner) {
+        val lifecycleObserver = LifecycleEventObserver { _, event ->
+            lifecycleEvent.value = event
+        }
+        lifecycleOwner.lifecycle.addObserver(lifecycleObserver)
+        onDispose {
+            lifecycleOwner.lifecycle.removeObserver(lifecycleObserver)
+        }
+    }
+    LaunchedEffect(lifecycleEvent) {
+        onEvent(lifecycleEvent.value)
+    }
+}
+
+@Composable
+fun DisposableEffectWithLifecycle(
+    lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current,
+    onCreate: () -> Unit = {},
+    onStart: () -> Unit = {},
+    onStop: () -> Unit = {},
+    onResume: () -> Unit = {},
+    onPause: () -> Unit = {},
+    onDestroy: () -> Unit = {},
+) {
+    val currentOnCreate by rememberUpdatedState(onCreate)
+    val currentOnStart by rememberUpdatedState(onStart)
+    val currentOnStop by rememberUpdatedState(onStop)
+    val currentOnResume by rememberUpdatedState(onResume)
+    val currentOnPause by rememberUpdatedState(onPause)
+    val currentOnDestroy by rememberUpdatedState(onDestroy)
+    DisposableEffect(lifecycleOwner) {
+        val lifecycleEventObserver = LifecycleEventObserver { _, event ->
+            when (event) {
+                Lifecycle.Event.ON_CREATE -> currentOnCreate()
+                Lifecycle.Event.ON_START -> currentOnStart()
+                Lifecycle.Event.ON_PAUSE -> currentOnPause()
+                Lifecycle.Event.ON_RESUME -> currentOnResume()
+                Lifecycle.Event.ON_STOP -> currentOnStop()
+                Lifecycle.Event.ON_DESTROY -> currentOnDestroy()
+                else -> {}
+            }
+        }
+        lifecycleOwner.lifecycle.addObserver(lifecycleEventObserver)
+        onDispose {
+            lifecycleOwner.lifecycle.removeObserver(lifecycleEventObserver)
+        }
+    }
+}