refactor: enhance navigation and screens (#2858)

Author: Nagarjuna0033

cmp-android/src/main/kotlin/cmp/android/app/ComponentActivityExtensions.kt

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2025 Mifos Initiative
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * See https://github.com/openMF/mobile-mobile/blob/master/LICENSE.md
+ */
+package cmp.android.app
+
+import android.content.res.Configuration
+import android.graphics.Color
+import androidx.activity.ComponentActivity
+import androidx.activity.SystemBarStyle
+import androidx.activity.enableEdgeToEdge
+import androidx.annotation.ColorInt
+import androidx.appcompat.app.AppCompatDelegate
+import androidx.core.util.Consumer
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.conflate
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.launch
+import org.mifos.mobile.core.model.DarkThemeConfig
+
+@ColorInt
+private val SCRIM_COLOR: Int = Color.TRANSPARENT
+
+/**
+ * Helper method to handle edge-to-edge logic for dark mode.
+ *
+ * This logic is from the Now-In-Android app found
+ * [here](https://github.com/android/nowinandroid/blob/689ef92e41427ab70f82e2c9fe59755441deae92/app/src/main/kotlin/com/google/samples/apps/nowinandroid/MainActivity.kt#L94).
+ */
+@Suppress("MaxLineLength")
+fun ComponentActivity.setupEdgeToEdge(
+    appThemeFlow: Flow<DarkThemeConfig>,
+) {
+    lifecycleScope.launch {
+        lifecycle.repeatOnLifecycle(state = Lifecycle.State.STARTED) {
+            combine(
+                isSystemInDarkModeFlow(),
+                appThemeFlow,
+            ) { isSystemDarkMode, appTheme ->
+                AppCompatDelegate.setDefaultNightMode(appTheme.osValue)
+            }
+                .distinctUntilChanged()
+                .collect { isDarkMode ->
+                    // This handles all the settings to go edge-to-edge. We are using a transparent
+                    // scrim for system bars and switching between "light" and "dark" based on the
+                    // system and internal app theme settings.
+                    val style = SystemBarStyle.auto(
+                        darkScrim = SCRIM_COLOR,
+                        lightScrim = SCRIM_COLOR,
+                        // Disabling Dark Mode for this app
+                        detectDarkMode = { false },
+                    )
+                    enableEdgeToEdge(statusBarStyle = style, navigationBarStyle = style)
+                }
+        }
+    }
+}
+
+/**
+ * Adds a configuration change listener to retrieve whether system is in
+ * dark theme or not. This will emit current status immediately and then
+ * will emit changes as needed.
+ */
+private fun ComponentActivity.isSystemInDarkModeFlow(): Flow<Boolean> =
+    callbackFlow {
+        channel.trySend(element = resources.configuration.isSystemInDarkMode)
+        val listener = Consumer<Configuration> {
+            channel.trySend(element = it.isSystemInDarkMode)
+        }
+        addOnConfigurationChangedListener(listener = listener)
+        awaitClose { removeOnConfigurationChangedListener(listener = listener) }
+    }
+        .distinctUntilChanged()
+        .conflate()

cmp-android/src/main/kotlin/cmp/android/app/ConfigurationExtension.kt

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2025 Mifos Initiative
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * See https://github.com/openMF/mobile-mobile/blob/master/LICENSE.md
+ */
+package cmp.android.app
+
+import android.content.res.Configuration
+
+val Configuration.isSystemInDarkMode
+    get() = (uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES

cmp-android/src/main/kotlin/cmp/android/app/MainActivity.kt

@@ -12,13 +12,18 @@ package cmp.android.app
 import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
-import androidx.activity.enableEdgeToEdge
+import androidx.appcompat.app.AppCompatDelegate
+import androidx.core.os.LocaleListCompat
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.core.view.WindowCompat
 import cmp.shared.SharedApp
 import io.github.vinceglb.filekit.FileKit
 import io.github.vinceglb.filekit.dialogs.init
+import org.koin.android.ext.android.inject
+import org.mifos.mobile.core.datastore.UserPreferencesRepository
 import org.mifos.mobile.core.ui.utils.ShareUtils
+import java.util.Locale
+import kotlin.getValue
 
 /**
  * Main activity class.
@@ -32,21 +37,41 @@ class MainActivity : ComponentActivity() {
      * Called when the activity is starting.
      * This is where most initialization should go: calling [setContentView(int)] to inflate the activity's UI,
      */
+
+    private val userPreferencesRepository: UserPreferencesRepository by inject()
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        var shouldShowSplashScreen = true
+        installSplashScreen().setKeepOnScreenCondition { shouldShowSplashScreen }
 
-        installSplashScreen()
+        val darkThemeConfigFlow = userPreferencesRepository.observeDarkThemeConfig
 
         WindowCompat.setDecorFitsSystemWindows(window, false)
-        enableEdgeToEdge()
+        setupEdgeToEdge(darkThemeConfigFlow)
         ShareUtils.setActivityProvider { return@setActivityProvider this }
         FileKit.init(this)
         /**
          * Set the content view of the activity.
          * @see setContent
          */
         setContent {
-            SharedApp()
+            SharedApp(
+                handleThemeMode = {
+                    AppCompatDelegate.setDefaultNightMode(it)
+                },
+                handleAppLocale = {
+                    it?.let {
+                        AppCompatDelegate.setApplicationLocales(
+                            LocaleListCompat.forLanguageTags(it),
+                        )
+                        Locale.setDefault(Locale(it))
+                    }
+                },
+                onSplashScreenRemoved = {
+                    shouldShowSplashScreen = false
+                },
+            )
         }
     }
 }

cmp-desktop/src/jvmMain/kotlin/main.kt

@@ -46,7 +46,11 @@ fun main() {
             title = stringResource(Res.string.application_title),
         ) {
             // Sets the content of the window.
-            SharedApp()
+            SharedApp(
+                handleThemeMode = {},
+                handleAppLocale = {},
+                onSplashScreenRemoved = {},
+            )
         }
     }
 }

cmp-navigation/build.gradle.kts

@@ -40,6 +40,7 @@ kotlin {
             implementation(projects.feature.notification)
             implementation(projects.feature.userProfile)
             implementation(projects.feature.location)
+            implementation(projects.feature.onboardingLanguage)
             // Core Modules
             implementation(projects.core.data)
             implementation(projects.core.common)
@@ -55,6 +56,7 @@ kotlin {
             implementation(libs.koin.compose)
             implementation(libs.koin.compose.viewmodel)
             implementation(libs.kotlinx.serialization.json)
+
         }
         androidMain.dependencies {
             implementation(libs.androidx.core.ktx)

cmp-navigation/src/commonMain/composeResources/values/strings.xml

@@ -9,9 +9,9 @@
     See https://github.com/openMF/mobile-mobile/blob/master/LICENSE.md
 -->
 <resources>
-    <string name="app_name">CMP App</string>
+    <string name="app_name">Mifos Mobile</string>
     <string name="home">Home</string>
+    <string name="transfer">Transfer</string>
     <string name="profile">Profile</string>
-    <string name="settings">Settings</string>
     <string name="not_connected">⚠️ You aren’t connected to the internet</string>
 </resources>

cmp-navigation/src/commonMain/kotlin/cmp/navigation/ComposeApp.kt

@@ -9,65 +9,41 @@
  */
 package cmp.navigation
 
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.Modifier
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.navigation.compose.rememberNavController
-import cmp.navigation.navigation.NavGraphRoute.AUTH_GRAPH
-import cmp.navigation.navigation.NavGraphRoute.PASSCODE_GRAPH
-import cmp.navigation.navigation.RootNavGraph
-import org.koin.compose.koinInject
+import cmp.navigation.rootnav.RootNavScreen
 import org.koin.compose.viewmodel.koinViewModel
-import org.mifos.mobile.core.data.util.NetworkMonitor
-import org.mifos.mobile.core.datastore.model.AppTheme
 import org.mifos.mobile.core.designsystem.theme.MifosMobileTheme
+import org.mifos.mobile.core.ui.utils.EventsEffect
 
 @Composable
 fun ComposeApp(
+    handleThemeMode: (osValue: Int) -> Unit,
+    handleAppLocale: (locale: String?) -> Unit,
+    onSplashScreenRemoved: () -> Unit,
     modifier: Modifier = Modifier,
-    networkMonitor: NetworkMonitor = koinInject(),
     viewModel: ComposeAppViewModel = koinViewModel(),
 ) {
-    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
-    val navController = rememberNavController()
+    val uiState by viewModel.stateFlow.collectAsStateWithLifecycle()
 
-    val navDestination = when (uiState) {
-        is MainUiState.Loading -> AUTH_GRAPH
-        is MainUiState.Success -> if ((uiState as MainUiState.Success).userData.isAuthenticated) {
-            PASSCODE_GRAPH
-        } else {
-            AUTH_GRAPH
+    EventsEffect(eventFlow = viewModel.eventFlow) { event ->
+        when (event) {
+            is AppEvent.ShowToast -> {}
+            is AppEvent.UpdateAppLocale -> handleAppLocale(event.localeName)
+            is AppEvent.UpdateAppTheme -> handleThemeMode(event.osValue)
         }
-
-        else -> AUTH_GRAPH
-    }
-
-    val isDarkMode = when (uiState) {
-        is MainUiState.Success -> when ((uiState as MainUiState.Success).appTheme) {
-            AppTheme.SYSTEM -> isSystemInDarkTheme()
-            AppTheme.LIGHT -> false
-            AppTheme.DARK -> true
-        }
-        else -> true
     }
 
-    MifosMobileTheme(isDarkMode) {
-        RootNavGraph(
-            modifier = modifier.fillMaxSize(),
-            networkMonitor = networkMonitor,
-            navHostController = navController,
-            startDestination = navDestination,
-            onClickLogout = {
-                viewModel.logOut()
-                navController.navigate(AUTH_GRAPH) {
-                    popUpTo(navController.graph.id) {
-                        inclusive = true
-                    }
-                }
-            },
+    MifosMobileTheme(
+        darkTheme = uiState.darkTheme,
+        androidTheme = uiState.isAndroidTheme,
+        shouldDisplayDynamicTheming = uiState.isDynamicColorsEnabled,
+    ) {
+        RootNavScreen(
+            modifier = modifier,
+            onSplashScreenRemoved = onSplashScreenRemoved,
         )
     }
 }