converting the muted rooms to a database table

domains/store/src/main/kotlin/app/dapk/st/domain/StoreModule.kt

@@ -34,7 +34,7 @@ class StoreModule(
     private val coroutineDispatchers: CoroutineDispatchers,
 ) {
 
-    private val muteableStore by unsafeLazy { MutedStorePersistence(preferences) }
+    private val muteableStore by unsafeLazy { MutedStorePersistence(database, coroutineDispatchers) }
 
     fun overviewStore(): OverviewStore = OverviewPersistence(database, coroutineDispatchers)
     fun roomStore(): RoomStore {

domains/store/src/main/kotlin/app/dapk/st/domain/room/MutedRoomsStore.kt

@@ -1,39 +1,41 @@
 package app.dapk.st.domain.room
 
-import app.dapk.st.core.Preferences
+import app.dapk.db.DapkDb
-import app.dapk.st.core.append
+import app.dapk.st.core.CoroutineDispatchers
-import app.dapk.st.core.removeFromSet
+import app.dapk.st.core.withIoContext
 import app.dapk.st.matrix.common.RoomId
 import app.dapk.st.matrix.sync.MuteableStore
+import com.squareup.sqldelight.runtime.coroutines.asFlow
+import com.squareup.sqldelight.runtime.coroutines.mapToList
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.firstOrNull
-import kotlinx.coroutines.flow.onStart
+import kotlinx.coroutines.flow.map
-
-private const val KEY_MUTE = "mute"
 
 internal class MutedStorePersistence(
-    private val preferences: Preferences
+    private val database: DapkDb,
+    private val coroutineDispatchers: CoroutineDispatchers,
 ) : MuteableStore {
 
     private val allMutedFlow = MutableSharedFlow<Set<RoomId>>(replay = 1)
 
     override suspend fun mute(roomId: RoomId) {
-        preferences.append(KEY_MUTE, roomId.value).notifyChange()
+        coroutineDispatchers.withIoContext {
+            database.mutedRoomQueries.insertMuted(roomId.value)
+        }
     }
 
     override suspend fun unmute(roomId: RoomId) {
-        preferences.removeFromSet(KEY_MUTE, roomId.value).notifyChange()
+        coroutineDispatchers.withIoContext {
+            database.mutedRoomQueries.removeMuted(roomId.value)
+        }
     }
 
-    private suspend fun Set<String>.notifyChange() = allMutedFlow.emit(this.map { RoomId(it) }.toSet())
-
     override suspend fun isMuted(roomId: RoomId) = allMutedFlow.firstOrNull()?.contains(roomId) ?: false
 
-    override fun observeMuted(): Flow<Set<RoomId>> = allMutedFlow.onStart { emit(readAll()) }
+    override fun observeMuted(): Flow<Set<RoomId>> = database.mutedRoomQueries.select()
-
+        .asFlow()
-    private suspend fun readAll(): Set<RoomId> {
+        .mapToList()
-        return preferences.readStrings(KEY_MUTE)?.map { RoomId(it) }?.toSet() ?: emptySet()
+        .map { it.map { RoomId(it) }.toSet() }
-    }
 
 }

domains/store/src/main/sqldelight/app/dapk/db/model/MutedRoom.sq

@@ -0,0 +1,16 @@
+CREATE TABLE IF NOT EXISTS dbMutedRoom (
+    room_id TEXT NOT NULL,
+    PRIMARY KEY (room_id)
+);
+
+insertMuted:
+INSERT OR REPLACE INTO dbMutedRoom(room_id)
+VALUES (?);
+
+removeMuted:
+DELETE FROM dbMutedRoom
+WHERE room_id = ?;
+
+select:
+SELECT room_id
+FROM dbMutedRoom;

domains/store/src/main/sqldelight/app/dapk/db/model/RoomMember.sq

@@ -16,7 +16,6 @@ FROM dbRoomMember
 WHERE room_id = ?
 LIMIT ?;
 
-
 insert:
 INSERT OR REPLACE INTO dbRoomMember(user_id, room_id, blob)
 VALUES (?, ?, ?);