Refactor: Extract MoviesApplication composable

This commit extracts the main navigation logic from `MainActivity` into a new `MoviesApplication` composable.

Key changes:
-   A new `MoviesApplication.kt` file is created to house the `NavDisplay` and its configuration.
-   `MainActivity` is simplified to just call `MoviesApplication`.
-   The `observeIn` extension function is removed in favor of `flowWithLifecycle`.
-   Modules (`TheMovieDbModule`, `MovieDetailsModule`) now own the `actions` `Channel`, removing redundant `remember` calls in the UI.
-   Dependencies like `AppModule` and `BackStack` are now passed explicitly to screen composables (`MoviesNavScreen`, `MovieDetailsNavScreen`).
-   Introduced a `BackStack` typealias for `SnapshotStateList<Screen>`.

Author: LordRaydenMK

app/src/main/java/io/github/lordraydenmk/themoviedbapp/MainActivity.kt

@@ -4,47 +4,14 @@ import android.os.Bundle
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.appcompat.app.AppCompatActivity
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.runtime.mutableStateListOf
-import androidx.compose.runtime.remember
-import androidx.lifecycle.viewmodel.navigation3.rememberViewModelStoreNavEntryDecorator
-import androidx.navigation3.runtime.NavEntry
-import androidx.navigation3.runtime.rememberSaveableStateHolderNavEntryDecorator
-import androidx.navigation3.ui.NavDisplay
-import io.github.lordraydenmk.themoviedbapp.movies.Screen
-import io.github.lordraydenmk.themoviedbapp.movies.Screen.MovieDetails
-import io.github.lordraydenmk.themoviedbapp.movies.Screen.PopularMovies
-import io.github.lordraydenmk.themoviedbapp.movies.moviedetails.MovieDetailsNavScreen
-import io.github.lordraydenmk.themoviedbapp.movies.popularmovies.MoviesNavScreen
 
-@OptIn(ExperimentalMaterial3Api::class)
 class MainActivity : AppCompatActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         enableEdgeToEdge()
         super.onCreate(savedInstanceState)
         setContent {
-            val backStack = remember { mutableStateListOf<Screen>(PopularMovies) }
-
-            NavDisplay(
-                entryDecorators = listOf(
-                    rememberSaveableStateHolderNavEntryDecorator(),
-                    rememberViewModelStoreNavEntryDecorator()
-                ),
-                backStack = backStack,
-                onBack = { backStack.removeLastOrNull() },
-                entryProvider = { key: Screen ->
-                    when (key) {
-                        PopularMovies -> NavEntry(key) {
-                            MoviesNavScreen(backStack)
-                        }
-
-                        is MovieDetails -> NavEntry(key) {
-                            MovieDetailsNavScreen(key.movieId, backStack)
-                        }
-                    }
-                }
-            )
+            MoviesApplication(appModule())
         }
     }
 }

app/src/main/java/io/github/lordraydenmk/themoviedbapp/MoviesApp.kt

@@ -0,0 +1,42 @@
+package io.github.lordraydenmk.themoviedbapp
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.snapshots.SnapshotStateList
+import androidx.lifecycle.viewmodel.navigation3.rememberViewModelStoreNavEntryDecorator
+import androidx.navigation3.runtime.NavEntry
+import androidx.navigation3.runtime.rememberSaveableStateHolderNavEntryDecorator
+import androidx.navigation3.ui.NavDisplay
+import io.github.lordraydenmk.themoviedbapp.movies.Screen
+import io.github.lordraydenmk.themoviedbapp.movies.Screen.MovieDetails
+import io.github.lordraydenmk.themoviedbapp.movies.Screen.PopularMovies
+import io.github.lordraydenmk.themoviedbapp.movies.moviedetails.MovieDetailsNavScreen
+import io.github.lordraydenmk.themoviedbapp.movies.popularmovies.MoviesNavScreen
+
+typealias BackStack = SnapshotStateList<Screen>
+
+@Composable
+fun MoviesApplication(appModule: AppModule) {
+    val backStack = remember { mutableStateListOf<Screen>(PopularMovies) }
+
+    NavDisplay(
+        entryDecorators = listOf(
+            rememberSaveableStateHolderNavEntryDecorator(),
+            rememberViewModelStoreNavEntryDecorator()
+        ),
+        backStack = backStack,
+        onBack = { backStack.removeLastOrNull() },
+        entryProvider = { key: Screen ->
+            when (key) {
+                PopularMovies -> NavEntry(key) {
+                    MoviesNavScreen(appModule, backStack)
+                }
+
+                is MovieDetails -> NavEntry(key) {
+                    MovieDetailsNavScreen(appModule, key.movieId, backStack)
+                }
+            }
+        }
+    )
+}

app/src/main/java/io/github/lordraydenmk/themoviedbapp/common/flow.kt

@@ -1,9 +1,5 @@
 package io.github.lordraydenmk.themoviedbapp.common
 
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.LifecycleOwner
-import androidx.lifecycle.lifecycleScope
-import androidx.lifecycle.repeatOnLifecycle
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -21,7 +17,6 @@ import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
-import kotlinx.coroutines.launch
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 
@@ -65,13 +60,3 @@ suspend inline fun <A, B, C> parZip(
     @Suppress("UNCHECKED_CAST")
     f(a as A, b as B)
 }
-
-fun <A> Flow<A>.observeIn(
-    lifecycleOwner: LifecycleOwner,
-    state: Lifecycle.State = Lifecycle.State.STARTED
-): Job =
-    lifecycleOwner.lifecycleScope.launch {
-        lifecycleOwner.lifecycle.repeatOnLifecycle(state) {
-            collect()
-        }
-    }

app/src/main/java/io/github/lordraydenmk/themoviedbapp/movies/moviedetails/MovieDetailsNavScreen.kt

@@ -5,34 +5,36 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.snapshots.SnapshotStateList
-import androidx.compose.ui.platform.LocalContext
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.compose.LocalLifecycleOwner
+import androidx.lifecycle.flowWithLifecycle
 import androidx.lifecycle.repeatOnLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
 import io.github.lordraydenmk.themoviedbapp.AppModule
-import io.github.lordraydenmk.themoviedbapp.appModule
-import io.github.lordraydenmk.themoviedbapp.common.observeIn
+import io.github.lordraydenmk.themoviedbapp.BackStack
 import io.github.lordraydenmk.themoviedbapp.common.presentation.ViewModelAlgebra
-import io.github.lordraydenmk.themoviedbapp.movies.Screen
 import io.github.lordraydenmk.themoviedbapp.movies.domain.MovieId
 import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.receiveAsFlow
 
 @Composable
 fun MovieDetailsNavScreen(
+    appModule: AppModule,
     movieId: MovieId,
-    backStack: SnapshotStateList<Screen>,
+    backStack: BackStack,
     viewModel: MovieDetailsViewModel = viewModel()
 ) {
-    val module = object : MovieDetailsModule,
-        AppModule by LocalContext.current.appModule(),
-        ViewModelAlgebra<MovieDetailsViewState, MovieDetailsEffect> by viewModel {}
+    val module = remember {
+        object : MovieDetailsModule,
+            AppModule by appModule,
+            ViewModelAlgebra<MovieDetailsViewState, MovieDetailsEffect> by viewModel {
+            override val actions: Channel<MovieDetailsAction> = Channel(Channel.UNLIMITED)
+        }
+    }
 
 
-    val actions = remember { Channel<MovieDetailsAction>(Channel.UNLIMITED) }
     with(module) {
         val lifecycleOwner = LocalLifecycleOwner.current
         LaunchedEffect(lifecycleOwner) {
@@ -41,13 +43,15 @@ fun MovieDetailsNavScreen(
             }
         }
         LaunchedEffect(lifecycleOwner) {
-            viewModel.effects.map { effect ->
-                when (effect) {
-                    is NavigateUp -> backStack.removeLastOrNull()
-                }
-            }.observeIn(lifecycleOwner)
+            viewModel.effects
+                .flowWithLifecycle(lifecycleOwner.lifecycle)
+                .map { effect ->
+                    when (effect) {
+                        is NavigateUp -> backStack.removeLastOrNull()
+                    }
+                }.collect()
         }
     }
     val state by viewModel.viewState.collectAsState(Loading)
-    MovieDetailsScreen(state, movieId, actions)
+    MovieDetailsScreen(state, movieId, module.actions)
 }

app/src/main/java/io/github/lordraydenmk/themoviedbapp/movies/moviedetails/movieDetails.kt

@@ -14,11 +14,14 @@ import io.github.lordraydenmk.themoviedbapp.movies.data.movieDetails
 import io.github.lordraydenmk.themoviedbapp.movies.domain.Movie
 import io.github.lordraydenmk.themoviedbapp.movies.domain.MovieId
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 
 interface MovieDetailsModule : AppModule,
-    ViewModelAlgebra<MovieDetailsViewState, MovieDetailsEffect>
+    ViewModelAlgebra<MovieDetailsViewState, MovieDetailsEffect> {
+    val actions: Channel<MovieDetailsAction>
+}
 
 suspend fun MovieDetailsModule.program(
     movieId: MovieId,

app/src/main/java/io/github/lordraydenmk/themoviedbapp/movies/popularmovies/MoviesNavScreen.kt

@@ -6,15 +6,13 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.snapshots.SnapshotStateList
-import androidx.compose.ui.platform.LocalContext
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.compose.LocalLifecycleOwner
 import androidx.lifecycle.flowWithLifecycle
 import androidx.lifecycle.repeatOnLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
 import io.github.lordraydenmk.themoviedbapp.AppModule
-import io.github.lordraydenmk.themoviedbapp.appModule
+import io.github.lordraydenmk.themoviedbapp.BackStack
 import io.github.lordraydenmk.themoviedbapp.common.presentation.ViewModelAlgebra
 import io.github.lordraydenmk.themoviedbapp.movies.Screen
 import kotlinx.coroutines.channels.Channel
@@ -25,14 +23,17 @@ import kotlinx.coroutines.flow.receiveAsFlow
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun MoviesNavScreen(
-    backStack: SnapshotStateList<Screen>,
+    appModule: AppModule,
+    backStack: BackStack,
     viewModel: MoviesViewModel = viewModel()
 ) {
-    val module = object : TheMovieDbModule,
-        AppModule by LocalContext.current.appModule(),
-        ViewModelAlgebra<PopularMoviesViewState, MoviesEffect> by viewModel {}
-
-    val actions = remember { Channel<MoviesAction>(Channel.UNLIMITED) }
+    val module = remember {
+        object : TheMovieDbModule,
+            AppModule by appModule,
+            ViewModelAlgebra<PopularMoviesViewState, MoviesEffect> by viewModel {
+            override val actions: Channel<MoviesAction> = Channel(Channel.UNLIMITED)
+        }
+    }
 
     with(module) {
         val lifecycleOwner = LocalLifecycleOwner.current
@@ -43,7 +44,7 @@ fun MoviesNavScreen(
         }
         LaunchedEffect(lifecycleOwner) {
             viewModel.effects
-                .flowWithLifecycle(lifecycleOwner.lifecycle, Lifecycle.State.STARTED)
+                .flowWithLifecycle(lifecycleOwner.lifecycle)
                 .map { effect ->
                     when (effect) {
                         is NavigateToDetails -> backStack.add(Screen.MovieDetails(effect.movieId))
@@ -53,5 +54,5 @@ fun MoviesNavScreen(
     }
 
     val state by viewModel.viewState.collectAsState(Loading)
-    PopularMoviesScreen(state = state, actions)
+    PopularMoviesScreen(state = state, module.actions)
 }

app/src/main/java/io/github/lordraydenmk/themoviedbapp/movies/popularmovies/moviesList.kt

@@ -11,10 +11,13 @@ import io.github.lordraydenmk.themoviedbapp.movies.NetworkError
 import io.github.lordraydenmk.themoviedbapp.movies.ServerError
 import io.github.lordraydenmk.themoviedbapp.movies.data.popularMovies
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 
-interface TheMovieDbModule : AppModule, ViewModelAlgebra<PopularMoviesViewState, MoviesEffect>
+interface TheMovieDbModule : AppModule, ViewModelAlgebra<PopularMoviesViewState, MoviesEffect> {
+    val actions: Channel<MoviesAction>
+}
 
 suspend fun TheMovieDbModule.program(actions: Flow<MoviesAction>): Unit =
     parZip(Dispatchers.Default, { firstLoad() }, { handleActions(actions) })