diff --git a/app/build.gradle.kts b/app/build.gradle.kts index 8713b176e..1dd75028d 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -34,7 +34,7 @@ android { minSdkVersion(AndroidConfig.minSdk) targetSdkVersion(AndroidConfig.targetSdk) testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" - versionCode = 16 + versionCode = 17 versionName = "1.6.2" buildConfigField("String", "COMMIT_COUNT", "\"${getCommitCount()}\"") diff --git a/app/src/main/java/eu/kanade/tachiyomi/Migrations.kt b/app/src/main/java/eu/kanade/tachiyomi/Migrations.kt index 48874afd2..753ae2ab8 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/Migrations.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/Migrations.kt @@ -12,6 +12,7 @@ import eu.kanade.tachiyomi.data.updater.UpdaterJob import eu.kanade.tachiyomi.extension.ExtensionUpdateJob import eu.kanade.tachiyomi.network.PREF_DOH_CLOUDFLARE import eu.kanade.tachiyomi.ui.library.LibrarySort +import eu.kanade.tachiyomi.ui.reader.setting.OrientationType import eu.kanade.tachiyomi.util.system.toast import eu.kanade.tachiyomi.widget.ExtendedNavigationView import uy.kohesive.injekt.Injekt @@ -144,13 +145,40 @@ object Migrations { } if (oldVersion < 59) { // Reset rotation to Free after replacing Lock - preferences.rotation().set(1) + val prefs = PreferenceManager.getDefaultSharedPreferences(context) + if (prefs.contains("pref_rotation_type_key")) { + prefs.edit { + putInt("pref_rotation_type_key", 1) + } + } // Disable update check for Android 5.x users if (BuildConfig.INCLUDE_UPDATER && Build.VERSION.SDK_INT <= Build.VERSION_CODES.M) { UpdaterJob.cancelTask(context) } } + if (oldVersion < 60) { + // Migrate Rotation and Viewer values to default values for viewer_flags + val prefs = PreferenceManager.getDefaultSharedPreferences(context) + val newOrientation = when (prefs.getInt("pref_rotation_type_key", 1)) { + 1 -> OrientationType.FREE.flagValue + 2 -> OrientationType.PORTRAIT.flagValue + 3 -> OrientationType.LANDSCAPE.flagValue + 4 -> OrientationType.LOCKED_PORTRAIT.flagValue + 5 -> OrientationType.LOCKED_LANDSCAPE.flagValue + else -> OrientationType.FREE.flagValue + } + + // Reading mode flag and prefValue is the same value + val newReadingMode = prefs.getInt("pref_default_viewer_key", 1) + + prefs.edit { + putInt("pref_default_orientation_type_key", newOrientation) + remove("pref_rotation_type_key") + putInt("pref_default_reading_mode_key", newReadingMode) + remove("pref_default_viewer_key") + } + } return true } diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/backup/full/models/BackupManga.kt b/app/src/main/java/eu/kanade/tachiyomi/data/backup/full/models/BackupManga.kt index 4981d24c0..edf225609 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/full/models/BackupManga.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/full/models/BackupManga.kt @@ -26,7 +26,7 @@ data class BackupManga( // @ProtoNumber(11) val lastUpdate: Long = 0, 1.x value, not used in 0.x // @ProtoNumber(12) val lastInit: Long = 0, 1.x value, not used in 0.x @ProtoNumber(13) var dateAdded: Long = 0, - @ProtoNumber(14) var viewer: Int = 0, + @ProtoNumber(14) var viewer: Int = 0, // Replaced by viewer_flags // @ProtoNumber(15) val flags: Int = 0, 1.x value, not used in 0.x @ProtoNumber(16) var chapters: List = emptyList(), @ProtoNumber(17) var categories: List = emptyList(), @@ -35,6 +35,8 @@ data class BackupManga( @ProtoNumber(100) var favorite: Boolean = true, @ProtoNumber(101) var chapterFlags: Int = 0, @ProtoNumber(102) var history: List = emptyList(), + @ProtoNumber(103) var viewer_flags: Int? = null, + // SY specific values @ProtoNumber(600) var mergedMangaReferences: List = emptyList(), @ProtoNumber(601) var flatMetadata: BackupFlatMetadata? = null, @@ -60,7 +62,7 @@ data class BackupManga( favorite = this@BackupManga.favorite source = this@BackupManga.source date_added = this@BackupManga.dateAdded - viewer = this@BackupManga.viewer + viewer_flags = this@BackupManga.viewer_flags ?: this@BackupManga.viewer chapter_flags = this@BackupManga.chapterFlags } } @@ -116,7 +118,8 @@ data class BackupManga( favorite = manga.favorite, source = manga.source, dateAdded = manga.date_added, - viewer = manga.viewer, + viewer = manga.readingModeType, + viewer_flags = manga.viewer_flags, chapterFlags = manga.chapter_flags // SY --> ).also { backupManga -> diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/backup/legacy/serializer/MangaTypeAdapter.kt b/app/src/main/java/eu/kanade/tachiyomi/data/backup/legacy/serializer/MangaTypeAdapter.kt index f124f482b..6fb57c16f 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/legacy/serializer/MangaTypeAdapter.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/legacy/serializer/MangaTypeAdapter.kt @@ -18,7 +18,7 @@ object MangaTypeAdapter { value(it.originalTitle) // SY <-- value(it.source) - value(it.viewer) + value(it.viewer_flags) value(it.chapter_flags) endArray() } @@ -29,7 +29,7 @@ object MangaTypeAdapter { manga.url = nextString() manga.title = nextString() manga.source = nextLong() - manga.viewer = nextInt() + manga.viewer_flags = nextInt() manga.chapter_flags = nextInt() endArray() manga diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/database/mappers/MangaTypeMapping.kt b/app/src/main/java/eu/kanade/tachiyomi/data/database/mappers/MangaTypeMapping.kt index da256eac9..d15e2fd10 100755 --- a/app/src/main/java/eu/kanade/tachiyomi/data/database/mappers/MangaTypeMapping.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/database/mappers/MangaTypeMapping.kt @@ -65,7 +65,7 @@ class MangaPutResolver : DefaultPutResolver() { COL_FAVORITE to obj.favorite, COL_LAST_UPDATE to obj.last_update, COL_INITIALIZED to obj.initialized, - COL_VIEWER to obj.viewer, + COL_VIEWER to obj.viewer_flags, COL_CHAPTER_FLAGS to obj.chapter_flags, COL_COVER_LAST_MODIFIED to obj.cover_last_modified, COL_DATE_ADDED to obj.date_added @@ -87,7 +87,7 @@ interface BaseMangaGetResolver { favorite = cursor.getInt(cursor.getColumnIndex(COL_FAVORITE)) == 1 last_update = cursor.getLong(cursor.getColumnIndex(COL_LAST_UPDATE)) initialized = cursor.getInt(cursor.getColumnIndex(COL_INITIALIZED)) == 1 - viewer = cursor.getInt(cursor.getColumnIndex(COL_VIEWER)) + viewer_flags = cursor.getInt(cursor.getColumnIndex(COL_VIEWER)) chapter_flags = cursor.getInt(cursor.getColumnIndex(COL_CHAPTER_FLAGS)) cover_last_modified = cursor.getLong(cursor.getColumnIndex(COL_COVER_LAST_MODIFIED)) date_added = cursor.getLong(cursor.getColumnIndex(COL_DATE_ADDED)) diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/database/models/Manga.kt b/app/src/main/java/eu/kanade/tachiyomi/data/database/models/Manga.kt index 11587bbfd..2e78150ac 100755 --- a/app/src/main/java/eu/kanade/tachiyomi/data/database/models/Manga.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/database/models/Manga.kt @@ -1,6 +1,8 @@ package eu.kanade.tachiyomi.data.database.models import eu.kanade.tachiyomi.source.model.SManga +import eu.kanade.tachiyomi.ui.reader.setting.OrientationType +import eu.kanade.tachiyomi.ui.reader.setting.ReadingModeType import tachiyomi.source.model.MangaInfo interface Manga : SManga { @@ -15,18 +17,18 @@ interface Manga : SManga { var date_added: Long - var viewer: Int + var viewer_flags: Int var chapter_flags: Int var cover_last_modified: Long fun setChapterOrder(order: Int) { - setFlags(order, SORT_MASK) + setChapterFlags(order, CHAPTER_SORT_MASK) } fun sortDescending(): Boolean { - return chapter_flags and SORT_MASK == SORT_DESC + return chapter_flags and CHAPTER_SORT_MASK == CHAPTER_SORT_DESC } fun getGenres(): List? { @@ -39,60 +41,72 @@ interface Manga : SManga { } // SY <-- - private fun setFlags(flag: Int, mask: Int) { + private fun setChapterFlags(flag: Int, mask: Int) { chapter_flags = chapter_flags and mask.inv() or (flag and mask) } + private fun setViewerFlags(flag: Int, mask: Int) { + viewer_flags = viewer_flags and mask.inv() or (flag and mask) + } + // Used to display the chapter's title one way or another var displayMode: Int - get() = chapter_flags and DISPLAY_MASK - set(mode) = setFlags(mode, DISPLAY_MASK) + get() = chapter_flags and CHAPTER_DISPLAY_MASK + set(mode) = setChapterFlags(mode, CHAPTER_DISPLAY_MASK) var readFilter: Int - get() = chapter_flags and READ_MASK - set(filter) = setFlags(filter, READ_MASK) + get() = chapter_flags and CHAPTER_READ_MASK + set(filter) = setChapterFlags(filter, CHAPTER_READ_MASK) var downloadedFilter: Int - get() = chapter_flags and DOWNLOADED_MASK - set(filter) = setFlags(filter, DOWNLOADED_MASK) + get() = chapter_flags and CHAPTER_DOWNLOADED_MASK + set(filter) = setChapterFlags(filter, CHAPTER_DOWNLOADED_MASK) var bookmarkedFilter: Int - get() = chapter_flags and BOOKMARKED_MASK - set(filter) = setFlags(filter, BOOKMARKED_MASK) + get() = chapter_flags and CHAPTER_BOOKMARKED_MASK + set(filter) = setChapterFlags(filter, CHAPTER_BOOKMARKED_MASK) var sorting: Int - get() = chapter_flags and SORTING_MASK - set(sort) = setFlags(sort, SORTING_MASK) + get() = chapter_flags and CHAPTER_SORTING_MASK + set(sort) = setChapterFlags(sort, CHAPTER_SORTING_MASK) + + var readingModeType: Int + get() = viewer_flags and ReadingModeType.MASK + set(readingMode) = setViewerFlags(readingMode, ReadingModeType.MASK) + + var orientationType: Int + get() = viewer_flags and OrientationType.MASK + set(rotationType) = setViewerFlags(rotationType, OrientationType.MASK) companion object { - const val SORT_DESC = 0x00000000 - const val SORT_ASC = 0x00000001 - const val SORT_MASK = 0x00000001 - // Generic filter that does not filter anything const val SHOW_ALL = 0x00000000 - const val SHOW_UNREAD = 0x00000002 - const val SHOW_READ = 0x00000004 - const val READ_MASK = 0x00000006 + const val CHAPTER_SORT_DESC = 0x00000000 + const val CHAPTER_SORT_ASC = 0x00000001 + const val CHAPTER_SORT_MASK = 0x00000001 - const val SHOW_DOWNLOADED = 0x00000008 - const val SHOW_NOT_DOWNLOADED = 0x00000010 - const val DOWNLOADED_MASK = 0x00000018 + const val CHAPTER_SHOW_UNREAD = 0x00000002 + const val CHAPTER_SHOW_READ = 0x00000004 + const val CHAPTER_READ_MASK = 0x00000006 - const val SHOW_BOOKMARKED = 0x00000020 - const val SHOW_NOT_BOOKMARKED = 0x00000040 - const val BOOKMARKED_MASK = 0x00000060 + const val CHAPTER_SHOW_DOWNLOADED = 0x00000008 + const val CHAPTER_SHOW_NOT_DOWNLOADED = 0x00000010 + const val CHAPTER_DOWNLOADED_MASK = 0x00000018 - const val SORTING_SOURCE = 0x00000000 - const val SORTING_NUMBER = 0x00000100 - const val SORTING_UPLOAD_DATE = 0x00000200 - const val SORTING_MASK = 0x00000300 + const val CHAPTER_SHOW_BOOKMARKED = 0x00000020 + const val CHAPTER_SHOW_NOT_BOOKMARKED = 0x00000040 + const val CHAPTER_BOOKMARKED_MASK = 0x00000060 - const val DISPLAY_NAME = 0x00000000 - const val DISPLAY_NUMBER = 0x00100000 - const val DISPLAY_MASK = 0x00100000 + const val CHAPTER_SORTING_SOURCE = 0x00000000 + const val CHAPTER_SORTING_NUMBER = 0x00000100 + const val CHAPTER_SORTING_UPLOAD_DATE = 0x00000200 + const val CHAPTER_SORTING_MASK = 0x00000300 + + const val CHAPTER_DISPLAY_NAME = 0x00000000 + const val CHAPTER_DISPLAY_NUMBER = 0x00100000 + const val CHAPTER_DISPLAY_MASK = 0x00100000 fun create(source: Long): Manga = MangaImpl().apply { this.source = source diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/database/models/MangaImpl.kt b/app/src/main/java/eu/kanade/tachiyomi/data/database/models/MangaImpl.kt index e0a3169ca..e35336a03 100755 --- a/app/src/main/java/eu/kanade/tachiyomi/data/database/models/MangaImpl.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/database/models/MangaImpl.kt @@ -56,7 +56,7 @@ open class MangaImpl : Manga { override var initialized: Boolean = false - override var viewer: Int = 0 + override var viewer_flags: Int = 0 override var chapter_flags: Int = 0 diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/database/queries/MangaQueries.kt b/app/src/main/java/eu/kanade/tachiyomi/data/database/queries/MangaQueries.kt index 2d543abea..372f001c8 100755 --- a/app/src/main/java/eu/kanade/tachiyomi/data/database/queries/MangaQueries.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/database/queries/MangaQueries.kt @@ -15,7 +15,6 @@ import eu.kanade.tachiyomi.data.database.resolvers.MangaLastUpdatedPutResolver import eu.kanade.tachiyomi.data.database.resolvers.MangaMigrationPutResolver import eu.kanade.tachiyomi.data.database.resolvers.MangaThumbnailPutResolver import eu.kanade.tachiyomi.data.database.resolvers.MangaTitlePutResolver -import eu.kanade.tachiyomi.data.database.resolvers.MangaViewerPutResolver import eu.kanade.tachiyomi.data.database.tables.CategoryTable import eu.kanade.tachiyomi.data.database.tables.ChapterTable import eu.kanade.tachiyomi.data.database.tables.MangaCategoryTable @@ -114,14 +113,24 @@ interface MangaQueries : DbProvider { fun insertMangas(mangas: List) = db.put().objects(mangas).prepare() - fun updateFlags(manga: Manga) = db.put() + fun updateChapterFlags(manga: Manga) = db.put() .`object`(manga) - .withPutResolver(MangaFlagsPutResolver()) + .withPutResolver(MangaFlagsPutResolver(MangaTable.COL_CHAPTER_FLAGS, Manga::chapter_flags)) .prepare() - fun updateFlags(mangas: List) = db.put() - .objects(mangas) - .withPutResolver(MangaFlagsPutResolver(true)) + fun updateChapterFlags(manga: List) = db.put() + .objects(manga) + .withPutResolver(MangaFlagsPutResolver(MangaTable.COL_CHAPTER_FLAGS, Manga::chapter_flags, true)) + .prepare() + + fun updateViewerFlags(manga: Manga) = db.put() + .`object`(manga) + .withPutResolver(MangaFlagsPutResolver(MangaTable.COL_VIEWER, Manga::viewer_flags)) + .prepare() + + fun updateViewerFlags(manga: List) = db.put() + .objects(manga) + .withPutResolver(MangaFlagsPutResolver(MangaTable.COL_VIEWER, Manga::viewer_flags, true)) .prepare() fun updateLastUpdated(manga: Manga) = db.put() @@ -134,11 +143,6 @@ interface MangaQueries : DbProvider { .withPutResolver(MangaFavoritePutResolver()) .prepare() - fun updateMangaViewer(manga: Manga) = db.put() - .`object`(manga) - .withPutResolver(MangaViewerPutResolver()) - .prepare() - fun updateMangaTitle(manga: Manga) = db.put() .`object`(manga) .withPutResolver(MangaTitlePutResolver()) diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/database/resolvers/MangaFlagsPutResolver.kt b/app/src/main/java/eu/kanade/tachiyomi/data/database/resolvers/MangaFlagsPutResolver.kt index b342e35bb..e19a4c889 100755 --- a/app/src/main/java/eu/kanade/tachiyomi/data/database/resolvers/MangaFlagsPutResolver.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/database/resolvers/MangaFlagsPutResolver.kt @@ -8,8 +8,9 @@ import com.pushtorefresh.storio.sqlite.queries.UpdateQuery import eu.kanade.tachiyomi.data.database.inTransactionReturn import eu.kanade.tachiyomi.data.database.models.Manga import eu.kanade.tachiyomi.data.database.tables.MangaTable +import kotlin.reflect.KProperty1 -class MangaFlagsPutResolver(private val updateAll: Boolean = false) : PutResolver() { +class MangaFlagsPutResolver(private val colName: String, private val fieldGetter: KProperty1, private val updateAll: Boolean = false) : PutResolver() { override fun performPut(db: StorIOSQLite, manga: Manga) = db.inTransactionReturn { val updateQuery = mapToUpdateQuery(manga) @@ -37,6 +38,6 @@ class MangaFlagsPutResolver(private val updateAll: Boolean = false) : PutResolve fun mapToContentValues(manga: Manga) = contentValuesOf( - MangaTable.COL_CHAPTER_FLAGS to manga.chapter_flags + colName to fieldGetter.get(manga) ) } diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/database/resolvers/MangaMigrationPutResolver.kt b/app/src/main/java/eu/kanade/tachiyomi/data/database/resolvers/MangaMigrationPutResolver.kt index 271823d2e..06124d819 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/data/database/resolvers/MangaMigrationPutResolver.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/database/resolvers/MangaMigrationPutResolver.kt @@ -30,6 +30,6 @@ class MangaMigrationPutResolver : PutResolver() { MangaTable.COL_DATE_ADDED to manga.date_added, MangaTable.COL_TITLE to manga.title, MangaTable.COL_CHAPTER_FLAGS to manga.chapter_flags, - MangaTable.COL_VIEWER to manga.viewer + MangaTable.COL_VIEWER to manga.viewer_flags ) } diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/database/resolvers/MangaViewerPutResolver.kt b/app/src/main/java/eu/kanade/tachiyomi/data/database/resolvers/MangaViewerPutResolver.kt deleted file mode 100644 index 5f465eb30..000000000 --- a/app/src/main/java/eu/kanade/tachiyomi/data/database/resolvers/MangaViewerPutResolver.kt +++ /dev/null @@ -1,32 +0,0 @@ -package eu.kanade.tachiyomi.data.database.resolvers - -import androidx.core.content.contentValuesOf -import com.pushtorefresh.storio.sqlite.StorIOSQLite -import com.pushtorefresh.storio.sqlite.operations.put.PutResolver -import com.pushtorefresh.storio.sqlite.operations.put.PutResult -import com.pushtorefresh.storio.sqlite.queries.UpdateQuery -import eu.kanade.tachiyomi.data.database.inTransactionReturn -import eu.kanade.tachiyomi.data.database.models.Manga -import eu.kanade.tachiyomi.data.database.tables.MangaTable - -class MangaViewerPutResolver : PutResolver() { - - override fun performPut(db: StorIOSQLite, manga: Manga) = db.inTransactionReturn { - val updateQuery = mapToUpdateQuery(manga) - val contentValues = mapToContentValues(manga) - - val numberOfRowsUpdated = db.lowLevel().update(updateQuery, contentValues) - PutResult.newUpdateResult(numberOfRowsUpdated, updateQuery.table()) - } - - fun mapToUpdateQuery(manga: Manga) = UpdateQuery.builder() - .table(MangaTable.TABLE) - .where("${MangaTable.COL_ID} = ?") - .whereArgs(manga.id) - .build() - - fun mapToContentValues(manga: Manga) = - contentValuesOf( - MangaTable.COL_VIEWER to manga.viewer - ) -} diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/preference/PreferenceKeys.kt b/app/src/main/java/eu/kanade/tachiyomi/data/preference/PreferenceKeys.kt index b84903d53..5654b2b12 100755 --- a/app/src/main/java/eu/kanade/tachiyomi/data/preference/PreferenceKeys.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/preference/PreferenceKeys.kt @@ -15,8 +15,6 @@ object PreferenceKeys { const val hideBottomBar = "pref_hide_bottom_bar_on_scroll" - const val rotation = "pref_rotation_type_key" - const val enableTransitionsPager = "pref_enable_transitions_pager_key" const val enableTransitionsWebtoon = "pref_enable_transitions_webtoon_key" @@ -53,7 +51,9 @@ object PreferenceKeys { const val colorFilterMode = "color_filter_mode" - const val defaultViewer = "pref_default_viewer_key" + const val defaultReadingMode = "pref_default_reading_mode_key" + + const val defaultOrientationType = "pref_default_orientation_type_key" const val imageScaleType = "pref_image_scale_type_key" diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/preference/PreferencesHelper.kt b/app/src/main/java/eu/kanade/tachiyomi/data/preference/PreferencesHelper.kt index f16ded281..6d0dd0ae2 100755 --- a/app/src/main/java/eu/kanade/tachiyomi/data/preference/PreferencesHelper.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/preference/PreferencesHelper.kt @@ -12,6 +12,8 @@ import eu.kanade.tachiyomi.data.database.models.Manga import eu.kanade.tachiyomi.data.preference.PreferenceValues.DisplayMode import eu.kanade.tachiyomi.data.track.TrackService import eu.kanade.tachiyomi.data.track.anilist.Anilist +import eu.kanade.tachiyomi.ui.reader.setting.OrientationType +import eu.kanade.tachiyomi.ui.reader.setting.ReadingModeType import eu.kanade.tachiyomi.widget.ExtendedNavigationView import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.onEach @@ -85,8 +87,6 @@ class PreferencesHelper(val context: Context) { fun themeDark() = flowPrefs.getEnum(Keys.themeDark, Values.DarkThemeVariant.default) - fun rotation() = flowPrefs.getInt(Keys.rotation, 1) - fun pageTransitionsPager() = flowPrefs.getBoolean(Keys.enableTransitionsPager, true) fun pageTransitionsWebtoon() = flowPrefs.getBoolean(Keys.enableTransitionsWebtoon, true) @@ -123,7 +123,9 @@ class PreferencesHelper(val context: Context) { fun colorFilterMode() = flowPrefs.getInt(Keys.colorFilterMode, 0) - fun defaultViewer() = prefs.getInt(Keys.defaultViewer, 2) + fun defaultReadingMode() = prefs.getInt(Keys.defaultReadingMode, ReadingModeType.RIGHT_TO_LEFT.flagValue) + + fun defaultOrientationType() = prefs.getInt(Keys.defaultOrientationType, OrientationType.FREE.flagValue) fun imageScaleType() = flowPrefs.getInt(Keys.imageScaleType, 1) @@ -297,11 +299,11 @@ class PreferencesHelper(val context: Context) { fun filterChapterByBookmarked() = prefs.getInt(Keys.defaultChapterFilterByBookmarked, Manga.SHOW_ALL) - fun sortChapterBySourceOrNumber() = prefs.getInt(Keys.defaultChapterSortBySourceOrNumber, Manga.SORTING_SOURCE) + fun sortChapterBySourceOrNumber() = prefs.getInt(Keys.defaultChapterSortBySourceOrNumber, Manga.CHAPTER_SORTING_SOURCE) - fun displayChapterByNameOrNumber() = prefs.getInt(Keys.defaultChapterDisplayByNameOrNumber, Manga.DISPLAY_NAME) + fun displayChapterByNameOrNumber() = prefs.getInt(Keys.defaultChapterDisplayByNameOrNumber, Manga.CHAPTER_DISPLAY_NAME) - fun sortChapterByAscendingOrDescending() = prefs.getInt(Keys.defaultChapterSortByAscendingOrDescending, Manga.SORT_DESC) + fun sortChapterByAscendingOrDescending() = prefs.getInt(Keys.defaultChapterSortByAscendingOrDescending, Manga.CHAPTER_SORT_DESC) fun incognitoMode() = flowPrefs.getBoolean(Keys.incognitoMode, false) @@ -314,7 +316,7 @@ class PreferencesHelper(val context: Context) { putInt(Keys.defaultChapterFilterByBookmarked, manga.bookmarkedFilter) putInt(Keys.defaultChapterSortBySourceOrNumber, manga.sorting) putInt(Keys.defaultChapterDisplayByNameOrNumber, manga.displayMode) - putInt(Keys.defaultChapterSortByAscendingOrDescending, if (manga.sortDescending()) Manga.SORT_DESC else Manga.SORT_ASC) + putInt(Keys.defaultChapterSortByAscendingOrDescending, if (manga.sortDescending()) Manga.CHAPTER_SORT_DESC else Manga.CHAPTER_SORT_ASC) } } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/advanced/process/MigrationProcessAdapter.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/advanced/process/MigrationProcessAdapter.kt index 44f5f78b5..111defcb4 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/advanced/process/MigrationProcessAdapter.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/advanced/process/MigrationProcessAdapter.kt @@ -145,8 +145,8 @@ class MigrationProcessAdapter( } // Update extras if (MigrationFlags.hasExtra(flags)) { - manga.viewer = prevManga.viewer manga.chapter_flags = prevManga.chapter_flags + manga.viewer_flags = prevManga.viewer_flags } // Update favorite status if (replace) { diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/manga/MigrationMangaPresenter.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/manga/MigrationMangaPresenter.kt index 987ab2400..99d0a7baf 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/manga/MigrationMangaPresenter.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/manga/MigrationMangaPresenter.kt @@ -104,7 +104,7 @@ class MigrationMangaPresenter( } if (migrateExtra) { - manga.viewer = prevManga.viewer + manga.viewer_flags = prevManga.viewer_flags manga.chapter_flags = prevManga.chapter_flags } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/manga/MangaPresenter.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/manga/MangaPresenter.kt index e05e0dcb5..810bf1805 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/manga/MangaPresenter.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/manga/MangaPresenter.kt @@ -448,9 +448,9 @@ class MangaPresenter( copyFrom(originalManga) favorite = true last_update = originalManga.last_update - viewer = originalManga.viewer + viewer_flags = originalManga.viewer_flags chapter_flags = originalManga.chapter_flags - sorting = Manga.SORTING_NUMBER + sorting = Manga.CHAPTER_SORTING_NUMBER date_added = System.currentTimeMillis() } var existingManga = db.getManga(mergedManga.url, mergedManga.source).executeAsBlocking() @@ -853,15 +853,15 @@ class MangaPresenter( fun getChapterSort(): (Chapter, Chapter) -> Int { return when (manga.sorting) { - Manga.SORTING_SOURCE -> when (sortDescending()) { + Manga.CHAPTER_SORTING_SOURCE -> when (sortDescending()) { true -> { c1, c2 -> c1.source_order.compareTo(c2.source_order) } false -> { c1, c2 -> c2.source_order.compareTo(c1.source_order) } } - Manga.SORTING_NUMBER -> when (sortDescending()) { + Manga.CHAPTER_SORTING_NUMBER -> when (sortDescending()) { true -> { c1, c2 -> c2.chapter_number.compareTo(c1.chapter_number) } false -> { c1, c2 -> c1.chapter_number.compareTo(c2.chapter_number) } } - Manga.SORTING_UPLOAD_DATE -> when (sortDescending()) { + Manga.CHAPTER_SORTING_UPLOAD_DATE -> when (sortDescending()) { true -> { c1, c2 -> c2.date_upload.compareTo(c1.date_upload) } false -> { c1, c2 -> c1.date_upload.compareTo(c2.date_upload) } } @@ -995,8 +995,8 @@ class MangaPresenter( * Reverses the sorting and requests an UI update. */ fun reverseSortOrder() { - manga.setChapterOrder(if (sortDescending()) Manga.SORT_ASC else Manga.SORT_DESC) - db.updateFlags(manga).executeAsBlocking() + manga.setChapterOrder(if (sortDescending()) Manga.CHAPTER_SORT_ASC else Manga.CHAPTER_SORT_DESC) + db.updateChapterFlags(manga).executeAsBlocking() refreshChapters() } @@ -1007,10 +1007,10 @@ class MangaPresenter( fun setUnreadFilter(state: State) { manga.readFilter = when (state) { State.IGNORE -> Manga.SHOW_ALL - State.INCLUDE -> Manga.SHOW_UNREAD - State.EXCLUDE -> Manga.SHOW_READ + State.INCLUDE -> Manga.CHAPTER_SHOW_UNREAD + State.EXCLUDE -> Manga.CHAPTER_SHOW_READ } - db.updateFlags(manga).executeAsBlocking() + db.updateChapterFlags(manga).executeAsBlocking() refreshChapters() } @@ -1021,10 +1021,10 @@ class MangaPresenter( fun setDownloadedFilter(state: State) { manga.downloadedFilter = when (state) { State.IGNORE -> Manga.SHOW_ALL - State.INCLUDE -> Manga.SHOW_DOWNLOADED - State.EXCLUDE -> Manga.SHOW_NOT_DOWNLOADED + State.INCLUDE -> Manga.CHAPTER_SHOW_DOWNLOADED + State.EXCLUDE -> Manga.CHAPTER_SHOW_NOT_DOWNLOADED } - db.updateFlags(manga).executeAsBlocking() + db.updateChapterFlags(manga).executeAsBlocking() refreshChapters() } @@ -1035,10 +1035,10 @@ class MangaPresenter( fun setBookmarkedFilter(state: State) { manga.bookmarkedFilter = when (state) { State.IGNORE -> Manga.SHOW_ALL - State.INCLUDE -> Manga.SHOW_BOOKMARKED - State.EXCLUDE -> Manga.SHOW_NOT_BOOKMARKED + State.INCLUDE -> Manga.CHAPTER_SHOW_BOOKMARKED + State.EXCLUDE -> Manga.CHAPTER_SHOW_NOT_BOOKMARKED } - db.updateFlags(manga).executeAsBlocking() + db.updateChapterFlags(manga).executeAsBlocking() refreshChapters() } @@ -1059,7 +1059,7 @@ class MangaPresenter( */ fun setDisplayMode(mode: Int) { manga.displayMode = mode - db.updateFlags(manga).executeAsBlocking() + db.updateChapterFlags(manga).executeAsBlocking() } /** @@ -1068,7 +1068,7 @@ class MangaPresenter( */ fun setSorting(sort: Int) { manga.sorting = sort - db.updateFlags(manga).executeAsBlocking() + db.updateChapterFlags(manga).executeAsBlocking() refreshChapters() } @@ -1087,8 +1087,8 @@ class MangaPresenter( return State.INCLUDE } return when (manga.downloadedFilter) { - Manga.SHOW_DOWNLOADED -> State.INCLUDE - Manga.SHOW_NOT_DOWNLOADED -> State.EXCLUDE + Manga.CHAPTER_SHOW_DOWNLOADED -> State.INCLUDE + Manga.CHAPTER_SHOW_NOT_DOWNLOADED -> State.EXCLUDE else -> State.IGNORE } } @@ -1098,8 +1098,8 @@ class MangaPresenter( */ fun onlyBookmarked(): State { return when (manga.bookmarkedFilter) { - Manga.SHOW_BOOKMARKED -> State.INCLUDE - Manga.SHOW_NOT_BOOKMARKED -> State.EXCLUDE + Manga.CHAPTER_SHOW_BOOKMARKED -> State.INCLUDE + Manga.CHAPTER_SHOW_NOT_BOOKMARKED -> State.EXCLUDE else -> State.IGNORE } } @@ -1109,8 +1109,8 @@ class MangaPresenter( */ fun onlyUnread(): State { return when (manga.readFilter) { - Manga.SHOW_UNREAD -> State.INCLUDE - Manga.SHOW_READ -> State.EXCLUDE + Manga.CHAPTER_SHOW_UNREAD -> State.INCLUDE + Manga.CHAPTER_SHOW_READ -> State.EXCLUDE else -> State.IGNORE } } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/manga/chapter/ChapterHolder.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/manga/chapter/ChapterHolder.kt index 2937856a0..c74edc84d 100755 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/manga/chapter/ChapterHolder.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/manga/chapter/ChapterHolder.kt @@ -31,7 +31,7 @@ class ChapterHolder( val chapter = item.chapter binding.chapterTitle.text = when (manga.displayMode) { - Manga.DISPLAY_NUMBER -> { + Manga.CHAPTER_DISPLAY_NUMBER -> { val number = adapter.decimalFormat.format(chapter.chapter_number.toDouble()) itemView.context.getString(R.string.display_mode_chapter, number) } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/manga/chapter/ChaptersSettingsSheet.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/manga/chapter/ChaptersSettingsSheet.kt index 55d9da99d..67536e6de 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/manga/chapter/ChaptersSettingsSheet.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/manga/chapter/ChaptersSettingsSheet.kt @@ -200,11 +200,11 @@ class ChaptersSettingsSheet( } source.state = - if (sorting == Manga.SORTING_SOURCE) order else Item.MultiSort.SORT_NONE + if (sorting == Manga.CHAPTER_SORTING_SOURCE) order else Item.MultiSort.SORT_NONE chapterNum.state = - if (sorting == Manga.SORTING_NUMBER) order else Item.MultiSort.SORT_NONE + if (sorting == Manga.CHAPTER_SORTING_NUMBER) order else Item.MultiSort.SORT_NONE uploadDate.state = - if (sorting == Manga.SORTING_UPLOAD_DATE) order else Item.MultiSort.SORT_NONE + if (sorting == Manga.CHAPTER_SORTING_UPLOAD_DATE) order else Item.MultiSort.SORT_NONE } override fun onItemClicked(item: Item) { @@ -223,9 +223,9 @@ class ChaptersSettingsSheet( } when (item) { - source -> presenter.setSorting(Manga.SORTING_SOURCE) - chapterNum -> presenter.setSorting(Manga.SORTING_NUMBER) - uploadDate -> presenter.setSorting(Manga.SORTING_UPLOAD_DATE) + source -> presenter.setSorting(Manga.CHAPTER_SORTING_SOURCE) + chapterNum -> presenter.setSorting(Manga.CHAPTER_SORTING_NUMBER) + uploadDate -> presenter.setSorting(Manga.CHAPTER_SORTING_UPLOAD_DATE) else -> throw Exception("Unknown sorting") } @@ -257,8 +257,8 @@ class ChaptersSettingsSheet( override fun initModels() { val mode = presenter.manga.displayMode - displayTitle.checked = mode == Manga.DISPLAY_NAME - displayChapterNum.checked = mode == Manga.DISPLAY_NUMBER + displayTitle.checked = mode == Manga.CHAPTER_DISPLAY_NAME + displayChapterNum.checked = mode == Manga.CHAPTER_DISPLAY_NUMBER } override fun onItemClicked(item: Item) { @@ -269,8 +269,8 @@ class ChaptersSettingsSheet( item.checked = true when (item) { - displayTitle -> presenter.setDisplayMode(Manga.DISPLAY_NAME) - displayChapterNum -> presenter.setDisplayMode(Manga.DISPLAY_NUMBER) + displayTitle -> presenter.setDisplayMode(Manga.CHAPTER_DISPLAY_NAME) + displayChapterNum -> presenter.setDisplayMode(Manga.CHAPTER_DISPLAY_NUMBER) else -> throw NotImplementedError("Unknown display mode") } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderActivity.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderActivity.kt index 5ec105c55..aac894b5e 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderActivity.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderActivity.kt @@ -33,7 +33,6 @@ import eu.kanade.tachiyomi.data.database.models.Manga import eu.kanade.tachiyomi.data.notification.NotificationReceiver import eu.kanade.tachiyomi.data.notification.Notifications import eu.kanade.tachiyomi.data.preference.PreferencesHelper -import eu.kanade.tachiyomi.data.preference.asImmediateFlow import eu.kanade.tachiyomi.data.preference.toggle import eu.kanade.tachiyomi.databinding.ReaderActivityBinding import eu.kanade.tachiyomi.source.SourceManager @@ -67,7 +66,6 @@ import eu.kanade.tachiyomi.util.system.toast import eu.kanade.tachiyomi.util.view.defaultBar import eu.kanade.tachiyomi.util.view.hideBar import eu.kanade.tachiyomi.util.view.isDefaultBar -import eu.kanade.tachiyomi.util.view.popupMenu import eu.kanade.tachiyomi.util.view.setTooltip import eu.kanade.tachiyomi.util.view.showBar import eu.kanade.tachiyomi.widget.SimpleAnimationListener @@ -459,12 +457,12 @@ class ReaderActivity : BaseRxActivity() setOnClickListener { popupMenu( - items = ReadingModeType.values().map { it.prefValue to it.stringRes }, - selectedItemId = presenter.getMangaViewer(resolveDefault = false), + items = ReadingModeType.values().map { it.flagValue to it.stringRes }, + selectedItemId = presenter.getMangaReadingMode(resolveDefault = false), ) { val newReadingMode = ReadingModeType.fromPreference(itemId) - presenter.setMangaViewer(newReadingMode.prefValue) + presenter.setMangaReadingMode(newReadingMode.flagValue) menuToggleToast?.cancel() if (!preferences.showReadingMode()) { @@ -480,29 +478,28 @@ class ReaderActivity : BaseRxActivity() setOnClickListener { popupMenu( - items = OrientationType.values().map { it.prefValue to it.stringRes }, - selectedItemId = preferences.rotation().get(), + items = OrientationType.values().map { it.flagValue to it.stringRes }, + selectedItemId = presenter.manga?.orientationType + ?: preferences.defaultOrientationType(), ) { val newOrientation = OrientationType.fromPreference(itemId) - preferences.rotation().set(newOrientation.prefValue) - setOrientation(newOrientation.flag) + presenter.setMangaOrientationType(newOrientation.flagValue) + + updateOrientationShortcut(newOrientation.flagValue) menuToggleToast?.cancel() menuToggleToast = toast(newOrientation.stringRes) } } - } - preferences.rotation().asImmediateFlow { updateRotationShortcut(it) } - .launchIn(lifecycleScope) - */ + }*/ // Crop borders with(binding.actionCropBorders) { setTooltip(R.string.pref_crop_borders) setOnClickListener { - val mangaViewer = presenter.getMangaViewer() + val mangaViewer = presenter.getMangaReadingMode() val isPagerType = ReadingModeType.isPagerType(mangaViewer) if (isPagerType) { preferences.cropBorders().toggle() @@ -731,13 +728,13 @@ class ReaderActivity : BaseRxActivity() } // EXH <-- - /*private fun updateRotationShortcut(preference: Int) { + /*private fun updateOrientationShortcut(preference: Int) { val orientation = OrientationType.fromPreference(preference) binding.actionRotation.setImageResource(orientation.iconRes) }*/ private fun updateCropBordersShortcut() { - val mangaViewer = presenter.getMangaViewer() + val mangaViewer = presenter.getMangaReadingMode() val isPagerType = ReadingModeType.isPagerType(mangaViewer) val enabled = if (isPagerType) { preferences.cropBorders().get() @@ -879,10 +876,10 @@ class ReaderActivity : BaseRxActivity() fun setManga(manga: Manga) { val prevViewer = viewer - /*val viewerMode = ReadingModeType.fromPreference(presenter.getMangaViewer(resolveDefault = false)) + /*val viewerMode = ReadingModeType.fromPreference(presenter.getMangaReadingMode(resolveDefault = false)) binding.actionReadingMode.setImageResource(viewerMode.iconRes)*/ - val newViewer = when (presenter.getMangaViewer()) { + val newViewer = when (presenter.getMangaReadingMode()) { ReadingModeType.LEFT_TO_RIGHT.prefValue -> L2RPagerViewer(this) ReadingModeType.VERTICAL.prefValue -> VerticalPagerViewer(this) ReadingModeType.WEBTOON.prefValue -> WebtoonViewer(this) @@ -890,6 +887,8 @@ class ReaderActivity : BaseRxActivity() else -> R2LPagerViewer(this) } + setOrientation(presenter.getMangaOrientationType()) + // Destroy previous viewer if there was one if (prevViewer != null) { prevViewer.destroy() @@ -900,12 +899,12 @@ class ReaderActivity : BaseRxActivity() // SY --> val defaultReaderType = manga.defaultReaderType(manga.mangaType(sourceName = sourceManager.get(manga.source)?.name)) - if (preferences.useAutoWebtoon().get() && manga.viewer == 0 && defaultReaderType != null && defaultReaderType == ReadingModeType.WEBTOON.prefValue) { + if (preferences.useAutoWebtoon().get() && manga.readingModeType == ReadingModeType.DEFAULT.flagValue && defaultReaderType != null && defaultReaderType == ReadingModeType.WEBTOON.prefValue) { readingModeToast?.cancel() readingModeToast = toast(resources.getString(R.string.eh_auto_webtoon_snack)) } else if (preferences.showReadingMode()) { // SY <-- - showReadingModeToast(presenter.getMangaViewer()) + showReadingModeToast(presenter.getMangaReadingMode()) } // SY --> @@ -1191,7 +1190,7 @@ class ReaderActivity : BaseRxActivity() /** * Forces the user preferred [orientation] on the activity. */ - private fun setOrientation(orientation: Int) { + fun setOrientation(orientation: Int) { val newOrientation = OrientationType.fromPreference(orientation) if (newOrientation.flag != requestedOrientation) { requestedOrientation = newOrientation.flag @@ -1207,14 +1206,6 @@ class ReaderActivity : BaseRxActivity() * Initializes the reader subscriptions. */ init { - preferences.rotation().asImmediateFlow { setOrientation(it) } - .drop(1) - .onEach { - delay(250) - setOrientation(it) - } - .launchIn(lifecycleScope) - preferences.readerTheme().asFlow() .drop(1) // We only care about updates .onEach { recreate() } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderPresenter.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderPresenter.kt index 840311aa8..4a9cce126 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderPresenter.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderPresenter.kt @@ -25,6 +25,8 @@ import eu.kanade.tachiyomi.ui.reader.loader.ChapterLoader 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.ReadingModeType import eu.kanade.tachiyomi.util.isLocal import eu.kanade.tachiyomi.util.lang.byteSize import eu.kanade.tachiyomi.util.lang.launchIO @@ -131,13 +133,13 @@ class ReaderPresenter( return@filter false } else if (preferences.skipFiltered()) { if ( - (manga.readFilter == Manga.SHOW_READ && !it.read) || - (manga.readFilter == Manga.SHOW_UNREAD && it.read) || + (manga.readFilter == Manga.CHAPTER_SHOW_READ && !it.read) || + (manga.readFilter == Manga.CHAPTER_SHOW_UNREAD && it.read) || ( - manga.downloadedFilter == Manga.SHOW_DOWNLOADED && + manga.downloadedFilter == Manga.CHAPTER_SHOW_DOWNLOADED && !downloadManager.isChapterDownloaded(it, manga) ) || - (manga.bookmarkedFilter == Manga.SHOW_BOOKMARKED && !it.bookmark) || + (manga.bookmarkedFilter == Manga.CHAPTER_SHOW_BOOKMARKED && !it.bookmark) || // SY --> (filteredScanlators != null && it.scanlatorList().none { group -> filteredScanlators.contains(group) }) // SY <-- @@ -160,9 +162,9 @@ class ReaderPresenter( } when (manga.sorting) { - Manga.SORTING_SOURCE -> ChapterLoadBySource().get(chaptersForReader) - Manga.SORTING_NUMBER -> ChapterLoadByNumber().get(chaptersForReader, selectedChapter) - Manga.SORTING_UPLOAD_DATE -> ChapterLoadByUploadDate().get(chaptersForReader) + Manga.CHAPTER_SORTING_SOURCE -> ChapterLoadBySource().get(chaptersForReader) + Manga.CHAPTER_SORTING_NUMBER -> ChapterLoadByNumber().get(chaptersForReader, selectedChapter) + Manga.CHAPTER_SORTING_UPLOAD_DATE -> ChapterLoadByUploadDate().get(chaptersForReader) else -> error("Unknown sorting method") }.map(::ReaderChapter) } @@ -594,15 +596,17 @@ class ReaderPresenter( /** * Returns the viewer position used by this manga or the default one. */ - fun getMangaViewer(resolveDefault: Boolean = true): Int { - val manga = manga ?: return preferences.defaultViewer() + fun getMangaReadingMode(resolveDefault: Boolean = true): Int { + val manga = manga ?: return preferences.defaultReadingMode() // SY --> - return if (resolveDefault && manga.viewer == 0 && preferences.useAutoWebtoon().get()) { - manga.defaultReaderType(manga.mangaType(sourceName = sourceManager.get(manga.source)?.name)) ?: if (manga.viewer == 0) preferences.defaultViewer() else manga.viewer - } else if (resolveDefault && manga.viewer == 0) { - preferences.defaultViewer() - } else { - manga.viewer + return when { + resolveDefault && manga.readingModeType == ReadingModeType.DEFAULT.flagValue && preferences.useAutoWebtoon().get() -> { + manga.defaultReaderType(manga.mangaType(sourceName = sourceManager.get(manga.source)?.name)) ?: if (manga.readingModeType == ReadingModeType.DEFAULT.flagValue) preferences.defaultReadingMode() else manga.readingModeType + } + resolveDefault && manga.readingModeType == ReadingModeType.DEFAULT.flagValue -> { + preferences.defaultReadingMode() + } + else -> manga.readingModeType } // SY <-- } @@ -610,10 +614,10 @@ class ReaderPresenter( /** * Updates the viewer position for the open manga. */ - fun setMangaViewer(viewer: Int) { + fun setMangaReadingMode(readingModeType: Int) { val manga = manga ?: return - manga.viewer = viewer - db.updateMangaViewer(manga).executeAsBlocking() + manga.readingModeType = readingModeType + db.updateViewerFlags(manga).executeAsBlocking() Observable.timer(250, TimeUnit.MILLISECONDS, AndroidSchedulers.mainThread()) .subscribeFirst({ view, _ -> @@ -630,6 +634,36 @@ class ReaderPresenter( }) } + /** + * Returns the orientation type used by this manga or the default one. + */ + fun getMangaOrientationType(): Int { + val default = preferences.defaultOrientationType() + return when (manga?.orientationType) { + OrientationType.DEFAULT.flagValue -> default + else -> manga?.orientationType ?: default + } + } + + /** + * Updates the orientation type for the open manga. + */ + fun setMangaOrientationType(rotationType: Int) { + val manga = manga ?: return + manga.orientationType = rotationType + db.updateViewerFlags(manga).executeAsBlocking() + + Timber.i("Manga orientation is ${manga.orientationType}") + + Observable.timer(250, TimeUnit.MILLISECONDS, AndroidSchedulers.mainThread()) + .subscribeFirst({ view, _ -> + val currChapters = viewerChaptersRelay.value + if (currChapters != null) { + view.setOrientation(getMangaOrientationType()) + } + }) + } + /** * Saves the image of this [page] in the given [directory] and returns the file location. */ diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/chapter/ReaderChapterItem.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/chapter/ReaderChapterItem.kt index 28d03679a..725ea530d 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/chapter/ReaderChapterItem.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/chapter/ReaderChapterItem.kt @@ -48,7 +48,7 @@ class ReaderChapterItem(val chapter: Chapter, val manga: Manga, val isCurrent: B val manga = item.manga chapterTitle.text = when (manga.displayMode) { - Manga.DISPLAY_NUMBER -> { + Manga.CHAPTER_DISPLAY_NUMBER -> { val number = item.decimalFormat.format(item.chapter_number.toDouble()) itemView.context.getString(R.string.display_mode_chapter, number) } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/chapter/ReaderChapterSheet.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/chapter/ReaderChapterSheet.kt index d312622a2..490c00fd8 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/chapter/ReaderChapterSheet.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/chapter/ReaderChapterSheet.kt @@ -122,9 +122,9 @@ class ReaderChapterSheet(private val activity: ReaderActivity) : BaseBottomSheet launchUI { val chapters = with(presenter.getChapters(context)) { when (activity.presenter.manga?.sorting) { - Manga.SORTING_SOURCE -> sortedBy { it.source_order } - Manga.SORTING_NUMBER -> sortedByDescending { it.chapter_number } - Manga.SORTING_UPLOAD_DATE -> sortedBy { it.date_upload } + Manga.CHAPTER_SORTING_SOURCE -> sortedBy { it.source_order } + Manga.CHAPTER_SORTING_NUMBER -> sortedByDescending { it.chapter_number } + Manga.CHAPTER_SORTING_UPLOAD_DATE -> sortedBy { it.date_upload } else -> sortedBy { it.source_order } } } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/OrientationType.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/OrientationType.kt index 007b5e27a..805c9452d 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/OrientationType.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/OrientationType.kt @@ -5,16 +5,20 @@ import androidx.annotation.DrawableRes import androidx.annotation.StringRes import eu.kanade.tachiyomi.R -enum class OrientationType(val prefValue: Int, val flag: Int, @StringRes val stringRes: Int, @DrawableRes val iconRes: Int) { - FREE(1, ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED, R.string.rotation_free, R.drawable.ic_screen_rotation_24dp), - PORTRAIT(2, ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT, R.string.rotation_portrait, R.drawable.ic_stay_current_portrait_24dp), - LANDSCAPE(3, ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE, R.string.rotation_landscape, R.drawable.ic_stay_current_landscape_24dp), - LOCKED_PORTRAIT(4, ActivityInfo.SCREEN_ORIENTATION_PORTRAIT, R.string.rotation_force_portrait, R.drawable.ic_screen_lock_portrait_24dp), - LOCKED_LANDSCAPE(5, ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE, R.string.rotation_force_landscape, R.drawable.ic_screen_lock_landscape_24dp), - ; +enum class OrientationType(val prefValue: Int, val flag: Int, @StringRes val stringRes: Int, @DrawableRes val iconRes: Int, val flagValue: Int) { + // TODO Default icon + DEFAULT(0, ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED, R.string.default_rotation_type, R.drawable.ic_screen_rotation_24dp, 0x00000000), + FREE(1, ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED, R.string.rotation_free, R.drawable.ic_screen_rotation_24dp, 0x00000008), + PORTRAIT(2, ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT, R.string.rotation_portrait, R.drawable.ic_stay_current_portrait_24dp, 0x00000010), + LANDSCAPE(3, ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE, R.string.rotation_landscape, R.drawable.ic_stay_current_landscape_24dp, 0x00000018), + LOCKED_PORTRAIT(4, ActivityInfo.SCREEN_ORIENTATION_PORTRAIT, R.string.rotation_force_portrait, R.drawable.ic_screen_lock_portrait_24dp, 0x00000020), + LOCKED_LANDSCAPE(5, ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE, R.string.rotation_force_landscape, R.drawable.ic_screen_lock_landscape_24dp, 0x00000028); companion object { - fun fromPreference(preference: Int): OrientationType = - values().find { it.prefValue == preference } ?: FREE + const val MASK = 0x00000038 + + fun fromPreference(preference: Int?): OrientationType = values().find { it.flagValue == preference } ?: FREE + + fun fromSpinner(position: Int?) = values().find { value -> value.prefValue == position } ?: DEFAULT } } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReaderGeneralSettings.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReaderGeneralSettings.kt index 6d0785e2e..d621b17bd 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReaderGeneralSettings.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReaderGeneralSettings.kt @@ -36,7 +36,6 @@ class ReaderGeneralSettings @JvmOverloads constructor(context: Context, attrs: A * Init general reader preferences. */ private fun initGeneralPreferences() { - binding.rotationMode.bindToPreference(preferences.rotation(), 1) binding.backgroundColor.bindToIntPreference(preferences.readerTheme(), R.array.reader_themes_values) binding.showPageNumber.bindToPreference(preferences.showPageNumber()) binding.fullscreen.bindToPreference(preferences.fullscreen()) diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReaderReadingModeSettings.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReaderReadingModeSettings.kt index e1367b63f..01ae4741a 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReaderReadingModeSettings.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReaderReadingModeSettings.kt @@ -43,16 +43,23 @@ class ReaderReadingModeSettings @JvmOverloads constructor(context: Context, attr */ private fun initGeneralPreferences() { binding.viewer.onItemSelectedListener = { position -> - (context as ReaderActivity).presenter.setMangaViewer(position) + val readingModeType = ReadingModeType.fromSpinner(position) + (context as ReaderActivity).presenter.setMangaReadingMode(readingModeType.flagValue) - val mangaViewer = (context as ReaderActivity).presenter.getMangaViewer() - if (mangaViewer == ReadingModeType.WEBTOON.prefValue || mangaViewer == ReadingModeType.CONTINUOUS_VERTICAL.prefValue) { + val mangaViewer = (context as ReaderActivity).presenter.getMangaReadingMode() + if (mangaViewer == ReadingModeType.WEBTOON.flagValue || mangaViewer == ReadingModeType.CONTINUOUS_VERTICAL.flagValue) { initWebtoonPreferences() } else { initPagerPreferences() } } - binding.viewer.setSelection((context as ReaderActivity).presenter.manga?.viewer ?: 0) + binding.viewer.setSelection((context as ReaderActivity).presenter.manga?.readingModeType.let { ReadingModeType.fromPreference(it).prefValue }) + + binding.rotationMode.onItemSelectedListener = { position -> + val rotationType = OrientationType.fromSpinner(position) + (context as ReaderActivity).presenter.setMangaOrientationType(rotationType.flagValue) + } + binding.rotationMode.setSelection((context as ReaderActivity).presenter.manga?.orientationType.let { OrientationType.fromPreference(it).prefValue }) } /** diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReadingModeType.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReadingModeType.kt index 936546645..d38b39877 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReadingModeType.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReadingModeType.kt @@ -4,21 +4,25 @@ import androidx.annotation.DrawableRes import androidx.annotation.StringRes import eu.kanade.tachiyomi.R -enum class ReadingModeType(val prefValue: Int, @StringRes val stringRes: Int, @DrawableRes val iconRes: Int) { - DEFAULT(0, R.string.default_viewer, R.drawable.ic_reader_default_24dp), - LEFT_TO_RIGHT(1, R.string.left_to_right_viewer, R.drawable.ic_reader_ltr_24dp), - RIGHT_TO_LEFT(2, R.string.right_to_left_viewer, R.drawable.ic_reader_rtl_24dp), - VERTICAL(3, R.string.vertical_viewer, R.drawable.ic_reader_vertical_24dp), - WEBTOON(4, R.string.webtoon_viewer, R.drawable.ic_reader_webtoon_24dp), - CONTINUOUS_VERTICAL(5, R.string.vertical_plus_viewer, R.drawable.ic_reader_continuous_vertical_24dp), +enum class ReadingModeType(val prefValue: Int, @StringRes val stringRes: Int, @DrawableRes val iconRes: Int, val flagValue: Int) { + DEFAULT(0, R.string.default_viewer, R.drawable.ic_reader_default_24dp, 0x00000000), + LEFT_TO_RIGHT(1, R.string.left_to_right_viewer, R.drawable.ic_reader_ltr_24dp, 0x00000001), + RIGHT_TO_LEFT(2, R.string.right_to_left_viewer, R.drawable.ic_reader_rtl_24dp, 0x00000002), + VERTICAL(3, R.string.vertical_viewer, R.drawable.ic_reader_vertical_24dp, 0x00000003), + WEBTOON(4, R.string.webtoon_viewer, R.drawable.ic_reader_webtoon_24dp, 0x00000004), + CONTINUOUS_VERTICAL(5, R.string.vertical_plus_viewer, R.drawable.ic_reader_continuous_vertical_24dp, 0x00000005), ; companion object { - fun fromPreference(preference: Int): ReadingModeType = values().find { it.prefValue == preference } ?: DEFAULT + const val MASK = 0x00000007 + + fun fromPreference(preference: Int?): ReadingModeType = values().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 } + + fun fromSpinner(position: Int?) = values().find { value -> value.prefValue == position } ?: DEFAULT } } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/recent/history/HistoryPresenter.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/recent/history/HistoryPresenter.kt index 2890e5f00..0193d3df6 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/recent/history/HistoryPresenter.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/recent/history/HistoryPresenter.kt @@ -122,9 +122,9 @@ class HistoryPresenter : BasePresenter() { } val sortFunction: (Chapter, Chapter) -> Int = when (manga.sorting) { - Manga.SORTING_SOURCE -> { c1, c2 -> c2.source_order.compareTo(c1.source_order) } - Manga.SORTING_NUMBER -> { c1, c2 -> c1.chapter_number.compareTo(c2.chapter_number) } - Manga.SORTING_UPLOAD_DATE -> { c1, c2 -> c1.date_upload.compareTo(c2.date_upload) } + Manga.CHAPTER_SORTING_SOURCE -> { c1, c2 -> c2.source_order.compareTo(c1.source_order) } + Manga.CHAPTER_SORTING_NUMBER -> { c1, c2 -> c1.chapter_number.compareTo(c2.chapter_number) } + Manga.CHAPTER_SORTING_UPLOAD_DATE -> { c1, c2 -> c1.date_upload.compareTo(c2.date_upload) } else -> throw NotImplementedError("Unknown sorting method") } @@ -133,8 +133,8 @@ class HistoryPresenter : BasePresenter() { val currChapterIndex = chapters.indexOfFirst { chapter.id == it.id } return when (manga.sorting) { - Manga.SORTING_SOURCE -> chapters.getOrNull(currChapterIndex + 1) - Manga.SORTING_NUMBER -> { + Manga.CHAPTER_SORTING_SOURCE -> chapters.getOrNull(currChapterIndex + 1) + Manga.CHAPTER_SORTING_NUMBER -> { val chapterNumber = chapter.chapter_number ((currChapterIndex + 1) until chapters.size) @@ -144,7 +144,7 @@ class HistoryPresenter : BasePresenter() { it.chapter_number <= chapterNumber + 1 } } - Manga.SORTING_UPLOAD_DATE -> { + Manga.CHAPTER_SORTING_UPLOAD_DATE -> { chapters.drop(currChapterIndex + 1) .firstOrNull { it.date_upload >= chapter.date_upload } } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/setting/SettingsReaderController.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/setting/SettingsReaderController.kt index 7abaa8a05..5064fc6e3 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/setting/SettingsReaderController.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/setting/SettingsReaderController.kt @@ -5,6 +5,8 @@ import androidx.preference.PreferenceScreen import eu.kanade.tachiyomi.R import eu.kanade.tachiyomi.data.preference.PreferenceValues.TappingInvertMode import eu.kanade.tachiyomi.data.preference.asImmediateFlow +import eu.kanade.tachiyomi.ui.reader.setting.OrientationType +import eu.kanade.tachiyomi.ui.reader.setting.ReadingModeType import eu.kanade.tachiyomi.util.preference.defaultValue import eu.kanade.tachiyomi.util.preference.entriesRes import eu.kanade.tachiyomi.util.preference.intListPreference @@ -23,7 +25,7 @@ class SettingsReaderController : SettingsController() { titleRes = R.string.pref_category_reader intListPreference { - key = Keys.defaultViewer + key = Keys.defaultReadingMode titleRes = R.string.pref_viewer_type entriesRes = arrayOf( R.string.left_to_right_viewer, @@ -32,8 +34,9 @@ class SettingsReaderController : SettingsController() { R.string.webtoon_viewer, R.string.vertical_plus_viewer ) - entryValues = arrayOf("1", "2", "3", "4", "5") - defaultValue = "2" + entryValues = ReadingModeType.values().drop(1) + .map { value -> "${value.flagValue}" }.toTypedArray() + defaultValue = "${ReadingModeType.RIGHT_TO_LEFT.flagValue}" summary = "%s" } intListPreference { @@ -89,7 +92,7 @@ class SettingsReaderController : SettingsController() { titleRes = R.string.pref_category_display intListPreference { - key = Keys.rotation + key = Keys.defaultOrientationType titleRes = R.string.pref_rotation_type entriesRes = arrayOf( R.string.rotation_free, @@ -98,8 +101,9 @@ class SettingsReaderController : SettingsController() { R.string.rotation_force_portrait, R.string.rotation_force_landscape, ) - entryValues = arrayOf("1", "2", "3", "4", "5") - defaultValue = "1" + entryValues = OrientationType.values().drop(1) + .map { value -> "${value.flagValue}" }.toTypedArray() + defaultValue = "${OrientationType.FREE.flagValue}" summary = "%s" } intListPreference { diff --git a/app/src/main/java/eu/kanade/tachiyomi/util/chapter/ChapterSettingsHelper.kt b/app/src/main/java/eu/kanade/tachiyomi/util/chapter/ChapterSettingsHelper.kt index cccb214d6..b0b850e0b 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/util/chapter/ChapterSettingsHelper.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/util/chapter/ChapterSettingsHelper.kt @@ -17,7 +17,8 @@ object ChapterSettingsHelper { fun setGlobalSettings(manga: Manga?) { manga?.let { prefs.setChapterSettingsDefault(it) - db.updateFlags(it).executeAsBlocking() + db.updateChapterFlags(it).executeAsBlocking() + db.updateViewerFlags(it).executeAsBlocking() } } @@ -34,7 +35,8 @@ object ChapterSettingsHelper { setChapterOrder(prefs.sortChapterByAscendingOrDescending()) } - db.updateFlags(manga).executeAsBlocking() + db.updateChapterFlags(manga).executeAsBlocking() + db.updateViewerFlags(manga).executeAsBlocking() } /** @@ -54,7 +56,8 @@ object ChapterSettingsHelper { manga } - db.updateFlags(updatedMangas).executeAsBlocking() + db.updateChapterFlags(updatedMangas).executeAsBlocking() + db.updateViewerFlags(updatedMangas).executeAsBlocking() } } } diff --git a/app/src/main/java/exh/EXHMigrations.kt b/app/src/main/java/exh/EXHMigrations.kt index 1ef6cf62a..4d8983322 100644 --- a/app/src/main/java/exh/EXHMigrations.kt +++ b/app/src/main/java/exh/EXHMigrations.kt @@ -24,6 +24,7 @@ import eu.kanade.tachiyomi.source.SourceManager import eu.kanade.tachiyomi.source.model.SManga import eu.kanade.tachiyomi.source.online.all.Hitomi import eu.kanade.tachiyomi.source.online.all.NHentai +import eu.kanade.tachiyomi.ui.reader.setting.OrientationType import exh.log.xLogE import exh.log.xLogW import exh.merged.sql.models.MergedMangaReference @@ -230,13 +231,41 @@ object EXHMigrations { } if (oldVersion under 16) { // Reset rotation to Free after replacing Lock - preferences.rotation().set(1) + val prefs = PreferenceManager.getDefaultSharedPreferences(context) + if (prefs.contains("pref_rotation_type_key")) { + prefs.edit { + putInt("pref_rotation_type_key", 1) + } + } // Disable update check for Android 5.x users // if (BuildConfig.INCLUDE_UPDATER && Build.VERSION.SDK_INT under Build.VERSION_CODES.M) { // UpdaterJob.cancelTask(context) // } } + if (oldVersion under 17) { + // Migrate Rotation and Viewer values to default values for viewer_flags + val prefs = PreferenceManager.getDefaultSharedPreferences(context) + val newOrientation = when (prefs.getInt("pref_rotation_type_key", 1)) { + 1 -> OrientationType.FREE.flagValue + 2 -> OrientationType.PORTRAIT.flagValue + 3 -> OrientationType.LANDSCAPE.flagValue + 4 -> OrientationType.LOCKED_PORTRAIT.flagValue + 5 -> OrientationType.LOCKED_LANDSCAPE.flagValue + else -> OrientationType.FREE.flagValue + } + + // Reading mode flag and prefValue is the same value + val newReadingMode = prefs.getInt("pref_default_viewer_key", 1) + + prefs.edit { + putInt("pref_default_orientation_type_key", newOrientation) + remove("pref_rotation_type_key") + putInt("pref_default_reading_mode_key", newReadingMode) + remove("pref_default_viewer_key") + } + } + // if (oldVersion under 1) { } (1 is current release version) // do stuff here when releasing changed crap diff --git a/app/src/main/res/layout/reader_general_settings.xml b/app/src/main/res/layout/reader_general_settings.xml index 89615b46f..3421bdd8e 100644 --- a/app/src/main/res/layout/reader_general_settings.xml +++ b/app/src/main/res/layout/reader_general_settings.xml @@ -10,13 +10,6 @@ android:layout_height="wrap_content" android:orientation="vertical"> - - + + + app:title="@string/pref_category_reading_mode" /> + + + @string/default_rotation_type @string/rotation_free @string/rotation_portrait @string/rotation_landscape @@ -72,14 +73,6 @@ @string/rotation_force_landscape - - 1 - 2 - 3 - 4 - 5 - - @string/filter_mode_default @string/filter_mode_multiply diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 64d3e3358..35b23755a 100755 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -333,7 +333,9 @@ No animation Normal Fast - Rotation + Default rotation type + Default + Rotation type Free Portrait Landscape diff --git a/app/src/test/java/eu/kanade/tachiyomi/data/backup/BackupTest.kt b/app/src/test/java/eu/kanade/tachiyomi/data/backup/BackupTest.kt index ddd97e243..d234fa7eb 100644 --- a/app/src/test/java/eu/kanade/tachiyomi/data/backup/BackupTest.kt +++ b/app/src/test/java/eu/kanade/tachiyomi/data/backup/BackupTest.kt @@ -20,6 +20,8 @@ import eu.kanade.tachiyomi.data.database.models.MangaImpl import eu.kanade.tachiyomi.data.database.models.TrackImpl import eu.kanade.tachiyomi.source.SourceManager import eu.kanade.tachiyomi.source.online.HttpSource +import eu.kanade.tachiyomi.ui.reader.setting.OrientationType +import eu.kanade.tachiyomi.ui.reader.setting.ReadingModeType import kotlinx.coroutines.runBlocking import org.assertj.core.api.Assertions.assertThat import org.junit.Before @@ -156,12 +158,14 @@ class BackupTest { fun testRestoreManga() { // Add manga to database val manga = getSingleManga("One Piece") - manga.viewer = 3 + manga.readingModeType = ReadingModeType.VERTICAL.flagValue + manga.orientationType = OrientationType.PORTRAIT.flagValue manga.id = db.insertManga(manga).executeAsBlocking().insertedId() var favoriteManga = legacyBackupManager.databaseHelper.getFavoriteMangas().executeAsBlocking() assertThat(favoriteManga).hasSize(1) - assertThat(favoriteManga[0].viewer).isEqualTo(3) + assertThat(favoriteManga[0].readingModeType).isEqualTo(ReadingModeType.VERTICAL.flagValue) + assertThat(favoriteManga[0].orientationType).isEqualTo(OrientationType.PORTRAIT.flagValue) // Update json with all options enabled mangaEntries.add(legacyBackupManager.backupMangaObject(manga, 1)) @@ -173,7 +177,8 @@ class BackupTest { favoriteManga = legacyBackupManager.databaseHelper.getFavoriteMangas().executeAsBlocking() assertThat(favoriteManga).hasSize(1) - assertThat(favoriteManga[0].viewer).isEqualTo(0) + assertThat(favoriteManga[0].readingModeType).isEqualTo(ReadingModeType.DEFAULT.flagValue) + assertThat(favoriteManga[0].orientationType).isEqualTo(OrientationType.DEFAULT.flagValue) // Restore local manga legacyBackupManager.restoreMangaNoFetch(manga, dbManga) @@ -181,7 +186,8 @@ class BackupTest { // Test if restore successful favoriteManga = legacyBackupManager.databaseHelper.getFavoriteMangas().executeAsBlocking() assertThat(favoriteManga).hasSize(1) - assertThat(favoriteManga[0].viewer).isEqualTo(3) + assertThat(favoriteManga[0].readingModeType).isEqualTo(ReadingModeType.VERTICAL.flagValue) + assertThat(favoriteManga[0].orientationType).isEqualTo(OrientationType.PORTRAIT.flagValue) // Clear database to test manga fetch clearDatabase() @@ -207,7 +213,8 @@ class BackupTest { // Check if restore successful val dbCats = legacyBackupManager.databaseHelper.getFavoriteMangas().executeAsBlocking() assertThat(dbCats).hasSize(1) - assertThat(dbCats[0].viewer).isEqualTo(3) + assertThat(dbCats[0].readingModeType).isEqualTo(ReadingModeType.VERTICAL.flagValue) + assertThat(dbCats[0].orientationType).isEqualTo(OrientationType.PORTRAIT.flagValue) assertThat(dbCats[0].description).isEqualTo("This is a description") } }