Adjust read next history logic

Closes #8454

app/src/main/java/eu/kanade/domain/DomainModule.kt

@@ -32,11 +32,9 @@ 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.DeleteAllHistory
 import eu.kanade.domain.history.interactor.GetHistory
-import eu.kanade.domain.history.interactor.GetNextUnreadChapters
+import eu.kanade.domain.history.interactor.GetNextChapters
-import eu.kanade.domain.history.interactor.RemoveHistoryById
+import eu.kanade.domain.history.interactor.RemoveHistory
-import eu.kanade.domain.history.interactor.RemoveHistoryByMangaId
 import eu.kanade.domain.history.interactor.UpsertHistory
 import eu.kanade.domain.history.repository.HistoryRepository
 import eu.kanade.domain.manga.interactor.GetDuplicateLibraryManga
@@ -94,7 +92,7 @@ class DomainModule : InjektModule {
         addFactory { GetLibraryManga(get()) }
         addFactory { GetMangaWithChapters(get(), get()) }
         addFactory { GetManga(get()) }
-        addFactory { GetNextUnreadChapters(get(), get(), get()) }
+        addFactory { GetNextChapters(get(), get(), get()) }
         addFactory { ResetViewerFlags(get()) }
         addFactory { SetMangaChapterFlags(get()) }
         addFactory { SetMangaDefaultChapterFlags(get(), get(), get()) }
@@ -119,11 +117,9 @@ class DomainModule : InjektModule {
         addFactory { SyncChaptersWithTrackServiceTwoWay(get(), get()) }
 
         addSingletonFactory<HistoryRepository> { HistoryRepositoryImpl(get()) }
-        addFactory { DeleteAllHistory(get()) }
         addFactory { GetHistory(get()) }
         addFactory { UpsertHistory(get()) }
-        addFactory { RemoveHistoryById(get()) }
+        addFactory { RemoveHistory(get()) }
-        addFactory { RemoveHistoryByMangaId(get()) }
 
         addFactory { DeleteDownload(get(), get()) }
 

app/src/main/java/eu/kanade/domain/history/interactor/DeleteAllHistory.kt

@@ -1,12 +0,0 @@
-package eu.kanade.domain.history.interactor
-
-import eu.kanade.domain.history.repository.HistoryRepository
-
-class DeleteAllHistory(
-    private val repository: HistoryRepository,
-) {
-
-    suspend fun await(): Boolean {
-        return repository.deleteAllHistory()
-    }
-}

app/src/main/java/eu/kanade/domain/history/interactor/GetHistory.kt

@@ -7,6 +7,7 @@ import kotlinx.coroutines.flow.Flow
 class GetHistory(
     private val repository: HistoryRepository,
 ) {
+
     fun subscribe(query: String): Flow<List<HistoryWithRelations>> {
         return repository.getHistory(query)
     }

app/src/main/java/eu/kanade/domain/history/interactor/GetNextChapters.kt

@@ -0,0 +1,52 @@
+package eu.kanade.domain.history.interactor
+
+import eu.kanade.domain.chapter.interactor.GetChapterByMangaId
+import eu.kanade.domain.chapter.model.Chapter
+import eu.kanade.domain.history.repository.HistoryRepository
+import eu.kanade.domain.manga.interactor.GetManga
+import eu.kanade.tachiyomi.util.chapter.getChapterSort
+import kotlin.math.max
+
+class GetNextChapters(
+    private val getChapterByMangaId: GetChapterByMangaId,
+    private val getManga: GetManga,
+    private val historyRepository: HistoryRepository,
+) {
+
+    suspend fun await(onlyUnread: Boolean = true): List<Chapter> {
+        val history = historyRepository.getLastHistory() ?: return emptyList()
+        return await(history.mangaId, history.chapterId, onlyUnread)
+    }
+
+    suspend fun await(mangaId: Long, onlyUnread: Boolean = true): List<Chapter> {
+        val manga = getManga.await(mangaId) ?: return emptyList()
+        val chapters = getChapterByMangaId.await(mangaId)
+            .sortedWith(getChapterSort(manga, sortDescending = false))
+
+        return if (onlyUnread) {
+            chapters.filterNot { it.read }
+        } else {
+            chapters
+        }
+    }
+
+    suspend fun await(mangaId: Long, fromChapterId: Long, onlyUnread: Boolean = true): List<Chapter> {
+        val chapters = await(mangaId, onlyUnread)
+        val currChapterIndex = chapters.indexOfFirst { it.id == fromChapterId }
+        val nextChapters = chapters.subList(max(0, currChapterIndex), chapters.size)
+
+        if (onlyUnread) {
+            return nextChapters
+        }
+
+        // The "next chapter" is either:
+        // - The current chapter if it isn't completely read
+        // - The chapters after the current chapter if the current one is completely read
+        val fromChapter = chapters.getOrNull(currChapterIndex)
+        return if (fromChapter != null && !fromChapter.read) {
+            nextChapters
+        } else {
+            nextChapters.drop(1)
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/history/interactor/GetNextUnreadChapters.kt

@@ -1,33 +0,0 @@
-package eu.kanade.domain.history.interactor
-
-import eu.kanade.domain.chapter.interactor.GetChapterByMangaId
-import eu.kanade.domain.chapter.model.Chapter
-import eu.kanade.domain.history.repository.HistoryRepository
-import eu.kanade.domain.manga.interactor.GetManga
-import eu.kanade.tachiyomi.util.chapter.getChapterSort
-import kotlin.math.max
-
-class GetNextUnreadChapters(
-    private val getChapterByMangaId: GetChapterByMangaId,
-    private val getManga: GetManga,
-    private val historyRepository: HistoryRepository,
-) {
-
-    suspend fun await(): Chapter? {
-        val history = historyRepository.getLastHistory() ?: return null
-        return await(history.mangaId, history.chapterId).firstOrNull()
-    }
-
-    suspend fun await(mangaId: Long): List<Chapter> {
-        val manga = getManga.await(mangaId) ?: return emptyList()
-        return getChapterByMangaId.await(mangaId)
-            .sortedWith(getChapterSort(manga, sortDescending = false))
-            .filterNot { it.read }
-    }
-
-    suspend fun await(mangaId: Long, fromChapterId: Long): List<Chapter> {
-        val unreadChapters = await(mangaId)
-        val currChapterIndex = unreadChapters.indexOfFirst { it.id == fromChapterId }
-        return unreadChapters.subList(max(0, currChapterIndex), unreadChapters.size)
-    }
-}

app/src/main/java/eu/kanade/domain/history/interactor/RemoveHistory.kt

@@ -3,11 +3,19 @@ package eu.kanade.domain.history.interactor
 import eu.kanade.domain.history.model.HistoryWithRelations
 import eu.kanade.domain.history.repository.HistoryRepository
 
-class RemoveHistoryById(
+class RemoveHistory(
     private val repository: HistoryRepository,
 ) {
 
+    suspend fun awaitAll(): Boolean {
+        return repository.deleteAllHistory()
+    }
+
     suspend fun await(history: HistoryWithRelations) {
         repository.resetHistory(history.id)
     }
+
+    suspend fun await(mangaId: Long) {
+        repository.resetHistoryByMangaId(mangaId)
+    }
 }

app/src/main/java/eu/kanade/domain/history/interactor/RemoveHistoryByMangaId.kt

@@ -1,12 +0,0 @@
-package eu.kanade.domain.history.interactor
-
-import eu.kanade.domain.history.repository.HistoryRepository
-
-class RemoveHistoryByMangaId(
-    private val repository: HistoryRepository,
-) {
-
-    suspend fun await(mangaId: Long) {
-        repository.resetHistoryByMangaId(mangaId)
-    }
-}

app/src/main/java/eu/kanade/presentation/history/HistoryScreen.kt

@@ -16,10 +16,10 @@ import eu.kanade.presentation.history.components.HistoryDeleteAllDialog
 import eu.kanade.presentation.history.components.HistoryDeleteDialog
 import eu.kanade.presentation.history.components.HistoryToolbar
 import eu.kanade.tachiyomi.R
+import eu.kanade.tachiyomi.ui.history.HistoryPresenter
+import eu.kanade.tachiyomi.ui.history.HistoryPresenter.Dialog
 import eu.kanade.tachiyomi.ui.main.MainActivity
 import eu.kanade.tachiyomi.ui.reader.ReaderActivity
-import eu.kanade.tachiyomi.ui.recent.history.HistoryPresenter
-import eu.kanade.tachiyomi.ui.recent.history.HistoryPresenter.Dialog
 import eu.kanade.tachiyomi.util.system.toast
 import eu.kanade.tachiyomi.widget.TachiyomiBottomNavigationView
 import kotlinx.coroutines.flow.collectLatest
@@ -88,7 +88,7 @@ fun HistoryScreen(
             HistoryDeleteAllDialog(
                 onDismissRequest = onDismissRequest,
                 onDelete = {
-                    presenter.deleteAllHistory()
+                    presenter.removeAllHistory()
                 },
             )
         }

app/src/main/java/eu/kanade/presentation/history/components/HistoryToolbar.kt

@@ -10,8 +10,8 @@ import androidx.compose.ui.res.stringResource
 import eu.kanade.presentation.components.AppBarTitle
 import eu.kanade.presentation.components.SearchToolbar
 import eu.kanade.tachiyomi.R
-import eu.kanade.tachiyomi.ui.recent.history.HistoryPresenter
+import eu.kanade.tachiyomi.ui.history.HistoryPresenter
-import eu.kanade.tachiyomi.ui.recent.history.HistoryState
+import eu.kanade.tachiyomi.ui.history.HistoryState
 
 @Composable
 fun HistoryToolbar(

app/src/main/java/eu/kanade/presentation/updates/UpdatesScreen.kt

@@ -35,10 +35,10 @@ import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.data.download.model.Download
 import eu.kanade.tachiyomi.data.library.LibraryUpdateService
 import eu.kanade.tachiyomi.ui.reader.ReaderActivity
-import eu.kanade.tachiyomi.ui.recent.updates.UpdatesItem
+import eu.kanade.tachiyomi.ui.updates.UpdatesItem
-import eu.kanade.tachiyomi.ui.recent.updates.UpdatesPresenter
+import eu.kanade.tachiyomi.ui.updates.UpdatesPresenter
-import eu.kanade.tachiyomi.ui.recent.updates.UpdatesPresenter.Dialog
+import eu.kanade.tachiyomi.ui.updates.UpdatesPresenter.Dialog
-import eu.kanade.tachiyomi.ui.recent.updates.UpdatesPresenter.Event
+import eu.kanade.tachiyomi.ui.updates.UpdatesPresenter.Event
 import eu.kanade.tachiyomi.util.system.toast
 import eu.kanade.tachiyomi.widget.TachiyomiBottomNavigationView
 import kotlinx.coroutines.delay

app/src/main/java/eu/kanade/presentation/updates/UpdatesState.kt

@@ -6,8 +6,8 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
 import eu.kanade.core.util.insertSeparators
-import eu.kanade.tachiyomi.ui.recent.updates.UpdatesItem
+import eu.kanade.tachiyomi.ui.updates.UpdatesItem
-import eu.kanade.tachiyomi.ui.recent.updates.UpdatesPresenter
+import eu.kanade.tachiyomi.ui.updates.UpdatesPresenter
 import eu.kanade.tachiyomi.util.lang.toDateKey
 import java.util.Date
 

app/src/main/java/eu/kanade/presentation/updates/UpdatesUiItem.kt

@@ -44,7 +44,7 @@ import eu.kanade.presentation.util.horizontalPadding
 import eu.kanade.presentation.util.selectedBackground
 import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.data.download.model.Download
-import eu.kanade.tachiyomi.ui.recent.updates.UpdatesItem
+import eu.kanade.tachiyomi.ui.updates.UpdatesItem
 import java.text.DateFormat
 import java.util.Date
 import kotlin.time.Duration.Companion.minutes

app/src/main/java/eu/kanade/tachiyomi/ui/history/HistoryController.kt

@@ -1,4 +1,4 @@
-package eu.kanade.tachiyomi.ui.recent.history
+package eu.kanade.tachiyomi.ui.history
 
 import androidx.compose.runtime.Composable
 import eu.kanade.presentation.history.HistoryScreen

app/src/main/java/eu/kanade/tachiyomi/ui/history/HistoryPresenter.kt

@@ -1,4 +1,4 @@
-package eu.kanade.tachiyomi.ui.recent.history
+package eu.kanade.tachiyomi.ui.history
 
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.Stable
@@ -9,11 +9,9 @@ import androidx.compose.runtime.setValue
 import eu.kanade.core.util.insertSeparators
 import eu.kanade.domain.base.BasePreferences
 import eu.kanade.domain.chapter.model.Chapter
-import eu.kanade.domain.history.interactor.DeleteAllHistory
 import eu.kanade.domain.history.interactor.GetHistory
-import eu.kanade.domain.history.interactor.GetNextUnreadChapters
+import eu.kanade.domain.history.interactor.GetNextChapters
-import eu.kanade.domain.history.interactor.RemoveHistoryById
+import eu.kanade.domain.history.interactor.RemoveHistory
-import eu.kanade.domain.history.interactor.RemoveHistoryByMangaId
 import eu.kanade.domain.history.model.HistoryWithRelations
 import eu.kanade.presentation.history.HistoryUiModel
 import eu.kanade.tachiyomi.R
@@ -37,10 +35,8 @@ import java.util.Date
 class HistoryPresenter(
     private val state: HistoryStateImpl = HistoryState() as HistoryStateImpl,
     private val getHistory: GetHistory = Injekt.get(),
-    private val getNextUnreadChapters: GetNextUnreadChapters = Injekt.get(),
+    private val getNextChapters: GetNextChapters = Injekt.get(),
-    private val deleteAllHistory: DeleteAllHistory = Injekt.get(),
+    private val removeHistory: RemoveHistory = Injekt.get(),
-    private val removeHistoryById: RemoveHistoryById = Injekt.get(),
-    private val removeHistoryByMangaId: RemoveHistoryByMangaId = Injekt.get(),
     preferences: BasePreferences = Injekt.get(),
 ) : BasePresenter<HistoryController>(), HistoryState by state {
 
@@ -48,7 +44,6 @@ class HistoryPresenter(
     val events: Flow<Event> = _events.receiveAsFlow()
 
     val isDownloadOnly: Boolean by preferences.downloadedOnly().asState()
-
     val isIncognitoMode: Boolean by preferences.incognitoMode().asState()
 
     @Composable
@@ -80,39 +75,42 @@ class HistoryPresenter(
             }
     }
 
-    fun removeFromHistory(history: HistoryWithRelations) {
-        presenterScope.launchIO {
-            removeHistoryById.await(history)
-        }
-    }
-
-    fun removeAllFromHistory(mangaId: Long) {
-        presenterScope.launchIO {
-            removeHistoryByMangaId.await(mangaId)
-        }
-    }
-
     fun getNextChapterForManga(mangaId: Long, chapterId: Long) {
         presenterScope.launchIO {
-            val chapter = getNextUnreadChapters.await(mangaId, chapterId).firstOrNull()
+            sendNextChapterEvent(getNextChapters.await(mangaId, chapterId, onlyUnread = false))
-            _events.send(if (chapter != null) Event.OpenChapter(chapter) else Event.NoNextChapterFound)
-        }
-    }
-
-    fun deleteAllHistory() {
-        presenterScope.launchIO {
-            val result = deleteAllHistory.await()
-            if (!result) return@launchIO
-            withUIContext {
-                view?.activity?.toast(R.string.clear_history_completed)
-            }
         }
     }
 
     fun resumeLastChapterRead() {
         presenterScope.launchIO {
-            val chapter = getNextUnreadChapters.await()
+            sendNextChapterEvent(getNextChapters.await(onlyUnread = false))
-            _events.send(if (chapter != null) Event.OpenChapter(chapter) else Event.NoNextChapterFound)
+        }
+    }
+
+    private suspend fun sendNextChapterEvent(chapters: List<Chapter>) {
+        val chapter = chapters.firstOrNull()
+        _events.send(if (chapter != null) Event.OpenChapter(chapter) else Event.NoNextChapterFound)
+    }
+
+    fun removeFromHistory(history: HistoryWithRelations) {
+        presenterScope.launchIO {
+            removeHistory.await(history)
+        }
+    }
+
+    fun removeAllFromHistory(mangaId: Long) {
+        presenterScope.launchIO {
+            removeHistory.await(mangaId)
+        }
+    }
+
+    fun removeAllHistory() {
+        presenterScope.launchIO {
+            val result = removeHistory.awaitAll()
+            if (!result) return@launchIO
+            withUIContext {
+                view?.activity?.toast(R.string.clear_history_completed)
+            }
         }
     }
 

app/src/main/java/eu/kanade/tachiyomi/ui/library/LibraryPresenter.kt

@@ -19,7 +19,7 @@ import eu.kanade.domain.category.interactor.SetMangaCategories
 import eu.kanade.domain.category.model.Category
 import eu.kanade.domain.chapter.interactor.SetReadStatus
 import eu.kanade.domain.chapter.model.toDbChapter
-import eu.kanade.domain.history.interactor.GetNextUnreadChapters
+import eu.kanade.domain.history.interactor.GetNextChapters
 import eu.kanade.domain.library.model.LibraryManga
 import eu.kanade.domain.library.model.LibrarySort
 import eu.kanade.domain.library.model.sort
@@ -78,7 +78,7 @@ class LibraryPresenter(
     private val getLibraryManga: GetLibraryManga = Injekt.get(),
     private val getTracksPerManga: GetTracksPerManga = Injekt.get(),
     private val getCategories: GetCategories = Injekt.get(),
-    private val getNextUnreadChapters: GetNextUnreadChapters = Injekt.get(),
+    private val getNextChapters: GetNextChapters = Injekt.get(),
     private val setReadStatus: SetReadStatus = Injekt.get(),
     private val updateManga: UpdateManga = Injekt.get(),
     private val setMangaCategories: SetMangaCategories = Injekt.get(),
@@ -410,7 +410,7 @@ class LibraryPresenter(
     fun downloadUnreadChapters(mangas: List<Manga>, amount: Int?) {
         presenterScope.launchNonCancellable {
             mangas.forEach { manga ->
-                val chapters = getNextUnreadChapters.await(manga.id)
+                val chapters = getNextChapters.await(manga.id)
                     .filterNot { chapter ->
                         downloadManager.queue.any { chapter.id == it.chapter.id } ||
                             downloadManager.isChapterDownloaded(

app/src/main/java/eu/kanade/tachiyomi/ui/main/MainActivity.kt

@@ -52,13 +52,13 @@ import eu.kanade.tachiyomi.ui.browse.BrowseController
 import eu.kanade.tachiyomi.ui.browse.source.browse.BrowseSourceController
 import eu.kanade.tachiyomi.ui.browse.source.globalsearch.GlobalSearchController
 import eu.kanade.tachiyomi.ui.download.DownloadController
+import eu.kanade.tachiyomi.ui.history.HistoryController
 import eu.kanade.tachiyomi.ui.library.LibraryController
 import eu.kanade.tachiyomi.ui.manga.MangaController
 import eu.kanade.tachiyomi.ui.more.MoreController
 import eu.kanade.tachiyomi.ui.more.NewUpdateDialogController
-import eu.kanade.tachiyomi.ui.recent.history.HistoryController
-import eu.kanade.tachiyomi.ui.recent.updates.UpdatesController
 import eu.kanade.tachiyomi.ui.setting.SettingsMainController
+import eu.kanade.tachiyomi.ui.updates.UpdatesController
 import eu.kanade.tachiyomi.util.lang.launchIO
 import eu.kanade.tachiyomi.util.lang.launchUI
 import eu.kanade.tachiyomi.util.preference.asHotFlow

app/src/main/java/eu/kanade/tachiyomi/ui/manga/MangaController.kt

@@ -40,6 +40,7 @@ import eu.kanade.tachiyomi.ui.browse.migration.search.SearchController
 import eu.kanade.tachiyomi.ui.browse.source.browse.BrowseSourceController
 import eu.kanade.tachiyomi.ui.browse.source.globalsearch.GlobalSearchController
 import eu.kanade.tachiyomi.ui.category.CategoryController
+import eu.kanade.tachiyomi.ui.history.HistoryController
 import eu.kanade.tachiyomi.ui.library.LibraryController
 import eu.kanade.tachiyomi.ui.main.MainActivity
 import eu.kanade.tachiyomi.ui.manga.MangaPresenter.Dialog
@@ -49,8 +50,7 @@ import eu.kanade.tachiyomi.ui.manga.track.TrackItem
 import eu.kanade.tachiyomi.ui.manga.track.TrackSearchDialog
 import eu.kanade.tachiyomi.ui.manga.track.TrackSheet
 import eu.kanade.tachiyomi.ui.reader.ReaderActivity
-import eu.kanade.tachiyomi.ui.recent.history.HistoryController
+import eu.kanade.tachiyomi.ui.updates.UpdatesController
-import eu.kanade.tachiyomi.ui.recent.updates.UpdatesController
 import eu.kanade.tachiyomi.ui.webview.WebViewActivity
 import eu.kanade.tachiyomi.util.system.isTabletUi
 import eu.kanade.tachiyomi.util.system.logcat

app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderPresenter.kt

@@ -11,7 +11,7 @@ import eu.kanade.domain.chapter.interactor.UpdateChapter
 import eu.kanade.domain.chapter.model.ChapterUpdate
 import eu.kanade.domain.chapter.model.toDbChapter
 import eu.kanade.domain.download.service.DownloadPreferences
-import eu.kanade.domain.history.interactor.GetNextUnreadChapters
+import eu.kanade.domain.history.interactor.GetNextChapters
 import eu.kanade.domain.history.interactor.UpsertHistory
 import eu.kanade.domain.history.model.HistoryUpdate
 import eu.kanade.domain.manga.interactor.GetManga
@@ -88,7 +88,7 @@ class ReaderPresenter(
     private val delayedTrackingStore: DelayedTrackingStore = Injekt.get(),
     private val getManga: GetManga = Injekt.get(),
     private val getChapterByMangaId: GetChapterByMangaId = Injekt.get(),
-    private val getNextUnreadChapters: GetNextUnreadChapters = Injekt.get(),
+    private val getNextChapters: GetNextChapters = Injekt.get(),
     private val getTracks: GetTracks = Injekt.get(),
     private val insertTrack: InsertTrack = Injekt.get(),
     private val upsertHistory: UpsertHistory = Injekt.get(),
@@ -475,7 +475,7 @@ class ReaderPresenter(
             )
             if (!isNextChapterDownloaded) return@launchIO
 
-            val chaptersToDownload = getNextUnreadChapters.await(manga.id!!, nextChapter.id!!)
+            val chaptersToDownload = getNextChapters.await(manga.id!!, nextChapter.id!!)
                 .take(amount)
             downloadManager.downloadChapters(
                 manga.toDomainManga()!!,

app/src/main/java/eu/kanade/tachiyomi/ui/updates/UpdatesController.kt

@@ -1,4 +1,4 @@
-package eu.kanade.tachiyomi.ui.recent.updates
+package eu.kanade.tachiyomi.ui.updates
 
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
@@ -26,6 +26,7 @@ class UpdatesController :
                 (activity as? MainActivity)?.moveToStartScreen()
             },
         )
+
         LaunchedEffect(presenter.selectionMode) {
             (activity as? MainActivity)?.showBottomNav(presenter.selectionMode.not())
         }

app/src/main/java/eu/kanade/tachiyomi/ui/updates/UpdatesPresenter.kt

@@ -1,4 +1,4 @@
-package eu.kanade.tachiyomi.ui.recent.updates
+package eu.kanade.tachiyomi.ui.updates
 
 import android.os.Bundle
 import androidx.compose.runtime.Immutable
@@ -47,13 +47,13 @@ import java.util.Date
 
 class UpdatesPresenter(
     private val state: UpdatesStateImpl = UpdatesState() as UpdatesStateImpl,
+    private val sourceManager: SourceManager = Injekt.get(),
+    private val downloadManager: DownloadManager = Injekt.get(),
+    private val downloadCache: DownloadCache = Injekt.get(),
     private val updateChapter: UpdateChapter = Injekt.get(),
     private val setReadStatus: SetReadStatus = Injekt.get(),
     private val getUpdates: GetUpdates = Injekt.get(),
     private val getManga: GetManga = Injekt.get(),
-    private val sourceManager: SourceManager = Injekt.get(),
-    private val downloadManager: DownloadManager = Injekt.get(),
-    private val downloadCache: DownloadCache = Injekt.get(),
     private val getChapter: GetChapter = Injekt.get(),
     basePreferences: BasePreferences = Injekt.get(),
     uiPreferences: UiPreferences = Injekt.get(),