feat: updating theme (#2956)

Author: Nagarjuna0033

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

@@ -9,28 +9,25 @@
  */
 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.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.toArgb
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.repeatOnLifecycle
-import kotlinx.coroutines.channels.awaitClose
+import cmp.android.app.util.isSystemInDarkModeFlow
 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
+import org.mifos.mobile.core.model.MifosThemeConfig
 
 @ColorInt
-private val SCRIM_COLOR: Int = Color.TRANSPARENT
+private val SCRIM_COLOR: Int = Color.Transparent.toArgb()
 
 /**
  * Helper method to handle edge-to-edge logic for dark mode.
@@ -40,15 +37,26 @@ private val SCRIM_COLOR: Int = Color.TRANSPARENT
  */
 @Suppress("MaxLineLength")
 fun ComponentActivity.setupEdgeToEdge(
-    appThemeFlow: Flow<DarkThemeConfig>,
+    appThemeFlow: Flow<MifosThemeConfig>,
 ) {
     lifecycleScope.launch {
         lifecycle.repeatOnLifecycle(state = Lifecycle.State.STARTED) {
             combine(
                 isSystemInDarkModeFlow(),
                 appThemeFlow,
             ) { isSystemDarkMode, appTheme ->
-                AppCompatDelegate.setDefaultNightMode(appTheme.osValue)
+
+                val currentNightMode = AppCompatDelegate.getDefaultNightMode()
+                if (currentNightMode != appTheme.osValue) {
+                    AppCompatDelegate.setDefaultNightMode(appTheme.osValue)
+                }
+
+                when (appTheme.osValue) {
+                    AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM -> isSystemDarkMode
+                    AppCompatDelegate.MODE_NIGHT_YES -> true
+                    AppCompatDelegate.MODE_NIGHT_NO -> false
+                    else -> isSystemDarkMode
+                }
             }
                 .distinctUntilChanged()
                 .collect { isDarkMode ->
@@ -58,28 +66,10 @@ fun ComponentActivity.setupEdgeToEdge(
                     val style = SystemBarStyle.auto(
                         darkScrim = SCRIM_COLOR,
                         lightScrim = SCRIM_COLOR,
-                        // Disabling Dark Mode for this app
-                        detectDarkMode = { false },
+                        detectDarkMode = { isDarkMode },
                     )
                     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

@@ -19,6 +19,8 @@ import androidx.core.view.WindowCompat
 import cmp.shared.SharedApp
 import io.github.vinceglb.filekit.FileKit
 import io.github.vinceglb.filekit.dialogs.init
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
 import org.koin.android.ext.android.inject
 import org.mifos.mobile.core.datastore.UserPreferencesRepository
 import org.mifos.mobile.core.ui.utils.ShareUtils
@@ -42,6 +44,11 @@ class MainActivity : ComponentActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        runBlocking {
+            val userThemeConfig = userPreferencesRepository.observeDarkThemeConfig.first()
+            AppCompatDelegate.setDefaultNightMode(userThemeConfig.osValue)
+        }
+
         var shouldShowSplashScreen = true
         installSplashScreen().setKeepOnScreenCondition { shouldShowSplashScreen }
 

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

@@ -0,0 +1,42 @@
+/*
+ * 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.util
+
+import android.content.res.Configuration
+import androidx.activity.ComponentActivity
+import androidx.core.util.Consumer
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.conflate
+import kotlinx.coroutines.flow.distinctUntilChanged
+
+/**
+ * Convenience wrapper for dark mode checking
+ */
+val Configuration.isSystemInDarkTheme
+    get() = (uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES
+
+/**
+ * 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.
+ */
+fun ComponentActivity.isSystemInDarkModeFlow(): Flow<Boolean> =
+    callbackFlow {
+        channel.trySend(element = resources.configuration.isSystemInDarkTheme)
+        val listener = Consumer<Configuration> {
+            channel.trySend(element = it.isSystemInDarkTheme)
+        }
+        addOnConfigurationChangedListener(listener = listener)
+        awaitClose { removeOnConfigurationChangedListener(listener = listener) }
+    }
+        .distinctUntilChanged()
+        .conflate()