Merge pull request #15 from Javernaut/refactoring/theme-management

Theme management refactoring

Author: Javernaut

app/build.gradle.kts

@@ -135,11 +135,11 @@ dependencies {
     implementation(libs.bundles.androidx.compose)
 
     implementation(libs.bundles.androidx.lifecycle)
-    implementation(libs.androidx.appcompat)
     implementation(libs.androidx.palette)
     implementation(libs.androidx.savedstate)
     implementation(libs.androidx.browser)
     implementation(libs.androidx.window)
+    implementation(libs.androidx.datastore.preferences)
     implementation(libs.androidx.navigation.compose)
 
     implementation(libs.mediafile)

app/src/main/java/com/javernaut/whatthecodec/App.kt

@@ -1,15 +1,7 @@
 package com.javernaut.whatthecodec
 
 import android.app.Application
-import com.javernaut.whatthecodec.settings.ThemeManager
 import dagger.hilt.android.HiltAndroidApp
 
 @HiltAndroidApp
-class App : Application() {
-
-    override fun onCreate() {
-        super.onCreate()
-        ThemeManager.initNightModePreference(this)
-    }
-
-}
+class App : Application()

app/src/main/java/com/javernaut/whatthecodec/compose/common/Common.kt

@@ -1,8 +1,16 @@
 package com.javernaut.whatthecodec.compose.common
 
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
 import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 
 @Composable
 fun OrientationLayout(
@@ -18,3 +26,32 @@ fun OrientationLayout(
         }
     }
 }
+
+@Composable
+fun SystemBroadcastReceiver(
+    systemAction: String,
+    onSystemEvent: (intent: Intent?) -> Unit
+) {
+    // Grab the current context in this part of the UI tree
+    val context = LocalContext.current
+
+    // Safely use the latest onSystemEvent lambda passed to the function
+    val currentOnSystemEvent by rememberUpdatedState(onSystemEvent)
+
+    // If either context or systemAction changes, unregister and register again
+    DisposableEffect(context, systemAction) {
+        val intentFilter = IntentFilter(systemAction)
+        val broadcast = object : BroadcastReceiver() {
+            override fun onReceive(context: Context?, intent: Intent?) {
+                currentOnSystemEvent(intent)
+            }
+        }
+
+        context.registerReceiver(broadcast, intentFilter)
+
+        // When the effect leaves the Composition, remove the callback
+        onDispose {
+            context.unregisterReceiver(broadcast)
+        }
+    }
+}

app/src/main/java/com/javernaut/whatthecodec/compose/playground/ComposePlaygroundActivity.kt

@@ -1,9 +1,9 @@
 package com.javernaut.whatthecodec.compose.playground
 
 import android.os.Bundle
+import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
-import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
@@ -24,18 +24,20 @@ import androidx.lifecycle.viewmodel.compose.viewModel
 import com.javernaut.whatthecodec.R
 import com.javernaut.whatthecodec.compose.theme.WhatTheCodecTheme
 import com.javernaut.whatthecodec.home.ui.screen.ObserveAsEvents
+import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.receiveAsFlow
 import kotlinx.coroutines.launch
 
-class ComposePlaygroundActivity : AppCompatActivity() {
+@AndroidEntryPoint
+class ComposePlaygroundActivity : ComponentActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         enableEdgeToEdge()
         super.onCreate(savedInstanceState)
 
         setContent {
-            WhatTheCodecTheme {
+            WhatTheCodecTheme.Dynamic {
                 PlaygroundScreen()
             }
         }

app/src/main/java/com/javernaut/whatthecodec/compose/preference/ListPreference.kt

@@ -23,8 +23,10 @@ import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -36,24 +38,15 @@ import com.javernaut.whatthecodec.compose.common.WtcDialog
 
 @Composable
 fun ListPreference(
-    key: String,
-    defaultValue: String,
     title: String,
     displayableEntries: List<String>,
-    entriesCodes: List<String>,
-    onNewCodeSelected: (String) -> Unit
+    selectedItemIndex: Int,
+    onNewCodeSelected: (Int) -> Unit
 ) {
-    val applicationContext = LocalContext.current.applicationContext
-    val defaultSharedPreferences =
-        PreferenceManager.getDefaultSharedPreferences(applicationContext)
-    val selectedItemCode = defaultSharedPreferences.getString(key, defaultValue)
-
-    val currentlySelectedItemIndex = entriesCodes.indexOf(selectedItemCode)
-
-    var dialogOpened by remember { mutableStateOf(false) }
+    var dialogOpened by rememberSaveable { mutableStateOf(false) }
     Preference(
         title = title,
-        summary = displayableEntries[currentlySelectedItemIndex]
+        summary = displayableEntries[selectedItemIndex]
     ) {
         dialogOpened = true
     }
@@ -63,14 +56,9 @@ fun ListPreference(
             title = title,
             dismissRequest = { dialogOpened = false },
             items = displayableEntries,
-            currentlySelectedIndex = currentlySelectedItemIndex
+            currentlySelectedIndex = selectedItemIndex
         ) {
-            val newValueToSet = entriesCodes[it]
-            defaultSharedPreferences
-                .edit()
-                .putString(key, newValueToSet)
-                .apply()
-            onNewCodeSelected(newValueToSet)
+            onNewCodeSelected(it)
         }
     }
 }
@@ -83,7 +71,7 @@ fun SingleChoicePreferenceDialog(
     currentlySelectedIndex: Int,
     clickListener: (Int) -> Unit
 ) {
-    var selectedIndex by remember { mutableStateOf(currentlySelectedIndex) }
+    var selectedIndex by rememberSaveable { mutableIntStateOf(currentlySelectedIndex) }
     PreferenceDialog(title, dismissRequest,
         applyRequest = {
             clickListener(selectedIndex)
@@ -123,7 +111,7 @@ fun MultiSelectListPreference(
         selectedItemCodes.contains(entriesCodes[it])
     }
 
-    var dialogOpened by remember { mutableStateOf(false) }
+    var dialogOpened by rememberSaveable { mutableStateOf(false) }
     Preference(
         title = title,
         summary = summaryBuilder(displayableEntries.filterIndexed { index, s ->

app/src/main/java/com/javernaut/whatthecodec/compose/preference/Preference.kt

@@ -100,7 +100,7 @@ private fun PreferenceTitle(@StringRes title: Int) {
 @Preview
 @Composable
 private fun PreferencePreview() {
-    WhatTheCodecTheme {
+    WhatTheCodecTheme.Static {
         PreferenceGroup {
             Preference(
                 title = "Title",
@@ -114,7 +114,7 @@ private fun PreferencePreview() {
 @PreviewLightDark
 @Composable
 private fun PreviewPreferenceGroup() {
-    WhatTheCodecTheme {
+    WhatTheCodecTheme.Static {
         Column {
             PreferenceGroup(R.string.settings_title) {
                 Preference(title = "Title", summary = "Summary") {

app/src/main/java/com/javernaut/whatthecodec/compose/theme/Theme.kt

@@ -0,0 +1,84 @@
+package com.javernaut.whatthecodec.compose.theme
+
+import android.app.Activity
+import android.os.Build
+import android.os.PowerManager
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalView
+import androidx.core.content.getSystemService
+import androidx.core.view.WindowCompat
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.javernaut.whatthecodec.compose.common.SystemBroadcastReceiver
+import com.javernaut.whatthecodec.compose.theme.dynamic.AppTheme
+import com.javernaut.whatthecodec.compose.theme.dynamic.ThemeViewModel
+
+object WhatTheCodecTheme {
+    @Composable
+    fun Static(
+        darkTheme: Boolean = isSystemInDarkTheme(),
+        content: @Composable () -> Unit
+    ) {
+        val colorScheme = if (darkTheme) darkScheme else lightScheme
+        MaterialTheme(
+            colorScheme = colorScheme,
+            content = content
+        )
+    }
+
+    @Composable
+    fun Dynamic(
+        themeViewModel: ThemeViewModel = viewModel(),
+        content: @Composable () -> Unit
+    ) {
+        val appTheme by themeViewModel.appTheme.collectAsState()
+        val darkTheme = when (appTheme) {
+            AppTheme.Light -> false
+            AppTheme.Dark -> true
+            AppTheme.Auto ->
+                // isSystemInDarkTheme() on Android S+ considers the Battery Saver mode
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) isSystemInDarkTheme()
+                else isPowerSaveMode()
+        }
+
+        val view = LocalView.current
+        if (!view.isInEditMode) {
+            SideEffect {
+                val window = (view.context as Activity).window
+                WindowCompat.getInsetsController(window, view).apply {
+                    isAppearanceLightStatusBars = !darkTheme
+                    isAppearanceLightNavigationBars = !darkTheme
+                }
+            }
+        }
+
+        Static(
+            darkTheme = darkTheme,
+            content = content
+        )
+    }
+}
+
+@Composable
+private fun isPowerSaveMode(): Boolean {
+    val powerManager = LocalContext.current.getSystemService<PowerManager>()!!
+    var result by remember {
+        mutableStateOf(
+            powerManager.isPowerSaveMode
+        )
+    }
+
+    SystemBroadcastReceiver(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED) {
+        result = powerManager.isPowerSaveMode
+    }
+
+    return result
+}

app/src/main/java/com/javernaut/whatthecodec/compose/theme/WhatTheCodecTheme.kt

@@ -0,0 +1,7 @@
+package com.javernaut.whatthecodec.compose.theme.dynamic
+
+enum class AppTheme {
+    Light,
+    Dark,
+    Auto
+}

app/src/main/java/com/javernaut/whatthecodec/compose/theme/dynamic/AppTheme.kt

@@ -0,0 +1,36 @@
+package com.javernaut.whatthecodec.compose.theme.dynamic
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.intPreferencesKey
+import androidx.datastore.preferences.preferencesDataStore
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class AppThemeRepository @Inject constructor(
+    @ApplicationContext context: Context
+) {
+    private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "theme_settings")
+    private val keyTheme = intPreferencesKey("selected_theme")
+
+    private val dataStore = context.dataStore
+
+    val selectedTheme: Flow<AppTheme> = context.dataStore.data
+        .map { preferences ->
+            preferences[keyTheme] ?: AppTheme.Auto.ordinal
+        }.map {
+            AppTheme.entries[it]
+        }
+
+    suspend fun setSelectedTheme(newAppTheme: AppTheme) {
+        dataStore.edit { settings ->
+            settings[keyTheme] = newAppTheme.ordinal
+        }
+    }
+}

app/src/main/java/com/javernaut/whatthecodec/compose/theme/dynamic/AppThemeRepository.kt

@@ -0,0 +1,25 @@
+package com.javernaut.whatthecodec.compose.theme.dynamic
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+@HiltViewModel
+class ThemeViewModel @Inject constructor(
+    private val appThemeRepository: AppThemeRepository
+) : ViewModel() {
+
+    val appTheme = appThemeRepository.selectedTheme.stateIn(
+        viewModelScope, SharingStarted.Eagerly, AppTheme.Auto
+    )
+
+    fun setAppTheme(newAppTheme: AppTheme) {
+        viewModelScope.launch {
+            appThemeRepository.setSelectedTheme(newAppTheme)
+        }
+    }
+}