Change CoroutineScope of preferences datastore, instead of redispatching (#325)

* Change CoroutineScope of preferences datastore, instead of redispatching

* Change dispatcher of application scope to default, instead of IO dispatcher

* Fix spotless

Author: fornewid

core/kotlin/src/main/java/soup/movie/common/di/CoroutineScopesModule.kt

@@ -23,7 +23,7 @@ import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
 import soup.movie.common.ApplicationScope
-import soup.movie.common.MainImmediateDispatcher
+import soup.movie.common.DefaultDispatcher
 import javax.inject.Singleton
 
 @Module
@@ -34,6 +34,6 @@ object CoroutineScopesModule {
     @Provides
     @ApplicationScope
     fun providesCoroutineScope(
-        @MainImmediateDispatcher dispatcher: CoroutineDispatcher,
+        @DefaultDispatcher dispatcher: CoroutineDispatcher,
     ): CoroutineScope = CoroutineScope(SupervisorJob() + dispatcher)
 }

data/settings/impl/src/main/java/soup/movie/data/settings/impl/AppSettingsImpl.kt

@@ -15,24 +15,17 @@
  */
 package soup.movie.data.settings.impl
 
-import android.content.Context
 import androidx.datastore.core.DataStore
-import androidx.datastore.preferences.SharedPreferencesMigration
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.intPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
-import androidx.datastore.preferences.preferencesDataStore
-import dagger.hilt.android.qualifiers.ApplicationContext
-import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 import soup.movie.common.ApplicationScope
-import soup.movie.common.IoDispatcher
 import soup.movie.data.settings.AppSettings
 import soup.movie.model.settings.AgeFilter
 import soup.movie.model.settings.TheaterFilter
@@ -41,21 +34,10 @@ import javax.inject.Singleton
 
 @Singleton
 class AppSettingsImpl @Inject constructor(
-    @ApplicationContext private val context: Context,
-    @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+    private val preferences: DataStore<Preferences>,
     @ApplicationScope private val coroutineScope: CoroutineScope,
 ) : AppSettings {
 
-    private val Context.preferencesName: String
-        get() = packageName + "_preferences"
-
-    private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(
-        name = context.preferencesName,
-        produceMigrations = { context ->
-            listOf(SharedPreferencesMigration(context, context.preferencesName))
-        },
-    )
-
     private val theaterFilterKey = intPreferencesKey("theater_filter")
 
     init {
@@ -65,13 +47,13 @@ class AppSettingsImpl @Inject constructor(
     }
 
     override suspend fun setTheaterFilter(theaterFilter: TheaterFilter) {
-        context.dataStore.edit { settings ->
+        preferences.edit { settings ->
             settings[theaterFilterKey] = theaterFilter.toFlags()
         }
     }
 
     override fun getTheaterFilterFlow(): Flow<TheaterFilter> {
-        return context.dataStore.data.map { preferences ->
+        return preferences.data.map { preferences ->
             TheaterFilter(
                 preferences[theaterFilterKey]
                     ?: TheaterFilter.FLAG_THEATER_ALL,
@@ -82,13 +64,13 @@ class AppSettingsImpl @Inject constructor(
     private val ageFilterKey = intPreferencesKey("age_filter")
 
     override suspend fun setAgeFilter(ageFilter: AgeFilter) {
-        context.dataStore.edit { settings ->
+        preferences.edit { settings ->
             settings[ageFilterKey] = ageFilter.toFlags()
         }
     }
 
     override fun getAgeFilterFlow(): Flow<AgeFilter> {
-        return context.dataStore.data.map { preferences ->
+        return preferences.data.map { preferences ->
             AgeFilter(
                 preferences[ageFilterKey] ?: AgeFilter.FLAG_AGE_DEFAULT,
             )
@@ -98,10 +80,8 @@ class AppSettingsImpl @Inject constructor(
     private val themeOptionKey = stringPreferencesKey("theme_option")
 
     override suspend fun setThemeOption(themeOption: String) {
-        withContext(ioDispatcher) {
-            context.dataStore.edit { settings ->
-                settings[themeOptionKey] = themeOption
-            }
+        preferences.edit { settings ->
+            settings[themeOptionKey] = themeOption
         }
     }
 
@@ -110,17 +90,15 @@ class AppSettingsImpl @Inject constructor(
     }
 
     override fun getThemeOptionFlow(): Flow<String> {
-        return context.dataStore.data.map { preferences ->
+        return preferences.data.map { preferences ->
             preferences[themeOptionKey].orEmpty()
         }
     }
 
     private suspend fun clearStaleData() {
-        withContext(ioDispatcher) {
-            context.dataStore.edit { settings ->
-                settings.remove(stringPreferencesKey("favorite_theaters"))
-                settings.remove(stringPreferencesKey("favorite_genre"))
-            }
+        preferences.edit { settings ->
+            settings.remove(stringPreferencesKey("favorite_theaters"))
+            settings.remove(stringPreferencesKey("favorite_genre"))
         }
     }
 }

data/settings/impl/src/main/java/soup/movie/data/settings/impl/di/DataStoreModule.kt

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2025 SOUP
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package soup.movie.data.settings.impl.di
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.SharedPreferencesMigration
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.preferencesDataStoreFile
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import soup.movie.common.ApplicationScope
+import soup.movie.common.IoDispatcher
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+object DataStoreModule {
+
+    @Provides
+    @Singleton
+    fun providesPreferencesDataStore(
+        @ApplicationContext context: Context,
+        @IoDispatcher ioDispatcher: CoroutineDispatcher,
+        @ApplicationScope scope: CoroutineScope,
+    ): DataStore<Preferences> {
+        val name = context.packageName + "_preferences"
+        return PreferenceDataStoreFactory.create(
+            scope = CoroutineScope(scope.coroutineContext + ioDispatcher),
+            migrations = listOf(
+                SharedPreferencesMigration(context = context, sharedPreferencesName = name),
+            ),
+        ) {
+            context.preferencesDataStoreFile(name)
+        }
+    }
+}