Clean up reading mode / orientation enum classes

Categorizing the reading modes so we can implement a better
selection UI.

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

@@ -44,7 +44,7 @@ import dev.chrisbanes.insetter.applyInsetter
 import eu.kanade.domain.base.BasePreferences
 import eu.kanade.presentation.reader.BrightnessOverlay
 import eu.kanade.presentation.reader.DisplayRefreshHost
-import eu.kanade.presentation.reader.OrientationModeSelectDialog
+import eu.kanade.presentation.reader.OrientationSelectDialog
 import eu.kanade.presentation.reader.PageIndicatorText
 import eu.kanade.presentation.reader.ReaderPageActionsDialog
 import eu.kanade.presentation.reader.ReadingModeSelectDialog
@@ -63,10 +63,10 @@ import eu.kanade.tachiyomi.ui.reader.ReaderViewModel.SetAsCoverResult.Success
 import eu.kanade.tachiyomi.ui.reader.model.ReaderChapter
 import eu.kanade.tachiyomi.ui.reader.model.ReaderPage
 import eu.kanade.tachiyomi.ui.reader.model.ViewerChapters
-import eu.kanade.tachiyomi.ui.reader.setting.OrientationType
+import eu.kanade.tachiyomi.ui.reader.setting.ReaderOrientation
 import eu.kanade.tachiyomi.ui.reader.setting.ReaderPreferences
 import eu.kanade.tachiyomi.ui.reader.setting.ReaderSettingsScreenModel
-import eu.kanade.tachiyomi.ui.reader.setting.ReadingModeType
+import eu.kanade.tachiyomi.ui.reader.setting.ReadingMode
 import eu.kanade.tachiyomi.ui.reader.viewer.ReaderProgressIndicator
 import eu.kanade.tachiyomi.ui.webview.WebViewActivity
 import eu.kanade.tachiyomi.util.system.hasDisplayCutout
@@ -332,7 +332,7 @@ class ReaderActivity : BaseActivity() {
 
             val cropBorderPaged by readerPreferences.cropBorders().collectAsState()
             val cropBorderWebtoon by readerPreferences.cropBordersWebtoon().collectAsState()
-            val isPagerType = ReadingModeType.isPagerType(viewModel.getMangaReadingMode())
+            val isPagerType = ReadingMode.isPagerType(viewModel.getMangaReadingMode())
             val cropEnabled = if (isPagerType) cropBorderPaged else cropBorderWebtoon
 
             ReaderAppBars(
@@ -360,14 +360,14 @@ class ReaderActivity : BaseActivity() {
                     moveToPageIndex(it)
                 },
 
-                readingMode = ReadingModeType.fromPreference(
+                readingMode = ReadingMode.fromPreference(
                     viewModel.getMangaReadingMode(resolveDefault = false),
                 ),
                 onClickReadingMode = viewModel::openReadingModeSelectDialog,
-                orientationMode = OrientationType.fromPreference(
-                    viewModel.getMangaOrientationType(resolveDefault = false),
+                orientation = ReaderOrientation.fromPreference(
+                    viewModel.getMangaOrientation(resolveDefault = false),
                 ),
-                onClickOrientationMode = viewModel::openOrientationModeSelectDialog,
+                onClickOrientation = viewModel::openOrientationModeSelectDialog,
                 cropEnabled = cropEnabled,
                 onClickCropBorder = {
                     val enabled = viewModel.toggleCropBorders()
@@ -425,7 +425,7 @@ class ReaderActivity : BaseActivity() {
                     )
                 }
                 is ReaderViewModel.Dialog.OrientationModeSelect -> {
-                    OrientationModeSelectDialog(
+                    OrientationSelectDialog(
                         onDismissRequest = onDismissRequest,
                         screenModel = settingsScreenModel,
                         onChange = { stringRes ->
@@ -482,15 +482,15 @@ class ReaderActivity : BaseActivity() {
      */
     private fun setManga(manga: Manga) {
         val prevViewer = viewModel.state.value.viewer
-        val newViewer = ReadingModeType.toViewer(viewModel.getMangaReadingMode(), this)
+        val newViewer = ReadingMode.toViewer(viewModel.getMangaReadingMode(), this)
 
         if (window.sharedElementEnterTransition is MaterialContainerTransform) {
             // Wait until transition is complete to avoid crash on API 26
             window.sharedElementEnterTransition.doOnEnd {
-                setOrientation(viewModel.getMangaOrientationType())
+                setOrientation(viewModel.getMangaOrientation())
             }
         } else {
-            setOrientation(viewModel.getMangaOrientationType())
+            setOrientation(viewModel.getMangaOrientation())
         }
 
         // Destroy previous viewer if there was one
@@ -543,7 +543,7 @@ class ReaderActivity : BaseActivity() {
     private fun showReadingModeToast(mode: Int) {
         try {
             readingModeToast?.cancel()
-            readingModeToast = toast(ReadingModeType.fromPreference(mode).stringRes)
+            readingModeToast = toast(ReadingMode.fromPreference(mode).stringRes)
         } catch (e: ArrayIndexOutOfBoundsException) {
             logcat(LogPriority.ERROR) { "Unknown reading mode: $mode" }
         }
@@ -721,7 +721,7 @@ class ReaderActivity : BaseActivity() {
      * Forces the user preferred [orientation] on the activity.
      */
     private fun setOrientation(orientation: Int) {
-        val newOrientation = OrientationType.fromPreference(orientation)
+        val newOrientation = ReaderOrientation.fromPreference(orientation)
         if (newOrientation.flag != requestedOrientation) {
             requestedOrientation = newOrientation.flag
         }

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

@@ -10,8 +10,8 @@ import androidx.lifecycle.viewModelScope
 import eu.kanade.domain.base.BasePreferences
 import eu.kanade.domain.chapter.model.toDbChapter
 import eu.kanade.domain.manga.interactor.SetMangaViewerFlags
-import eu.kanade.domain.manga.model.orientationType
-import eu.kanade.domain.manga.model.readingModeType
+import eu.kanade.domain.manga.model.readerOrientation
+import eu.kanade.domain.manga.model.readingMode
 import eu.kanade.domain.track.interactor.TrackChapter
 import eu.kanade.domain.track.service.TrackPreferences
 import eu.kanade.tachiyomi.data.database.models.toDomainChapter
@@ -29,9 +29,9 @@ import eu.kanade.tachiyomi.ui.reader.model.InsertPage
 import eu.kanade.tachiyomi.ui.reader.model.ReaderChapter
 import eu.kanade.tachiyomi.ui.reader.model.ReaderPage
 import eu.kanade.tachiyomi.ui.reader.model.ViewerChapters
-import eu.kanade.tachiyomi.ui.reader.setting.OrientationType
+import eu.kanade.tachiyomi.ui.reader.setting.ReaderOrientation
 import eu.kanade.tachiyomi.ui.reader.setting.ReaderPreferences
-import eu.kanade.tachiyomi.ui.reader.setting.ReadingModeType
+import eu.kanade.tachiyomi.ui.reader.setting.ReadingMode
 import eu.kanade.tachiyomi.ui.reader.viewer.Viewer
 import eu.kanade.tachiyomi.util.chapter.filterDownloaded
 import eu.kanade.tachiyomi.util.chapter.removeDuplicates
@@ -630,20 +630,20 @@ class ReaderViewModel @JvmOverloads constructor(
      */
     fun getMangaReadingMode(resolveDefault: Boolean = true): Int {
         val default = readerPreferences.defaultReadingMode().get()
-        val readingMode = ReadingModeType.fromPreference(manga?.readingModeType?.toInt())
+        val readingMode = ReadingMode.fromPreference(manga?.readingMode?.toInt())
         return when {
-            resolveDefault && readingMode == ReadingModeType.DEFAULT -> default
-            else -> manga?.readingModeType?.toInt() ?: default
+            resolveDefault && readingMode == ReadingMode.DEFAULT -> default
+            else -> manga?.readingMode?.toInt() ?: default
         }
     }
 
     /**
      * Updates the viewer position for the open manga.
      */
-    fun setMangaReadingMode(readingModeType: ReadingModeType) {
+    fun setMangaReadingMode(readingMode: ReadingMode) {
         val manga = manga ?: return
         runBlocking(Dispatchers.IO) {
-            setMangaViewerFlags.awaitSetReadingMode(manga.id, readingModeType.flagValue.toLong())
+            setMangaViewerFlags.awaitSetReadingMode(manga.id, readingMode.flagValue.toLong())
             val currChapters = state.value.viewerChapters
             if (currChapters != null) {
                 // Save current page
@@ -664,22 +664,22 @@ class ReaderViewModel @JvmOverloads constructor(
     /**
      * Returns the orientation type used by this manga or the default one.
      */
-    fun getMangaOrientationType(resolveDefault: Boolean = true): Int {
+    fun getMangaOrientation(resolveDefault: Boolean = true): Int {
         val default = readerPreferences.defaultOrientationType().get()
-        val orientation = OrientationType.fromPreference(manga?.orientationType?.toInt())
+        val orientation = ReaderOrientation.fromPreference(manga?.readerOrientation?.toInt())
         return when {
-            resolveDefault && orientation == OrientationType.DEFAULT -> default
-            else -> manga?.orientationType?.toInt() ?: default
+            resolveDefault && orientation == ReaderOrientation.DEFAULT -> default
+            else -> manga?.readerOrientation?.toInt() ?: default
         }
     }
 
     /**
      * Updates the orientation type for the open manga.
      */
-    fun setMangaOrientationType(rotationType: OrientationType) {
+    fun setMangaOrientationType(orientation: ReaderOrientation) {
         val manga = manga ?: return
         viewModelScope.launchIO {
-            setMangaViewerFlags.awaitSetOrientation(manga.id, rotationType.flagValue.toLong())
+            setMangaViewerFlags.awaitSetOrientation(manga.id, orientation.flagValue.toLong())
             val currChapters = state.value.viewerChapters
             if (currChapters != null) {
                 // Save current page
@@ -692,14 +692,14 @@ class ReaderViewModel @JvmOverloads constructor(
                         viewerChapters = currChapters,
                     )
                 }
-                eventChannel.send(Event.SetOrientation(getMangaOrientationType()))
+                eventChannel.send(Event.SetOrientation(getMangaOrientation()))
                 eventChannel.send(Event.ReloadViewerChapters)
             }
         }
     }
 
     fun toggleCropBorders(): Boolean {
-        val isPagerType = ReadingModeType.isPagerType(getMangaReadingMode())
+        val isPagerType = ReadingMode.isPagerType(getMangaReadingMode())
         return if (isPagerType) {
             readerPreferences.cropBorders().toggle()
         } else {

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

@@ -5,7 +5,7 @@ import androidx.annotation.DrawableRes
 import androidx.annotation.StringRes
 import eu.kanade.tachiyomi.R
 
-enum class OrientationType(
+enum class ReaderOrientation(
     val flag: Int,
     @StringRes val stringRes: Int,
     @DrawableRes val iconRes: Int,
@@ -58,6 +58,6 @@ enum class OrientationType(
     companion object {
         const val MASK = 0x00000038
 
-        fun fromPreference(preference: Int?): OrientationType = entries.find { it.flagValue == preference } ?: DEFAULT
+        fun fromPreference(preference: Int?): ReaderOrientation = entries.find { it.flagValue == preference } ?: DEFAULT
     }
 }

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

@@ -32,12 +32,12 @@ class ReaderPreferences(
 
     fun defaultReadingMode() = preferenceStore.getInt(
         "pref_default_reading_mode_key",
-        ReadingModeType.RIGHT_TO_LEFT.flagValue,
+        ReadingMode.RIGHT_TO_LEFT.flagValue,
     )
 
     fun defaultOrientationType() = preferenceStore.getInt(
         "pref_default_orientation_type_key",
-        OrientationType.FREE.flagValue,
+        ReaderOrientation.FREE.flagValue,
     )
 
     fun webtoonDoubleTapZoomEnabled() = preferenceStore.getBoolean("pref_enable_double_tap_zoom_webtoon", true)

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

@@ -14,8 +14,8 @@ import uy.kohesive.injekt.api.get
 class ReaderSettingsScreenModel(
     readerState: StateFlow<ReaderViewModel.State>,
     val hasDisplayCutout: Boolean,
-    val onChangeReadingMode: (ReadingModeType) -> Unit,
-    val onChangeOrientation: (OrientationType) -> Unit,
+    val onChangeReadingMode: (ReadingMode) -> Unit,
+    val onChangeOrientation: (ReaderOrientation) -> Unit,
     val preferences: ReaderPreferences = Injekt.get(),
 ) : ScreenModel {
 

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

@@ -10,27 +10,59 @@ import eu.kanade.tachiyomi.ui.reader.viewer.pager.R2LPagerViewer
 import eu.kanade.tachiyomi.ui.reader.viewer.pager.VerticalPagerViewer
 import eu.kanade.tachiyomi.ui.reader.viewer.webtoon.WebtoonViewer
 
-enum class ReadingModeType(
+enum class ReadingMode(
     @StringRes val stringRes: Int,
     @DrawableRes val iconRes: Int,
     val flagValue: Int,
+    val direction: Direction? = null,
+    val type: ViewerType? = null,
 ) {
     DEFAULT(R.string.label_default, R.drawable.ic_reader_default_24dp, 0x00000000),
-    LEFT_TO_RIGHT(R.string.left_to_right_viewer, R.drawable.ic_reader_ltr_24dp, 0x00000001),
-    RIGHT_TO_LEFT(R.string.right_to_left_viewer, R.drawable.ic_reader_rtl_24dp, 0x00000002),
-    VERTICAL(R.string.vertical_viewer, R.drawable.ic_reader_vertical_24dp, 0x00000003),
-    WEBTOON(R.string.webtoon_viewer, R.drawable.ic_reader_webtoon_24dp, 0x00000004),
-    CONTINUOUS_VERTICAL(R.string.vertical_plus_viewer, R.drawable.ic_reader_continuous_vertical_24dp, 0x00000005),
+    LEFT_TO_RIGHT(
+        R.string.left_to_right_viewer,
+        R.drawable.ic_reader_ltr_24dp,
+        0x00000001,
+        Direction.Horizontal,
+        ViewerType.Pager,
+    ),
+    RIGHT_TO_LEFT(
+        R.string.right_to_left_viewer,
+        R.drawable.ic_reader_rtl_24dp,
+        0x00000002,
+        Direction.Horizontal,
+        ViewerType.Pager,
+    ),
+    VERTICAL(
+        R.string.vertical_viewer,
+        R.drawable.ic_reader_vertical_24dp,
+        0x00000003,
+        Direction.Vertical,
+        ViewerType.Pager,
+    ),
+    WEBTOON(
+        R.string.webtoon_viewer,
+        R.drawable.ic_reader_webtoon_24dp,
+        0x00000004,
+        Direction.Vertical,
+        ViewerType.Webtoon,
+    ),
+    CONTINUOUS_VERTICAL(
+        R.string.vertical_plus_viewer,
+        R.drawable.ic_reader_continuous_vertical_24dp,
+        0x00000005,
+        Direction.Vertical,
+        ViewerType.Webtoon,
+    ),
     ;
 
     companion object {
         const val MASK = 0x00000007
 
-        fun fromPreference(preference: Int?): ReadingModeType = entries.find { it.flagValue == preference } ?: DEFAULT
+        fun fromPreference(preference: Int?): ReadingMode = entries.find { it.flagValue == preference } ?: DEFAULT
 
         fun isPagerType(preference: Int): Boolean {
             val mode = fromPreference(preference)
-            return mode == LEFT_TO_RIGHT || mode == RIGHT_TO_LEFT || mode == VERTICAL
+            return mode.type is ViewerType.Pager
         }
 
         fun toViewer(preference: Int?, activity: ReaderActivity): Viewer {
@@ -44,4 +76,14 @@ enum class ReadingModeType(
             }
         }
     }
+
+    sealed interface Direction {
+        data object Horizontal : Direction
+        data object Vertical : Direction
+    }
+
+    sealed interface ViewerType {
+        data object Pager : ViewerType
+        data object Webtoon : ViewerType
+    }
 }