Refactor search

files/build.gradle.kts

@@ -44,7 +44,6 @@ dependencies {
 
     implementation(libs.koin.android)
 
-    implementation(project(":preferences"))
     implementation(project(":base"))
     implementation(project(":ktx"))
     implementation(project(":ms-services"))

files/src/main/java/de/mm20/launcher2/files/FilesRepository.kt

@@ -1,12 +1,15 @@
 package de.mm20.launcher2.files
 
 import android.content.Context
-import de.mm20.launcher2.files.providers.*
+import de.mm20.launcher2.files.providers.FileProvider
+import de.mm20.launcher2.files.providers.GDriveFileProvider
+import de.mm20.launcher2.files.providers.LocalFileProvider
+import de.mm20.launcher2.files.providers.NextcloudFileProvider
+import de.mm20.launcher2.files.providers.OneDriveFileProvider
+import de.mm20.launcher2.files.providers.OwncloudFileProvider
 import de.mm20.launcher2.nextcloud.NextcloudApiHelper
 import de.mm20.launcher2.owncloud.OwncloudClient
 import de.mm20.launcher2.permissions.PermissionsManager
-import de.mm20.launcher2.preferences.LauncherDataStore
-import de.mm20.launcher2.search.SearchableRepository
 import de.mm20.launcher2.search.data.File
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentListOf
@@ -14,24 +17,30 @@ import kotlinx.collections.immutable.toImmutableList
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.channelFlow
 import kotlinx.coroutines.launch
 
-interface FileRepository: SearchableRepository<File> {
+interface FileRepository {
+    fun search(
+        query: String,
+        local: Boolean = true,
+        gdrive: Boolean = true,
+        onedrive: Boolean = true,
+        nextcloud: Boolean = true,
+        owncloud: Boolean = true,
+    ): Flow<ImmutableList<File>>
+
     fun deleteFile(file: File)
 }
 
 internal class FileRepositoryImpl(
     private val context: Context,
-    private val dataStore: LauncherDataStore,
     private val permissionsManager: PermissionsManager,
 ) : FileRepository {
 
     private val scope = CoroutineScope(Job() + Dispatchers.Default)
 
-
-    private val providers = MutableStateFlow<List<FileProvider>>(emptyList())
-
     private val nextcloudClient by lazy {
         NextcloudApiHelper(context)
     }
@@ -39,46 +48,35 @@ internal class FileRepositoryImpl(
         OwncloudClient(context)
     }
 
-    init {
-        scope.launch {
-            dataStore.data.map { it.fileSearch }.distinctUntilChanged().collectLatest {
-                val provs = mutableListOf<FileProvider>()
-                if (it.localFiles) {
-                    provs += LocalFileProvider(context, permissionsManager)
-                }
-                if (it.nextcloud) {
-                    provs += NextcloudFileProvider(nextcloudClient)
-                }
-                if (it.owncloud) {
-                    provs += OwncloudFileProvider(owncloudClient)
-                }
-                if (it.gdrive) {
-                    provs += GDriveFileProvider(context)
-                }
-                if (it.onedrive) {
-                    provs += OneDriveFileProvider(context)
-                }
-                providers.value = provs
-            }
-        }
-    }
-
-    override fun search(query: String): Flow<ImmutableList<File>> = channelFlow {
+    override fun search(
+        query: String,
+        local: Boolean,
+        gdrive: Boolean,
+        onedrive: Boolean,
+        nextcloud: Boolean,
+        owncloud: Boolean
+    ) = channelFlow {
         if (query.isBlank()) {
             send(persistentListOf())
             return@channelFlow
         }
 
-        providers.collectLatest { providers ->
-            if (providers.isEmpty()) {
-                send(persistentListOf())
-                return@collectLatest
-            }
-            val results = mutableListOf<File>()
-            for (provider in providers) {
-                results.addAll(provider.search(query))
-                send(results.toImmutableList())
-            }
+        val providers = mutableListOf<FileProvider>()
+
+        if (local) providers.add(LocalFileProvider(context, permissionsManager))
+        if (gdrive) providers.add(GDriveFileProvider(context))
+        if (onedrive) providers.add(OneDriveFileProvider(context))
+        if (nextcloud) providers.add(NextcloudFileProvider(nextcloudClient))
+        if (owncloud) providers.add(OwncloudFileProvider(owncloudClient))
+
+        if (providers.isEmpty()) {
+            send(persistentListOf())
+            return@channelFlow
+        }
+        val results = mutableListOf<File>()
+        for (provider in providers) {
+            results.addAll(provider.search(query))
+            send(results.toImmutableList())
         }
     }
 

files/src/main/java/de/mm20/launcher2/files/Module.kt

@@ -4,5 +4,5 @@ import org.koin.android.ext.koin.androidContext
 import org.koin.dsl.module
 
 val filesModule = module {
-    single<FileRepository> { FileRepositoryImpl(androidContext(), get(), get()) }
+    single<FileRepository> { FileRepositoryImpl(androidContext(), get()) }
 }