Minor cleanup

2025-11-14 04:58:56 +01:00 · 2022-10-14 16:13:50 -04:00
parent 7e92921f84
commit bc1fbfac9d
21 changed files with 60 additions and 75 deletions
--- a/app/src/main/java/eu/kanade/domain/DomainModule.kt
+++ b/app/src/main/java/eu/kanade/domain/DomainModule.kt
@@ -32,7 +32,7 @@ import eu.kanade.domain.download.interactor.DeleteDownload
 import eu.kanade.domain.extension.interactor.GetExtensionLanguages
 import eu.kanade.domain.extension.interactor.GetExtensionSources
 import eu.kanade.domain.extension.interactor.GetExtensionsByType
-import eu.kanade.domain.history.interactor.DeleteHistoryTable
+import eu.kanade.domain.history.interactor.DeleteAllHistory
 import eu.kanade.domain.history.interactor.GetHistory
 import eu.kanade.domain.history.interactor.GetNextChapter
 import eu.kanade.domain.history.interactor.RemoveHistoryById
@@ -117,7 +117,7 @@ class DomainModule : InjektModule {
        addFactory { SyncChaptersWithTrackServiceTwoWay(get(), get()) }

        addSingletonFactory<HistoryRepository> { HistoryRepositoryImpl(get()) }
-        addFactory { DeleteHistoryTable(get()) }
+        addFactory { DeleteAllHistory(get()) }
        addFactory { GetHistory(get()) }
        addFactory { UpsertHistory(get()) }
        addFactory { RemoveHistoryById(get()) }
--- a/app/src/main/java/eu/kanade/domain/category/interactor/CreateCategoryWithName.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/CreateCategoryWithName.kt
@@ -4,9 +4,8 @@ import eu.kanade.domain.category.model.Category
 import eu.kanade.domain.category.model.anyWithName
 import eu.kanade.domain.category.repository.CategoryRepository
 import eu.kanade.domain.library.service.LibraryPreferences
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
 import eu.kanade.tachiyomi.util.system.logcat
-import kotlinx.coroutines.NonCancellable
-import kotlinx.coroutines.withContext
 import logcat.LogPriority

 class CreateCategoryWithName(
@@ -22,10 +21,10 @@ class CreateCategoryWithName(
                sort.direction.flag
        }

-    suspend fun await(name: String): Result = withContext(NonCancellable) {
+    suspend fun await(name: String): Result = withNonCancellableContext {
        val categories = categoryRepository.getAll()
        if (categories.anyWithName(name)) {
-            return@withContext Result.NameAlreadyExistsError
+            return@withNonCancellableContext Result.NameAlreadyExistsError
        }

        val nextOrder = categories.maxOfOrNull { it.order }?.plus(1) ?: 0
--- a/app/src/main/java/eu/kanade/domain/category/interactor/DeleteCategory.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/DeleteCategory.kt
@@ -2,21 +2,20 @@ package eu.kanade.domain.category.interactor

 import eu.kanade.domain.category.model.CategoryUpdate
 import eu.kanade.domain.category.repository.CategoryRepository
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
 import eu.kanade.tachiyomi.util.system.logcat
-import kotlinx.coroutines.NonCancellable
-import kotlinx.coroutines.withContext
 import logcat.LogPriority

 class DeleteCategory(
    private val categoryRepository: CategoryRepository,
 ) {

-    suspend fun await(categoryId: Long) = withContext(NonCancellable) {
+    suspend fun await(categoryId: Long) = withNonCancellableContext {
        try {
            categoryRepository.delete(categoryId)
        } catch (e: Exception) {
            logcat(LogPriority.ERROR, e)
-            return@withContext Result.InternalError(e)
+            return@withNonCancellableContext Result.InternalError(e)
        }

        val categories = categoryRepository.getAll()
--- a/app/src/main/java/eu/kanade/domain/category/interactor/RenameCategory.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/RenameCategory.kt
@@ -4,19 +4,18 @@ import eu.kanade.domain.category.model.Category
 import eu.kanade.domain.category.model.CategoryUpdate
 import eu.kanade.domain.category.model.anyWithName
 import eu.kanade.domain.category.repository.CategoryRepository
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
 import eu.kanade.tachiyomi.util.system.logcat
-import kotlinx.coroutines.NonCancellable
-import kotlinx.coroutines.withContext
 import logcat.LogPriority

 class RenameCategory(
    private val categoryRepository: CategoryRepository,
 ) {

-    suspend fun await(categoryId: Long, name: String) = withContext(NonCancellable) {
+    suspend fun await(categoryId: Long, name: String) = withNonCancellableContext {
        val categories = categoryRepository.getAll()
        if (categories.anyWithName(name)) {
-            return@withContext Result.NameAlreadyExistsError
+            return@withNonCancellableContext Result.NameAlreadyExistsError
        }

        val update = CategoryUpdate(
--- a/app/src/main/java/eu/kanade/domain/category/interactor/ReorderCategory.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/ReorderCategory.kt
@@ -3,21 +3,20 @@ package eu.kanade.domain.category.interactor
 import eu.kanade.domain.category.model.Category
 import eu.kanade.domain.category.model.CategoryUpdate
 import eu.kanade.domain.category.repository.CategoryRepository
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
 import eu.kanade.tachiyomi.util.system.logcat
-import kotlinx.coroutines.NonCancellable
-import kotlinx.coroutines.withContext
 import logcat.LogPriority

 class ReorderCategory(
    private val categoryRepository: CategoryRepository,
 ) {

-    suspend fun await(categoryId: Long, newPosition: Int) = withContext(NonCancellable) {
+    suspend fun await(categoryId: Long, newPosition: Int) = withNonCancellableContext {
        val categories = categoryRepository.getAll().filterNot(Category::isSystemCategory)

        val currentIndex = categories.indexOfFirst { it.id == categoryId }
        if (currentIndex == newPosition) {
-            return@withContext Result.Unchanged
+            return@withNonCancellableContext Result.Unchanged
        }

        val reorderedCategories = categories.toMutableList()
--- a/app/src/main/java/eu/kanade/domain/category/interactor/UpdateCategory.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/UpdateCategory.kt
@@ -2,14 +2,13 @@ package eu.kanade.domain.category.interactor

 import eu.kanade.domain.category.model.CategoryUpdate
 import eu.kanade.domain.category.repository.CategoryRepository
-import kotlinx.coroutines.NonCancellable
-import kotlinx.coroutines.withContext
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext

 class UpdateCategory(
    private val categoryRepository: CategoryRepository,
 ) {

-    suspend fun await(payload: CategoryUpdate): Result = withContext(NonCancellable) {
+    suspend fun await(payload: CategoryUpdate): Result = withNonCancellableContext {
        try {
            categoryRepository.updatePartial(payload)
            Result.Success
--- a/app/src/main/java/eu/kanade/domain/chapter/interactor/SetReadStatus.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/interactor/SetReadStatus.kt
@@ -7,9 +7,8 @@ import eu.kanade.domain.download.interactor.DeleteDownload
 import eu.kanade.domain.download.service.DownloadPreferences
 import eu.kanade.domain.manga.model.Manga
 import eu.kanade.domain.manga.repository.MangaRepository
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
 import eu.kanade.tachiyomi.util.system.logcat
-import kotlinx.coroutines.NonCancellable
-import kotlinx.coroutines.withContext
 import logcat.LogPriority

 class SetReadStatus(
@@ -27,49 +26,39 @@ class SetReadStatus(
        )
    }

-    suspend fun await(read: Boolean, vararg values: Chapter): Result = withContext(NonCancellable) {
-        val chapters = values.filterNot { it.read == read }
-
-        if (chapters.isEmpty()) {
-            return@withContext Result.NoChapters
-        }
-
-        val manga = chapters.fold(mutableSetOf<Manga>()) { acc, chapter ->
-            if (acc.all { it.id != chapter.mangaId }) {
-                acc += mangaRepository.getMangaById(chapter.mangaId)
-            }
-            acc
+    suspend fun await(read: Boolean, vararg chapters: Chapter): Result = withNonCancellableContext {
+        val chaptersToUpdate = chapters.filterNot { it.read == read }
+        if (chaptersToUpdate.isEmpty()) {
+            return@withNonCancellableContext Result.NoChapters
        }

        try {
            chapterRepository.updateAll(
-                chapters.map { chapter ->
-                    mapper(chapter, read)
-                },
+                chaptersToUpdate.map { mapper(it, read) },
            )
        } catch (e: Exception) {
            logcat(LogPriority.ERROR, e)
-            return@withContext Result.InternalError(e)
+            return@withNonCancellableContext Result.InternalError(e)
        }

        if (read && downloadPreferences.removeAfterMarkedAsRead().get()) {
-            manga.forEach {
-                deleteDownload.awaitAll(
-                    manga = it,
-                    values = chapters
-                        .filter { chapter -> it.id == chapter.mangaId }
-                        .toTypedArray(),
-                )
-            }
+            chaptersToUpdate
+                .groupBy { it.mangaId }
+                .forEach { (mangaId, chapters) ->
+                    deleteDownload.awaitAll(
+                        manga = mangaRepository.getMangaById(mangaId),
+                        chapters = chapters.toTypedArray(),
+                    )
+                }
        }

        Result.Success
    }

-    suspend fun await(mangaId: Long, read: Boolean): Result = withContext(NonCancellable) {
+    suspend fun await(mangaId: Long, read: Boolean): Result = withNonCancellableContext {
        await(
            read = read,
-            values = chapterRepository
+            chapters = chapterRepository
                .getChapterByMangaId(mangaId)
                .toTypedArray(),
        )
--- a/app/src/main/java/eu/kanade/domain/chapter/interactor/SyncChaptersWithSource.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/interactor/SyncChaptersWithSource.kt
@@ -9,8 +9,8 @@ import eu.kanade.domain.chapter.repository.ChapterRepository
 import eu.kanade.domain.manga.interactor.UpdateManga
 import eu.kanade.domain.manga.model.Manga
 import eu.kanade.tachiyomi.data.download.DownloadManager
-import eu.kanade.tachiyomi.source.LocalSource
 import eu.kanade.tachiyomi.source.Source
+import eu.kanade.tachiyomi.source.isLocal
 import eu.kanade.tachiyomi.source.model.SChapter
 import eu.kanade.tachiyomi.source.online.HttpSource
 import eu.kanade.tachiyomi.util.chapter.ChapterRecognition
@@ -42,7 +42,7 @@ class SyncChaptersWithSource(
        manga: Manga,
        source: Source,
    ): List<Chapter> {
-        if (rawSourceChapters.isEmpty() && source.id != LocalSource.ID) {
+        if (rawSourceChapters.isEmpty() && !source.isLocal()) {
            throw NoChaptersException()
        }

--- a/app/src/main/java/eu/kanade/domain/download/interactor/DeleteDownload.kt
+++ b/app/src/main/java/eu/kanade/domain/download/interactor/DeleteDownload.kt
@@ -5,17 +5,16 @@ import eu.kanade.domain.chapter.model.toDbChapter
 import eu.kanade.domain.manga.model.Manga
 import eu.kanade.tachiyomi.data.download.DownloadManager
 import eu.kanade.tachiyomi.source.SourceManager
-import kotlinx.coroutines.NonCancellable
-import kotlinx.coroutines.withContext
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext

 class DeleteDownload(
    private val sourceManager: SourceManager,
    private val downloadManager: DownloadManager,
 ) {

-    suspend fun awaitAll(manga: Manga, vararg values: Chapter) = withContext(NonCancellable) {
+    suspend fun awaitAll(manga: Manga, vararg chapters: Chapter) = withNonCancellableContext {
        sourceManager.get(manga.source)?.let { source ->
-            downloadManager.deleteChapters(values.map { it.toDbChapter() }, manga, source)
+            downloadManager.deleteChapters(chapters.map { it.toDbChapter() }, manga, source)
        }
    }
 }
--- a/app/src/main/java/eu/kanade/domain/history/interactor/DeleteHistoryTable.kt
+++ b/app/src/main/java/eu/kanade/domain/history/interactor/DeleteHistoryTable.kt
@@ -2,7 +2,7 @@ package eu.kanade.domain.history.interactor

 import eu.kanade.domain.history.repository.HistoryRepository

-class DeleteHistoryTable(
+class DeleteAllHistory(
    private val repository: HistoryRepository,
 ) {

--- a/app/src/main/java/eu/kanade/domain/manga/interactor/UpdateManga.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/interactor/UpdateManga.kt
@@ -20,8 +20,8 @@ class UpdateManga(
        return mangaRepository.update(mangaUpdate)
    }

-    suspend fun awaitAll(values: List<MangaUpdate>): Boolean {
-        return mangaRepository.updateAll(values)
+    suspend fun awaitAll(mangaUpdates: List<MangaUpdate>): Boolean {
+        return mangaRepository.updateAll(mangaUpdates)
    }

    suspend fun awaitUpdateFromSource(
--- a/app/src/main/java/eu/kanade/domain/manga/repository/MangaRepository.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/repository/MangaRepository.kt
@@ -33,5 +33,5 @@ interface MangaRepository {

    suspend fun update(update: MangaUpdate): Boolean

-    suspend fun updateAll(values: List<MangaUpdate>): Boolean
+    suspend fun updateAll(mangaUpdates: List<MangaUpdate>): Boolean
 }
--- a/app/src/main/java/eu/kanade/domain/updates/interactor/GetUpdates.kt
+++ b/app/src/main/java/eu/kanade/domain/updates/interactor/GetUpdates.kt
@@ -18,7 +18,7 @@ class GetUpdates(
        return repository.subscribeAll(after)
            .onEach { updates ->
                // Set unread chapter count for bottom bar badge
-                preferences.unreadUpdatesCount().set(updates.count { it.read.not() })
+                preferences.unreadUpdatesCount().set(updates.count { !it.read })
            }
    }
 }