Cleanup related to fetch interval display

app/src/main/java/eu/kanade/tachiyomi/data/backup/BackupRestorer.kt

@@ -14,7 +14,7 @@ import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.isActive
 import tachiyomi.domain.chapter.model.Chapter
 import tachiyomi.domain.chapter.repository.ChapterRepository
-import tachiyomi.domain.manga.interactor.SetMangaUpdateInterval
+import tachiyomi.domain.manga.interactor.SetFetchInterval
 import tachiyomi.domain.manga.model.Manga
 import tachiyomi.domain.track.model.Track
 import uy.kohesive.injekt.Injekt
@@ -31,10 +31,10 @@ class BackupRestorer(
 ) {
     private val updateManga: UpdateManga = Injekt.get()
     private val chapterRepository: ChapterRepository = Injekt.get()
-    private val setMangaUpdateInterval: SetMangaUpdateInterval = Injekt.get()
+    private val setFetchInterval: SetFetchInterval = Injekt.get()
 
     private var zonedDateTime = ZonedDateTime.now()
-    private var currentRange = setMangaUpdateInterval.getCurrentFetchRange(zonedDateTime)
+    private var currentFetchInterval = setFetchInterval.getCurrent(zonedDateTime)
 
     private var backupManager = BackupManager(context)
 
@@ -103,7 +103,7 @@ class BackupRestorer(
         val backupMaps = backup.backupBrokenSources.map { BackupSource(it.name, it.sourceId) } + backup.backupSources
         sourceMapping = backupMaps.associate { it.sourceId to it.name }
         zonedDateTime = ZonedDateTime.now()
-        currentRange = setMangaUpdateInterval.getCurrentFetchRange(zonedDateTime)
+        currentFetchInterval = setFetchInterval.getCurrent(zonedDateTime)
 
         return coroutineScope {
             // Restore individual manga
@@ -147,7 +147,7 @@ class BackupRestorer(
                 restoreNewManga(updatedManga, chapters, categories, history, tracks, backupCategories)
             }
             val updatedChapters = chapterRepository.getChapterByMangaId(restoredManga.id)
-            updateManga.awaitUpdateFetchInterval(restoredManga, updatedChapters, zonedDateTime, currentRange)
+            updateManga.awaitUpdateFetchInterval(restoredManga, updatedChapters, zonedDateTime, currentFetchInterval)
         } catch (e: Exception) {
             val sourceName = sourceMapping[manga.source] ?: manga.source.toString()
             errors.add(Date() to "${manga.title} [$sourceName]: ${e.message}")

app/src/main/java/eu/kanade/tachiyomi/data/library/LibraryUpdateJob.kt

@@ -69,7 +69,7 @@ import tachiyomi.domain.library.service.LibraryPreferences.Companion.MANGA_NON_R
 import tachiyomi.domain.library.service.LibraryPreferences.Companion.MANGA_OUTSIDE_RELEASE_PERIOD
 import tachiyomi.domain.manga.interactor.GetLibraryManga
 import tachiyomi.domain.manga.interactor.GetManga
-import tachiyomi.domain.manga.interactor.SetMangaUpdateInterval
+import tachiyomi.domain.manga.interactor.SetFetchInterval
 import tachiyomi.domain.manga.model.Manga
 import tachiyomi.domain.manga.model.toMangaUpdate
 import tachiyomi.domain.source.model.SourceNotInstalledException
@@ -104,7 +104,7 @@ class LibraryUpdateJob(private val context: Context, workerParams: WorkerParamet
     private val getTracks: GetTracks = Injekt.get()
     private val insertTrack: InsertTrack = Injekt.get()
     private val syncChaptersWithTrackServiceTwoWay: SyncChaptersWithTrackServiceTwoWay = Injekt.get()
-    private val setMangaUpdateInterval: SetMangaUpdateInterval = Injekt.get()
+    private val setFetchInterval: SetFetchInterval = Injekt.get()
 
     private val notifier = LibraryUpdateNotifier(context)
 
@@ -232,8 +232,8 @@ class LibraryUpdateJob(private val context: Context, workerParams: WorkerParamet
         val restrictions = libraryPreferences.libraryUpdateMangaRestriction().get()
 
         val now = ZonedDateTime.now()
-        val fetchRange = setMangaUpdateInterval.getCurrentFetchRange(now)
-        val higherLimit = fetchRange.second
+        val fetchInterval = setFetchInterval.getCurrent(now)
+        val higherLimit = fetchInterval.second
 
         coroutineScope {
             mangaToUpdate.groupBy { it.manga.source }.values
@@ -272,7 +272,7 @@ class LibraryUpdateJob(private val context: Context, workerParams: WorkerParamet
 
                                         else -> {
                                             try {
-                                                val newChapters = updateManga(manga, now, fetchRange)
+                                                val newChapters = updateManga(manga, now, fetchInterval)
                                                     .sortedByDescending { it.sourceOrder }
 
                                                 if (newChapters.isNotEmpty()) {

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

@@ -83,6 +83,13 @@ class MangaScreen(
 
         val successState = state as MangaScreenModel.State.Success
         val isHttpSource = remember { successState.source is HttpSource }
+        val fetchInterval = remember(successState.manga.fetchInterval) {
+            FetchInterval(
+                interval = successState.manga.fetchInterval,
+                leadDays = screenModel.leadDay,
+                followDays = screenModel.followDay,
+            )
+        }
 
         LaunchedEffect(successState.manga, screenModel.source) {
             if (isHttpSource) {
@@ -100,7 +107,7 @@ class MangaScreen(
             state = successState,
             snackbarHostState = screenModel.snackbarHostState,
             dateFormat = screenModel.dateFormat,
-            intervalDisplay = screenModel::intervalDisplay,
+            fetchInterval = fetchInterval,
             isTabletUi = isTabletUi(),
             chapterSwipeStartAction = screenModel.chapterSwipeStartAction,
             chapterSwipeEndAction = screenModel.chapterSwipeEndAction,
@@ -123,7 +130,7 @@ class MangaScreen(
             onShareClicked = { shareManga(context, screenModel.manga, screenModel.source) }.takeIf { isHttpSource },
             onDownloadActionClicked = screenModel::runDownloadAction.takeIf { !successState.source.isLocalOrStub() },
             onEditCategoryClicked = screenModel::showChangeCategoryDialog.takeIf { successState.manga.favorite },
-            onEditIntervalClicked = screenModel::showSetMangaIntervalDialog.takeIf { screenModel.isIntervalEnabled && successState.manga.favorite },
+            onEditFetchIntervalClicked = screenModel::showSetFetchIntervalDialog.takeIf { screenModel.isUpdateIntervalEnabled && successState.manga.favorite },
             onMigrateClicked = { navigator.push(MigrateSearchScreen(successState.manga.id)) }.takeIf { successState.manga.favorite },
             onMultiBookmarkClicked = screenModel::bookmarkChapters,
             onMultiMarkAsReadClicked = screenModel::markChaptersRead,
@@ -209,11 +216,11 @@ class MangaScreen(
                     LoadingScreen(Modifier.systemBarsPadding())
                 }
             }
-            is MangaScreenModel.Dialog.SetMangaInterval -> {
+            is MangaScreenModel.Dialog.SetFetchInterval -> {
                 SetIntervalDialog(
-                    interval = if (dialog.manga.calculateInterval < 0) -dialog.manga.calculateInterval else 0,
+                    interval = if (dialog.manga.fetchInterval < 0) -dialog.manga.fetchInterval else 0,
                     onDismissRequest = onDismissRequest,
-                    onValueChanged = { screenModel.setFetchRangeInterval(dialog.manga, it) },
+                    onValueChanged = { screenModel.setFetchInterval(dialog.manga, it) },
                 )
             }
         }

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

@@ -75,7 +75,6 @@ import tachiyomi.domain.track.interactor.GetTracks
 import tachiyomi.source.local.isLocal
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
-import kotlin.math.absoluteValue
 
 class MangaScreenModel(
     val context: Context,
@@ -129,9 +128,9 @@ class MangaScreenModel(
     val dateFormat by mutableStateOf(UiPreferences.dateFormat(uiPreferences.dateFormat().get()))
     private val skipFiltered by readerPreferences.skipFiltered().asState(coroutineScope)
 
-    val isIntervalEnabled = LibraryPreferences.MANGA_OUTSIDE_RELEASE_PERIOD in libraryPreferences.libraryUpdateMangaRestriction().get()
-    private val leadDay = libraryPreferences.leadingExpectedDays().get()
-    private val followDay = libraryPreferences.followingExpectedDays().get()
+    val isUpdateIntervalEnabled = LibraryPreferences.MANGA_OUTSIDE_RELEASE_PERIOD in libraryPreferences.libraryUpdateMangaRestriction().get()
+    val leadDay = libraryPreferences.leadingExpectedDays().get()
+    val followDay = libraryPreferences.followingExpectedDays().get()
 
     private val selectedPositions: Array<Int> = arrayOf(-1, -1) // first and last selected index in list
     private val selectedChapterIds: HashSet<Long> = HashSet()
@@ -355,30 +354,23 @@ class MangaScreenModel(
         }
     }
 
-    fun showSetMangaIntervalDialog() {
+    fun showSetFetchIntervalDialog() {
         val manga = successState?.manga ?: return
         updateSuccessState {
-            it.copy(dialog = Dialog.SetMangaInterval(manga))
+            it.copy(dialog = Dialog.SetFetchInterval(manga))
         }
     }
 
-    // TODO: this should be in the state/composables
-    fun intervalDisplay(): Pair<Int, Int>? {
-        val manga = successState?.manga ?: return null
-        val effInterval = manga.calculateInterval
-        return 1.coerceAtLeast(effInterval.absoluteValue - leadDay) to (effInterval.absoluteValue + followDay)
-    }
-
-    fun setFetchRangeInterval(manga: Manga, newInterval: Int) {
+    fun setFetchInterval(manga: Manga, newInterval: Int) {
         val interval = when (newInterval) {
             // reset interval 0 default to trigger recalculation
             // only reset if interval is custom, which is negative
-            0 -> if (manga.calculateInterval < 0) 0 else manga.calculateInterval
+            0 -> if (manga.fetchInterval < 0) 0 else manga.fetchInterval
             else -> -newInterval
         }
         coroutineScope.launchIO {
             updateManga.awaitUpdateFetchInterval(
-                manga.copy(calculateInterval = interval),
+                manga.copy(fetchInterval = interval),
                 successState?.chapters?.map { it.chapter }.orEmpty(),
             )
             val newManga = mangaRepository.getMangaById(mangaId)
@@ -983,7 +975,7 @@ class MangaScreenModel(
         data class ChangeCategory(val manga: Manga, val initialSelection: List<CheckboxState<Category>>) : Dialog
         data class DeleteChapters(val chapters: List<Chapter>) : Dialog
         data class DuplicateManga(val manga: Manga, val duplicate: Manga) : Dialog
-        data class SetMangaInterval(val manga: Manga) : Dialog
+        data class SetFetchInterval(val manga: Manga) : Dialog
         data object SettingsSheet : Dialog
         data object TrackSheet : Dialog
         data object FullCover : Dialog
@@ -1063,3 +1055,10 @@ data class ChapterItem(
 ) {
     val isDownloaded = downloadState == Download.State.DOWNLOADED
 }
+
+@Immutable
+data class FetchInterval(
+    val interval: Int,
+    val leadDays: Int,
+    val followDays: Int,
+)