Refactor usecases

app/src/main/kotlin/de/entikore/composedex/domain/usecase/ChangeLightDarkThemeUseCase.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2024 Entikore
+ * Copyright 2025 Entikore
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,22 +17,19 @@ package de.entikore.composedex.domain.usecase
 
 import de.entikore.composedex.domain.model.preferences.AppThemeConfig
 import de.entikore.composedex.domain.repository.AppSettingsRepository
-import de.entikore.composedex.domain.usecase.base.ParamsSuspendUseCase
+import de.entikore.composedex.domain.usecase.base.BaseSuspendUseCase
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
 import javax.inject.Inject
 
 /**
  * This use case changes the app theme between light and dark mode.
  */
 class ChangeLightDarkThemeUseCase @Inject constructor(
     private val repository: AppSettingsRepository,
-    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO
-) : ParamsSuspendUseCase<AppThemeConfig, Unit>() {
-    override suspend operator fun invoke(params: AppThemeConfig) {
-        withContext(ioDispatcher) {
-            repository.setTheme(params)
-        }
-    }
+    dispatcher: CoroutineDispatcher = Dispatchers.IO
+) : BaseSuspendUseCase<AppThemeConfig, Unit>(dispatcher) {
+
+    override suspend fun execute(params: AppThemeConfig) =
+        repository.setTheme(params)
 }

app/src/main/kotlin/de/entikore/composedex/domain/usecase/ChangeTypeThemeUseCase.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2024 Entikore
+ * Copyright 2025 Entikore
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,22 +18,19 @@ package de.entikore.composedex.domain.usecase
 import de.entikore.composedex.domain.model.pokemon.Pokemon
 import de.entikore.composedex.domain.model.preferences.TypeThemeConfig
 import de.entikore.composedex.domain.repository.AppSettingsRepository
-import de.entikore.composedex.domain.usecase.base.ParamsSuspendUseCase
+import de.entikore.composedex.domain.usecase.base.BaseSuspendUseCase
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
 import javax.inject.Inject
 
 /**
  * This use case changes the app theme, to match the color palette with the type of the [Pokemon].
  */
 class ChangeTypeThemeUseCase @Inject constructor(
     private val repository: AppSettingsRepository,
-    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO
-) : ParamsSuspendUseCase<String, Unit>() {
-    override suspend operator fun invoke(params: String) {
-        withContext(ioDispatcher) {
-            repository.setTypeTheme(TypeThemeConfig.fromTypeString(params))
-        }
-    }
+    dispatcher: CoroutineDispatcher = Dispatchers.IO
+) : BaseSuspendUseCase<String, Unit>(dispatcher) {
+
+    override suspend fun execute(params: String) =
+        repository.setTypeTheme(TypeThemeConfig.fromTypeString(params))
 }

app/src/main/kotlin/de/entikore/composedex/domain/usecase/DeleteLocalDataUseCase.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2024 Entikore
+ * Copyright 2025 Entikore
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,27 +18,24 @@ package de.entikore.composedex.domain.usecase
 import android.content.Context
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.entikore.composedex.domain.repository.LocalStorage
-import de.entikore.composedex.domain.usecase.base.SuspendUseCase
+import de.entikore.composedex.domain.usecase.base.BaseSuspendUseCase
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
 
 /**
  * This use case deletes all stored data from the local storage.
  */
 class DeleteLocalDataUseCase(
     @ApplicationContext private val context: Context,
     private val localStorage: LocalStorage,
-    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO
-) : SuspendUseCase<Unit>() {
+    dispatcher: CoroutineDispatcher = Dispatchers.IO
+) : BaseSuspendUseCase<Unit, Unit>(dispatcher) {
 
-    override suspend operator fun invoke() {
-        withContext(ioDispatcher) {
-            val files = context.fileList()
-            for (file in files) {
-                context.deleteFile(file)
-            }
-            localStorage.clearData()
+    override suspend fun execute(params: Unit) {
+        val files = context.fileList()
+        for (file in files) {
+            context.deleteFile(file)
         }
+        localStorage.clearData()
     }
 }

app/src/main/kotlin/de/entikore/composedex/domain/usecase/GetFavouritesUseCase.kt → app/src/main/kotlin/de/entikore/composedex/domain/usecase/FetchFavouritesUseCase.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2024 Entikore
+ * Copyright 2025 Entikore
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,21 +15,23 @@
  */
 package de.entikore.composedex.domain.usecase
 
-import de.entikore.composedex.domain.WorkResult
-import de.entikore.composedex.domain.asWorkResult
 import de.entikore.composedex.domain.model.pokemon.Pokemon
 import de.entikore.composedex.domain.repository.FavouriteRepository
-import de.entikore.composedex.domain.usecase.base.UseCase
-import kotlinx.coroutines.flow.Flow
+import de.entikore.composedex.domain.usecase.base.BaseFetchUseCase
+import de.entikore.composedex.domain.util.asResult
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.distinctUntilChanged
 import javax.inject.Inject
 
 /**
  * This use case returns the latest as favourites marked Pokemon.
  */
-class GetFavouritesUseCase @Inject constructor(private val repository: FavouriteRepository) :
-    UseCase<Flow<WorkResult<List<Pokemon>>>>() {
-
-    override operator fun invoke() = repository.getFavourites().distinctUntilChanged()
-        .asWorkResult()
+@Suppress("TooGenericExceptionCaught")
+class FetchFavouritesUseCase @Inject constructor(
+    private val repository: FavouriteRepository,
+    dispatcher: CoroutineDispatcher = Dispatchers.IO
+) :
+    BaseFetchUseCase<Unit, List<Pokemon>>(dispatcher) {
+    override fun execute(params: Unit) = repository.getFavourites().distinctUntilChanged().asResult()
 }

app/src/main/kotlin/de/entikore/composedex/domain/usecase/GetGenerationUseCase.kt → app/src/main/kotlin/de/entikore/composedex/domain/usecase/FetchGenerationUseCase.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2024 Entikore
+ * Copyright 2025 Entikore
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,28 +15,32 @@
  */
 package de.entikore.composedex.domain.usecase
 
-import de.entikore.composedex.domain.WorkResult
-import de.entikore.composedex.domain.asWorkResult
 import de.entikore.composedex.domain.model.generation.Generation
 import de.entikore.composedex.domain.repository.GenerationRepository
-import de.entikore.composedex.domain.usecase.base.ParamsUseCase
+import de.entikore.composedex.domain.usecase.base.BaseFetchUseCase
+import de.entikore.composedex.domain.util.asResult
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import javax.inject.Inject
 
 /**
  * This use case returns the latest [Generation] of the provided name or id.
  */
-class GetGenerationUseCase @Inject constructor(private val repository: GenerationRepository) :
-    ParamsUseCase<String, Flow<WorkResult<Generation>>>() {
+class FetchGenerationUseCase @Inject constructor(
+    private val repository: GenerationRepository,
+    dispatcher: CoroutineDispatcher = Dispatchers.IO
+) :
+    BaseFetchUseCase<String, Generation>(dispatcher) {
 
-    override operator fun invoke(params: String): Flow<WorkResult<Generation>> {
+    override fun execute(params: String): Flow<Result<Generation>> {
         val id = params.trim().toIntOrNull()
         return if (id != null) {
-            repository.getGenerationById(id).distinctUntilChanged().asWorkResult()
+            repository.getGenerationById(id).distinctUntilChanged().asResult()
         } else {
             val normalizedParams = params.lowercase().trim()
-            repository.getGenerationByName(normalizedParams).distinctUntilChanged().asWorkResult()
+            repository.getGenerationByName(normalizedParams).distinctUntilChanged().asResult()
         }
     }
 }

app/src/main/kotlin/de/entikore/composedex/domain/usecase/GetGenerationsUseCase.kt → app/src/main/kotlin/de/entikore/composedex/domain/usecase/FetchGenerationsUseCase.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2024 Entikore
+ * Copyright 2025 Entikore
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,20 +15,23 @@
  */
 package de.entikore.composedex.domain.usecase
 
-import de.entikore.composedex.domain.WorkResult
-import de.entikore.composedex.domain.asWorkResult
 import de.entikore.composedex.domain.model.generation.Generation
 import de.entikore.composedex.domain.repository.GenerationRepository
-import de.entikore.composedex.domain.usecase.base.UseCase
-import kotlinx.coroutines.flow.Flow
+import de.entikore.composedex.domain.usecase.base.BaseFetchUseCase
+import de.entikore.composedex.domain.util.asResult
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.distinctUntilChanged
 import javax.inject.Inject
 
 /**
  * This use case returns the latest list of all [Generation].
  */
-class GetGenerationsUseCase @Inject constructor(private val repository: GenerationRepository) :
-    UseCase<Flow<WorkResult<List<Generation>>>>() {
-    override operator fun invoke() =
-        repository.getGenerations().distinctUntilChanged().asWorkResult()
+class FetchGenerationsUseCase @Inject constructor(
+    private val repository: GenerationRepository,
+    dispatcher: CoroutineDispatcher = Dispatchers.IO
+) :
+    BaseFetchUseCase<Unit, List<Generation>>(dispatcher) {
+    override fun execute(params: Unit) =
+        repository.getGenerations().distinctUntilChanged().asResult()
 }

app/src/main/kotlin/de/entikore/composedex/domain/usecase/GetPokemonOfGenerationUseCase.kt → app/src/main/kotlin/de/entikore/composedex/domain/usecase/FetchPokemonOfGenerationUseCase.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2024 Entikore
+ * Copyright 2025 Entikore
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,12 +15,13 @@
  */
 package de.entikore.composedex.domain.usecase
 
-import de.entikore.composedex.domain.WorkResult
-import de.entikore.composedex.domain.asWorkResult
 import de.entikore.composedex.domain.model.generation.Generation
 import de.entikore.composedex.domain.model.pokemon.Pokemon
 import de.entikore.composedex.domain.repository.GenerationRepository
-import de.entikore.composedex.domain.usecase.base.ParamsUseCase
+import de.entikore.composedex.domain.usecase.base.BaseFetchUseCase
+import de.entikore.composedex.domain.util.asResult
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import javax.inject.Inject
@@ -29,17 +30,17 @@ import javax.inject.Inject
  * This use case returns the latest list of [Pokemon] belonging to the [Generation]
  * of the provided name or id.
  */
-class GetPokemonOfGenerationUseCase @Inject constructor(
-    private val repository: GenerationRepository
-) : ParamsUseCase<String, Flow<WorkResult<List<Pokemon>>>>() {
-    override operator fun invoke(params: String): Flow<WorkResult<List<Pokemon>>> {
+class FetchPokemonOfGenerationUseCase @Inject constructor(
+    private val repository: GenerationRepository,
+    dispatcher: CoroutineDispatcher = Dispatchers.IO
+) : BaseFetchUseCase<String, List<Pokemon>>(dispatcher) {
+    override fun execute(params: String): Flow<Result<List<Pokemon>>> {
         val id = params.trim().toIntOrNull()
         return if (id != null) {
-            repository.getPokemonOfGenerationById(id).distinctUntilChanged().asWorkResult()
+            repository.getPokemonOfGenerationById(id).distinctUntilChanged().asResult()
         } else {
             val normalizedParams = params.lowercase().trim()
-            repository.getPokemonOfGenerationByName(normalizedParams).distinctUntilChanged()
-                .asWorkResult()
+            repository.getPokemonOfGenerationByName(normalizedParams).distinctUntilChanged().asResult()
         }
     }
 }

app/src/main/kotlin/de/entikore/composedex/domain/usecase/GetPokemonOfTypeUseCase.kt → app/src/main/kotlin/de/entikore/composedex/domain/usecase/FetchPokemonOfTypeUseCase.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2024 Entikore
+ * Copyright 2025 Entikore
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,23 +15,25 @@
  */
 package de.entikore.composedex.domain.usecase
 
-import de.entikore.composedex.domain.WorkResult
-import de.entikore.composedex.domain.asWorkResult
 import de.entikore.composedex.domain.model.pokemon.Pokemon
 import de.entikore.composedex.domain.model.type.Type
 import de.entikore.composedex.domain.repository.TypeRepository
-import de.entikore.composedex.domain.usecase.base.ParamsUseCase
-import kotlinx.coroutines.flow.Flow
+import de.entikore.composedex.domain.usecase.base.BaseFetchUseCase
+import de.entikore.composedex.domain.util.asResult
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.distinctUntilChanged
 import javax.inject.Inject
 
 /**
  * This use case returns the latest list of [Pokemon] belonging to the [Type]
  * of the provided name.
  */
-class GetPokemonOfTypeUseCase @Inject constructor(private val repository: TypeRepository) :
-    ParamsUseCase<String, Flow<WorkResult<List<Pokemon>>>>() {
-
-    override operator fun invoke(params: String): Flow<WorkResult<List<Pokemon>>> =
-        repository.getPokemonOfType(params).distinctUntilChanged().asWorkResult()
+class FetchPokemonOfTypeUseCase @Inject constructor(
+    private val repository: TypeRepository,
+    dispatcher: CoroutineDispatcher = Dispatchers.IO
+) :
+    BaseFetchUseCase<String, List<Pokemon>>(dispatcher) {
+    override fun execute(params: String) =
+        repository.getPokemonOfType(params).distinctUntilChanged().asResult()
 }