UI adjust part 1

Currently translated at 100.0% (636 of 636 strings)

Co-authored-by: maryush <maryush@gmail.com>
Translate-URL: https://hosted.weblate.org/projects/kotatsu/strings/pl/
Translation: Kotatsu/Strings

app/build.gradle

@@ -16,8 +16,8 @@ android {
 		applicationId 'org.koitharu.kotatsu'
 		minSdk = 21
 		targetSdk = 34
-		versionCode = 629
-		versionName = '6.8-b1'
+		versionCode = 633
+		versionName = '6.8.3'
 		generatedDensities = []
 		testInstrumentationRunner 'org.koitharu.kotatsu.HiltTestRunner'
 		ksp {
@@ -82,7 +82,7 @@ afterEvaluate {
 }
 dependencies {
 	//noinspection GradleDependency
-	implementation('com.github.KotatsuApp:kotatsu-parsers:103ef11f3d') {
+	implementation('com.github.KotatsuApp:kotatsu-parsers:44ea9fe709') {
 		exclude group: 'org.json', module: 'json'
 	}
 
@@ -104,7 +104,7 @@ dependencies {
 	implementation 'androidx.viewpager2:viewpager2:1.1.0-beta02'
 	implementation 'androidx.preference:preference-ktx:1.2.1'
 	implementation 'androidx.biometric:biometric-ktx:1.2.0-alpha05'
-	implementation 'com.google.android.material:material:1.12.0-alpha03'
+	implementation 'com.google.android.material:material:1.12.0-beta01'
 	implementation 'androidx.lifecycle:lifecycle-common-java8:2.7.0'
 	implementation 'androidx.webkit:webkit:1.10.0'
 
@@ -127,8 +127,8 @@ dependencies {
 	implementation 'com.hannesdorfmann:adapterdelegates4-kotlin-dsl:4.3.2'
 	implementation 'com.hannesdorfmann:adapterdelegates4-kotlin-dsl-viewbinding:4.3.2'
 
-	implementation 'com.google.dagger:hilt-android:2.51'
-	kapt 'com.google.dagger:hilt-compiler:2.51'
+	implementation 'com.google.dagger:hilt-android:2.51.1'
+	kapt 'com.google.dagger:hilt-compiler:2.51.1'
 	implementation 'androidx.hilt:hilt-work:1.2.0'
 	kapt 'androidx.hilt:hilt-compiler:1.2.0'
 
@@ -161,6 +161,6 @@ dependencies {
 	androidTestImplementation 'androidx.room:room-testing:2.6.1'
 	androidTestImplementation 'com.squareup.moshi:moshi-kotlin:1.15.1'
 
-	androidTestImplementation 'com.google.dagger:hilt-android-testing:2.51'
-	kaptAndroidTest 'com.google.dagger:hilt-android-compiler:2.51'
+	androidTestImplementation 'com.google.dagger:hilt-android-testing:2.51.1'
+	kaptAndroidTest 'com.google.dagger:hilt-android-compiler:2.51.1'
 }

app/src/main/AndroidManifest.xml

@@ -94,6 +94,34 @@
 				<data android:host="kotatsu.app" />
 			</intent-filter>
 		</activity>
+		<activity
+			android:name="org.koitharu.kotatsu.details.ui.DetailsActivity2"
+			android:exported="true">
+			<intent-filter>
+				<action android:name="${applicationId}.action.VIEW_MANGA" />
+			</intent-filter>
+			<intent-filter android:autoVerify="true">
+				<action android:name="android.intent.action.VIEW" />
+
+				<category android:name="android.intent.category.DEFAULT" />
+				<category android:name="android.intent.category.BROWSABLE" />
+
+				<data android:scheme="http" />
+				<data android:scheme="https" />
+				<data android:host="kotatsu.app" />
+				<data android:path="/manga" />
+			</intent-filter>
+			<intent-filter>
+				<action android:name="android.intent.action.VIEW" />
+
+				<category android:name="android.intent.category.DEFAULT" />
+				<category android:name="android.intent.category.BROWSABLE" />
+
+				<data android:scheme="kotatsu" />
+				<data android:host="manga" />
+				<data android:host="kotatsu.app" />
+			</intent-filter>
+		</activity>
 		<activity
 			android:name="org.koitharu.kotatsu.reader.ui.ReaderActivity"
 			android:exported="true">

app/src/main/kotlin/org/koitharu/kotatsu/alternatives/domain/MigrateUseCase.kt

@@ -5,9 +5,7 @@ import org.koitharu.kotatsu.core.db.MangaDatabase
 import org.koitharu.kotatsu.core.model.getPreferredBranch
 import org.koitharu.kotatsu.core.parser.MangaDataRepository
 import org.koitharu.kotatsu.core.parser.MangaRepository
-import org.koitharu.kotatsu.details.domain.DetailsLoadUseCase
 import org.koitharu.kotatsu.details.domain.ProgressUpdateUseCase
-import org.koitharu.kotatsu.favourites.data.FavouriteEntity
 import org.koitharu.kotatsu.history.data.HistoryEntity
 import org.koitharu.kotatsu.history.data.PROGRESS_NONE
 import org.koitharu.kotatsu.history.data.toMangaHistory
@@ -21,7 +19,6 @@ class MigrateUseCase @Inject constructor(
 	private val mangaDataRepository: MangaDataRepository,
 	private val database: MangaDatabase,
 	private val progressUpdateUseCase: ProgressUpdateUseCase,
-	private val useCase: DetailsLoadUseCase
 ) {
 
 	suspend operator fun invoke(oldManga: Manga, newManga: Manga) {
@@ -41,16 +38,12 @@ class MigrateUseCase @Inject constructor(
 		database.withTransaction {
 			// replace favorites
 			val favoritesDao = database.getFavouritesDao()
-			val oldFavourite = favoritesDao.find(oldDetails.id)
-			if (oldFavourite != null) {
+			val oldFavourites = favoritesDao.findAllRaw(oldDetails.id)
+			if (oldFavourites.isNotEmpty()) {
 				favoritesDao.delete(oldManga.id)
-				for (f in oldFavourite.categories) {
-					val e = FavouriteEntity(
+				for (f in oldFavourites) {
+					val e = f.copy(
 						mangaId = newManga.id,
-						categoryId = f.categoryId.toLong(),
-						sortKey = f.sortKey,
-						createdAt = f.createdAt,
-						deletedAt = 0,
 					)
 					favoritesDao.upsert(e)
 				}

app/src/main/kotlin/org/koitharu/kotatsu/bookmarks/ui/BookmarksFragment.kt

@@ -25,6 +25,7 @@ import org.koitharu.kotatsu.core.ui.list.ListSelectionController
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.core.ui.list.fastscroll.FastScroller
 import org.koitharu.kotatsu.core.ui.util.ReversibleActionObserver
+import org.koitharu.kotatsu.core.util.ext.findAppCompatDelegate
 import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.core.util.ext.observeEvent
 import org.koitharu.kotatsu.databinding.FragmentListSimpleBinding
@@ -71,7 +72,7 @@ class BookmarksFragment :
 	) {
 		super.onViewBindingCreated(binding, savedInstanceState)
 		selectionController = ListSelectionController(
-			activity = requireActivity(),
+			appCompatDelegate = checkNotNull(findAppCompatDelegate()),
 			decoration = BookmarksSelectionDecoration(binding.root.context),
 			registryOwner = this,
 			callback = this,
@@ -100,7 +101,7 @@ class BookmarksFragment :
 		}
 		viewModel.onError.observeEvent(
 			viewLifecycleOwner,
-			SnackbarErrorObserver(binding.recyclerView, this)
+			SnackbarErrorObserver(binding.recyclerView, this),
 		)
 		viewModel.onActionDone.observeEvent(viewLifecycleOwner, ReversibleActionObserver(binding.recyclerView))
 	}
@@ -206,10 +207,11 @@ class BookmarksFragment :
 	companion object {
 
 		@Deprecated(
-			"", ReplaceWith(
+			"",
+			ReplaceWith(
 				"BookmarksFragment()",
-				"org.koitharu.kotatsu.bookmarks.ui.BookmarksFragment"
-			)
+				"org.koitharu.kotatsu.bookmarks.ui.BookmarksFragment",
+			),
 		)
 		fun newInstance() = BookmarksFragment()
 	}

app/src/main/kotlin/org/koitharu/kotatsu/bookmarks/ui/sheet/BookmarksSheet.kt

@@ -37,6 +37,7 @@ import org.koitharu.kotatsu.reader.ui.thumbnails.PageThumbnail
 import javax.inject.Inject
 import kotlin.math.roundToInt
 
+@Deprecated("")
 @AndroidEntryPoint
 class BookmarksSheet :
 	BaseAdaptiveSheet<SheetPagesBinding>(),

app/src/main/kotlin/org/koitharu/kotatsu/bookmarks/ui/sheet/BookmarksSheetViewModel.kt

@@ -21,6 +21,7 @@ import org.koitharu.kotatsu.list.ui.model.LoadingFooter
 import org.koitharu.kotatsu.parsers.util.SuspendLazy
 import javax.inject.Inject
 
+@Deprecated("")
 @HiltViewModel
 class BookmarksSheetViewModel @Inject constructor(
 	savedStateHandle: SavedStateHandle,

app/src/main/kotlin/org/koitharu/kotatsu/browser/BrowserActivity.kt

@@ -1,6 +1,5 @@
 package org.koitharu.kotatsu.browser
 
-import android.annotation.SuppressLint
 import android.content.ActivityNotFoundException
 import android.content.Context
 import android.content.Intent
@@ -12,18 +11,28 @@ import android.webkit.CookieManager
 import androidx.core.graphics.Insets
 import androidx.core.view.isVisible
 import androidx.core.view.updatePadding
+import dagger.hilt.android.AndroidEntryPoint
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.network.CommonHeaders
+import org.koitharu.kotatsu.core.parser.MangaRepository
+import org.koitharu.kotatsu.core.parser.RemoteMangaRepository
 import org.koitharu.kotatsu.core.ui.BaseActivity
 import org.koitharu.kotatsu.core.util.ext.configureForParser
+import org.koitharu.kotatsu.core.util.ext.getSerializableExtraCompat
 import org.koitharu.kotatsu.core.util.ext.toUriOrNull
 import org.koitharu.kotatsu.databinding.ActivityBrowserBinding
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import javax.inject.Inject
 import com.google.android.material.R as materialR
 
-@SuppressLint("SetJavaScriptEnabled")
+@AndroidEntryPoint
 class BrowserActivity : BaseActivity<ActivityBrowserBinding>(), BrowserCallback {
 
 	private lateinit var onBackPressedCallback: WebViewBackPressedCallback
 
+	@Inject
+	lateinit var mangaRepositoryFactory: MangaRepository.Factory
+
 	override fun onCreate(savedInstanceState: Bundle?) {
 		super.onCreate(savedInstanceState)
 		if (!setContentViewWebViewSafe { ActivityBrowserBinding.inflate(layoutInflater) }) {
@@ -33,7 +42,11 @@ class BrowserActivity : BaseActivity<ActivityBrowserBinding>(), BrowserCallback
 			setDisplayHomeAsUpEnabled(true)
 			setHomeAsUpIndicator(materialR.drawable.abc_ic_clear_material)
 		}
-		viewBinding.webView.configureForParser(null)
+		val userAgent = intent?.getSerializableExtraCompat<MangaSource>(EXTRA_SOURCE)?.let { source ->
+			val repository = mangaRepositoryFactory.create(source) as? RemoteMangaRepository
+			repository?.headers?.get(CommonHeaders.USER_AGENT)
+		}
+		viewBinding.webView.configureForParser(userAgent)
 		CookieManager.getInstance().setAcceptThirdPartyCookies(viewBinding.webView, true)
 		viewBinding.webView.webViewClient = BrowserClient(this)
 		viewBinding.webView.webChromeClient = ProgressChromeClient(viewBinding.progressBar)
@@ -54,16 +67,6 @@ class BrowserActivity : BaseActivity<ActivityBrowserBinding>(), BrowserCallback
 		}
 	}
 
-	override fun onSaveInstanceState(outState: Bundle) {
-		super.onSaveInstanceState(outState)
-		viewBinding.webView.saveState(outState)
-	}
-
-	override fun onRestoreInstanceState(savedInstanceState: Bundle) {
-		super.onRestoreInstanceState(savedInstanceState)
-		viewBinding.webView.restoreState(savedInstanceState)
-	}
-
 	override fun onCreateOptionsMenu(menu: Menu): Boolean {
 		super.onCreateOptionsMenu(menu)
 		menuInflater.inflate(R.menu.opt_browser, menu)
@@ -136,11 +139,13 @@ class BrowserActivity : BaseActivity<ActivityBrowserBinding>(), BrowserCallback
 	companion object {
 
 		private const val EXTRA_TITLE = "title"
+		private const val EXTRA_SOURCE = "source"
 
-		fun newIntent(context: Context, url: String, title: String?): Intent {
+		fun newIntent(context: Context, url: String, source: MangaSource?, title: String?): Intent {
 			return Intent(context, BrowserActivity::class.java)
 				.setData(Uri.parse(url))
 				.putExtra(EXTRA_TITLE, title)
+				.putExtra(EXTRA_SOURCE, source)
 		}
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/browser/cloudflare/CaptchaNotifier.kt

@@ -20,7 +20,7 @@ class CaptchaNotifier(
 ) : EventListener {
 
 	fun notify(exception: CloudFlareProtectedException) {
-		if (!context.checkNotificationPermission()) {
+		if (!context.checkNotificationPermission(CHANNEL_ID)) {
 			return
 		}
 		val manager = NotificationManagerCompat.from(context)

app/src/main/kotlin/org/koitharu/kotatsu/browser/cloudflare/CloudFlareActivity.kt

@@ -81,16 +81,6 @@ class CloudFlareActivity : BaseActivity<ActivityBrowserBinding>(), CloudFlareCal
 		super.onDestroy()
 	}
 
-	override fun onSaveInstanceState(outState: Bundle) {
-		super.onSaveInstanceState(outState)
-		viewBinding.webView.saveState(outState)
-	}
-
-	override fun onRestoreInstanceState(savedInstanceState: Bundle) {
-		super.onRestoreInstanceState(savedInstanceState)
-		viewBinding.webView.restoreState(savedInstanceState)
-	}
-
 	override fun onCreateOptionsMenu(menu: Menu?): Boolean {
 		menuInflater.inflate(R.menu.opt_captcha, menu)
 		return super.onCreateOptionsMenu(menu)

app/src/main/kotlin/org/koitharu/kotatsu/core/backup/BackupZipInput.kt

@@ -6,12 +6,14 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.runInterruptible
 import okio.Closeable
 import org.json.JSONArray
+import org.koitharu.kotatsu.core.exceptions.BadBackupFormatException
 import org.koitharu.kotatsu.core.util.ext.processLifecycleScope
 import java.io.File
 import java.util.EnumSet
+import java.util.zip.ZipException
 import java.util.zip.ZipFile
 
-class BackupZipInput(val file: File) : Closeable {
+class BackupZipInput private constructor(val file: File) : Closeable {
 
 	private val zipFile = ZipFile(file)
 
@@ -41,4 +43,17 @@ class BackupZipInput(val file: File) : Closeable {
 			}
 		}
 	}
+
+	companion object {
+
+		fun from(file: File): BackupZipInput = try {
+			val res = BackupZipInput(file)
+			if (res.zipFile.getEntry("index") == null) {
+				throw BadBackupFormatException(null)
+			}
+			res
+		} catch (e: ZipException) {
+			throw BadBackupFormatException(e)
+		}
+	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/core/db/MangaDatabase.kt

@@ -31,6 +31,7 @@ import org.koitharu.kotatsu.core.db.migrations.Migration15To16
 import org.koitharu.kotatsu.core.db.migrations.Migration16To17
 import org.koitharu.kotatsu.core.db.migrations.Migration17To18
 import org.koitharu.kotatsu.core.db.migrations.Migration18To19
+import org.koitharu.kotatsu.core.db.migrations.Migration19To20
 import org.koitharu.kotatsu.core.db.migrations.Migration1To2
 import org.koitharu.kotatsu.core.db.migrations.Migration2To3
 import org.koitharu.kotatsu.core.db.migrations.Migration3To4
@@ -57,7 +58,7 @@ import org.koitharu.kotatsu.tracker.data.TrackEntity
 import org.koitharu.kotatsu.tracker.data.TrackLogEntity
 import org.koitharu.kotatsu.tracker.data.TracksDao
 
-const val DATABASE_VERSION = 19
+const val DATABASE_VERSION = 20
 
 @Database(
 	entities = [
@@ -116,6 +117,7 @@ fun getDatabaseMigrations(context: Context): Array<Migration> = arrayOf(
 	Migration16To17(context),
 	Migration17To18(),
 	Migration18To19(),
+	Migration19To20(),
 )
 
 fun MangaDatabase(context: Context): MangaDatabase = Room

app/src/main/kotlin/org/koitharu/kotatsu/core/db/dao/TrackLogsDao.kt

@@ -1,6 +1,10 @@
 package org.koitharu.kotatsu.core.db.dao
 
-import androidx.room.*
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import androidx.room.Transaction
 import kotlinx.coroutines.flow.Flow
 import org.koitharu.kotatsu.tracker.data.TrackLogEntity
 import org.koitharu.kotatsu.tracker.data.TrackLogWithManga
@@ -24,6 +28,9 @@ interface TrackLogsDao {
 	@Query("DELETE FROM track_logs WHERE manga_id NOT IN (SELECT manga_id FROM tracks)")
 	suspend fun gc()
 
+	@Query("DELETE FROM track_logs WHERE id IN (SELECT id FROM track_logs ORDER BY created_at DESC LIMIT 0 OFFSET :size)")
+	suspend fun trim(size: Int)
+
 	@Query("SELECT COUNT(*) FROM track_logs")
 	suspend fun count(): Int
 }

app/src/main/kotlin/org/koitharu/kotatsu/core/db/migrations/Migration19To20.kt

@@ -0,0 +1,16 @@
+package org.koitharu.kotatsu.core.db.migrations
+
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
+
+class Migration19To20 : Migration(19, 20) {
+
+	override fun migrate(db: SupportSQLiteDatabase) {
+		db.execSQL("CREATE TABLE tracks_bk (manga_id INTEGER NOT NULL, chapters_total INTEGER NOT NULL, last_chapter_id INTEGER NOT NULL, chapters_new INTEGER NOT NULL, last_check INTEGER NOT NULL, last_notified_id INTEGER NOT NULL, PRIMARY KEY(manga_id))")
+		db.execSQL("INSERT INTO tracks_bk SELECT manga_id, chapters_total, last_chapter_id, chapters_new, last_check, last_notified_id FROM tracks")
+		db.execSQL("DROP TABLE tracks")
+		db.execSQL("CREATE TABLE tracks (`manga_id` INTEGER NOT NULL, `last_chapter_id` INTEGER NOT NULL, `chapters_new` INTEGER NOT NULL, `last_check_time` INTEGER NOT NULL, `last_chapter_date` INTEGER NOT NULL, `last_result` INTEGER NOT NULL, PRIMARY KEY(`manga_id`), FOREIGN KEY(`manga_id`) REFERENCES `manga`(`manga_id`) ON UPDATE NO ACTION ON DELETE CASCADE )")
+		db.execSQL("INSERT INTO tracks SELECT manga_id, last_chapter_id, chapters_new, last_check AS last_check_time, 0 AS last_chapter_date, 0 AS last_result FROM tracks_bk")
+		db.execSQL("DROP TABLE tracks_bk")
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/core/exceptions/BadBackupFormatException.kt

@@ -0,0 +1,5 @@
+package org.koitharu.kotatsu.core.exceptions
+
+import java.io.IOException
+
+class BadBackupFormatException(cause: Throwable?) : IOException(cause)

app/src/main/kotlin/org/koitharu/kotatsu/core/exceptions/NoDataReceivedException.kt

@@ -0,0 +1,7 @@
+package org.koitharu.kotatsu.core.exceptions
+
+import okio.IOException
+
+class NoDataReceivedException(
+	private val url: String,
+) : IOException("No data has been received from $url")

app/src/main/kotlin/org/koitharu/kotatsu/core/exceptions/resolve/ExceptionResolver.kt

@@ -82,7 +82,7 @@ class ExceptionResolver : ActivityResultCallback<TaggedActivityResult> {
 
 	private fun openInBrowser(url: String) {
 		val context = activity ?: fragment?.activity ?: return
-		context.startActivity(BrowserActivity.newIntent(context, url, null))
+		context.startActivity(BrowserActivity.newIntent(context, url, null, null))
 	}
 
 	private fun openAlternatives(manga: Manga) {

app/src/main/kotlin/org/koitharu/kotatsu/core/parser/MangaLoaderContextImpl.kt

@@ -16,6 +16,7 @@ import org.koitharu.kotatsu.core.network.cookies.MutableCookieJar
 import org.koitharu.kotatsu.core.prefs.SourceSettings
 import org.koitharu.kotatsu.core.util.ext.configureForParser
 import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
+import org.koitharu.kotatsu.core.util.ext.sanitizeHeaderValue
 import org.koitharu.kotatsu.core.util.ext.toList
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.parsers.config.MangaSourceConfig
@@ -41,7 +42,7 @@ class MangaLoaderContextImpl @Inject constructor(
 	private val userAgentLazy = SuspendLazy {
 		withContext(Dispatchers.Main) {
 			obtainWebView().settings.userAgentString
-		}
+		}.sanitizeHeaderValue()
 	}
 
 	@SuppressLint("SetJavaScriptEnabled")

app/src/main/kotlin/org/koitharu/kotatsu/core/prefs/AppSettings.kt

@@ -78,6 +78,10 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		get() = prefs.getInt(KEY_GRID_SIZE, 100)
 		set(value) = prefs.edit { putInt(KEY_GRID_SIZE, value) }
 
+	var gridSizePages: Int
+		get() = prefs.getInt(KEY_GRID_SIZE_PAGES, 100)
+		set(value) = prefs.edit { putInt(KEY_GRID_SIZE_PAGES, value) }
+
 	var historyListMode: ListMode
 		get() = prefs.getEnumValue(KEY_LIST_MODE_HISTORY, listMode)
 		set(value) = prefs.edit { putEnumValue(KEY_LIST_MODE_HISTORY, value) }
@@ -221,8 +225,15 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isUnstableUpdatesAllowed: Boolean
 		get() = prefs.getBoolean(KEY_UPDATES_UNSTABLE, false)
 
+	val isPagesTabEnabled: Boolean
+		get() = prefs.getBoolean(KEY_PAGES_TAB, true)
+
 	val defaultDetailsTab: Int
-		get() = prefs.getString(KEY_DETAILS_TAB, null)?.toIntOrNull()?.coerceIn(0, 1) ?: 0
+		get() = if (isPagesTabEnabled) {
+			prefs.getString(KEY_DETAILS_TAB, null)?.toIntOrNull()?.coerceIn(0, 1) ?: 0
+		} else {
+			0
+		}
 
 	val isContentPrefetchEnabled: Boolean
 		get() {
@@ -520,6 +531,7 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_SEARCH_HISTORY_CLEAR = "search_history_clear"
 		const val KEY_UPDATES_FEED_CLEAR = "updates_feed_clear"
 		const val KEY_GRID_SIZE = "grid_size"
+		const val KEY_GRID_SIZE_PAGES = "grid_size_pages"
 		const val KEY_REMOTE_SOURCES = "remote_sources"
 		const val KEY_LOCAL_STORAGE = "local_storage"
 		const val KEY_READER_DOUBLE_PAGES = "reader_double_pages"
@@ -622,6 +634,7 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_CF_INVERTED = "cf_inverted"
 		const val KEY_CF_GRAYSCALE = "cf_grayscale"
 		const val KEY_IGNORE_DOZE = "ignore_dose"
+		const val KEY_PAGES_TAB = "pages_tab"
 		const val KEY_DETAILS_TAB = "details_tab"
 		const val KEY_READING_TIME = "reading_time"
 		const val KEY_PAGES_SAVE_DIR = "pages_dir"

app/src/main/kotlin/org/koitharu/kotatsu/core/prefs/SourceSettings.kt

@@ -3,9 +3,11 @@ package org.koitharu.kotatsu.core.prefs
 import android.content.Context
 import android.content.SharedPreferences.OnSharedPreferenceChangeListener
 import androidx.core.content.edit
+import okhttp3.internal.isSensitiveHeader
 import org.koitharu.kotatsu.core.util.ext.getEnumValue
 import org.koitharu.kotatsu.core.util.ext.ifNullOrEmpty
 import org.koitharu.kotatsu.core.util.ext.putEnumValue
+import org.koitharu.kotatsu.core.util.ext.sanitizeHeaderValue
 import org.koitharu.kotatsu.parsers.config.ConfigKey
 import org.koitharu.kotatsu.parsers.config.MangaSourceConfig
 import org.koitharu.kotatsu.parsers.model.MangaSource
@@ -25,7 +27,10 @@ class SourceSettings(context: Context, source: MangaSource) : MangaSourceConfig
 	@Suppress("UNCHECKED_CAST")
 	override fun <T> get(key: ConfigKey<T>): T {
 		return when (key) {
-			is ConfigKey.UserAgent -> prefs.getString(key.key, key.defaultValue).ifNullOrEmpty { key.defaultValue }
+			is ConfigKey.UserAgent -> prefs.getString(key.key, key.defaultValue)
+				.ifNullOrEmpty { key.defaultValue }
+				.sanitizeHeaderValue()
+
 			is ConfigKey.Domain -> prefs.getString(key.key, key.defaultValue).ifNullOrEmpty { key.defaultValue }
 			is ConfigKey.ShowSuspiciousContent -> prefs.getBoolean(key.key, key.defaultValue)
 			is ConfigKey.SplitByTranslations -> prefs.getBoolean(key.key, key.defaultValue)
@@ -36,7 +41,7 @@ class SourceSettings(context: Context, source: MangaSource) : MangaSourceConfig
 		when (key) {
 			is ConfigKey.Domain -> putString(key.key, value as String?)
 			is ConfigKey.ShowSuspiciousContent -> putBoolean(key.key, value as Boolean)
-			is ConfigKey.UserAgent -> putString(key.key, value as String?)
+			is ConfigKey.UserAgent -> putString(key.key, (value as String?)?.sanitizeHeaderValue())
 			is ConfigKey.SplitByTranslations -> putBoolean(key.key, value as Boolean)
 		}
 	}

app/src/main/kotlin/org/koitharu/kotatsu/core/ui/BaseActivity.kt

@@ -127,11 +127,13 @@ abstract class BaseActivity<B : ViewBinding> :
 		val actionModeColor = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
 			ColorUtils.compositeColors(
 				ContextCompat.getColor(this, com.google.android.material.R.color.m3_appbar_overlay_color),
-				getThemeColor(R.attr.m3ColorBackground),
+				getThemeColor(com.google.android.material.R.attr.colorSurface),
 			)
 		} else {
-			ContextCompat.getColor(this, R.color.kotatsu_m3_background)
+			ContextCompat.getColor(this, R.color.kotatsu_background)
 		}
+		defaultStatusBarColor = window.statusBarColor
+		window.statusBarColor = actionModeColor
 		val insets = ViewCompat.getRootWindowInsets(viewBinding.root)
 			?.getInsets(WindowInsetsCompat.Type.systemBars()) ?: return
 		findViewById<ActionBarContextView?>(androidx.appcompat.R.id.action_mode_bar).apply {
@@ -140,8 +142,6 @@ abstract class BaseActivity<B : ViewBinding> :
 				topMargin = insets.top
 			}
 		}
-		defaultStatusBarColor = window.statusBarColor
-		window.statusBarColor = actionModeColor
 	}
 
 	@CallSuper

app/src/main/kotlin/org/koitharu/kotatsu/core/ui/list/ListSelectionController.kt

@@ -1,10 +1,9 @@
 package org.koitharu.kotatsu.core.ui.list
 
-import android.app.Activity
 import android.os.Bundle
 import android.view.Menu
 import android.view.MenuItem
-import androidx.appcompat.app.AppCompatActivity
+import androidx.appcompat.app.AppCompatDelegate
 import androidx.appcompat.view.ActionMode
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
@@ -20,7 +19,7 @@ private const val KEY_SELECTION = "selection"
 private const val PROVIDER_NAME = "selection_decoration"
 
 class ListSelectionController(
-	private val activity: Activity,
+	private val appCompatDelegate: AppCompatDelegate,
 	private val decoration: AbstractSelectionItemDecoration,
 	private val registryOwner: SavedStateRegistryOwner,
 	private val callback: Callback2,
@@ -108,7 +107,7 @@ class ListSelectionController(
 
 	private fun startActionMode() {
 		if (actionMode == null) {
-			actionMode = (activity as? AppCompatActivity)?.startSupportActionMode(this)
+			actionMode = appCompatDelegate.startSupportActionMode(this)
 		}
 	}
 

app/src/main/kotlin/org/koitharu/kotatsu/core/ui/sheet/BaseAdaptiveSheet.kt

@@ -1,25 +1,39 @@
 package org.koitharu.kotatsu.core.ui.sheet
 
 import android.app.Dialog
+import android.content.Context
+import android.graphics.Color
+import android.os.Build
 import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.view.ViewGroup.LayoutParams
 import androidx.activity.OnBackPressedDispatcher
+import androidx.annotation.CallSuper
+import androidx.appcompat.app.AppCompatDialog
 import androidx.appcompat.app.AppCompatDialogFragment
+import androidx.appcompat.view.ActionMode
+import androidx.appcompat.widget.ActionBarContextView
+import androidx.core.content.ContextCompat
+import androidx.core.graphics.ColorUtils
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.updateLayoutParams
 import androidx.viewbinding.ViewBinding
 import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.android.material.bottomsheet.BottomSheetDialog
 import com.google.android.material.sidesheet.SideSheetDialog
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.ui.util.ActionModeDelegate
+import org.koitharu.kotatsu.core.util.ext.getThemeColor
 import com.google.android.material.R as materialR
 
 abstract class BaseAdaptiveSheet<B : ViewBinding> : AppCompatDialogFragment() {
 
 	private var waitingForDismissAllowingStateLoss = false
 	private var isFitToContentsDisabled = false
+	private var defaultStatusBarColor = Color.TRANSPARENT
 
 	var viewBinding: B? = null
 		private set
@@ -31,12 +45,19 @@ abstract class BaseAdaptiveSheet<B : ViewBinding> : AppCompatDialogFragment() {
 	protected val behavior: AdaptiveSheetBehavior?
 		get() = AdaptiveSheetBehavior.from(dialog)
 
+	@JvmField
+	val actionModeDelegate = ActionModeDelegate()
+
 	val isExpanded: Boolean
 		get() = behavior?.state == AdaptiveSheetBehavior.STATE_EXPANDED
 
 	val onBackPressedDispatcher: OnBackPressedDispatcher
 		get() = requireComponentDialog().onBackPressedDispatcher
 
+	var isLocked = false
+		private set
+	private var lockCounter = 0
+
 	final override fun onCreateView(
 		inflater: LayoutInflater,
 		container: ViewGroup?,
@@ -60,11 +81,45 @@ abstract class BaseAdaptiveSheet<B : ViewBinding> : AppCompatDialogFragment() {
 
 	override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
 		val context = requireContext()
-		return if (context.resources.getBoolean(R.bool.is_tablet)) {
-			SideSheetDialog(context, theme)
+		val dialog = if (context.resources.getBoolean(R.bool.is_tablet)) {
+			SideSheetDialogImpl(context, theme)
 		} else {
-			BottomSheetDialog(context, theme)
+			BottomSheetDialogImpl(context, theme)
 		}
+		dialog.onBackPressedDispatcher.addCallback(actionModeDelegate)
+		return dialog
+	}
+
+	@CallSuper
+	protected open fun dispatchSupportActionModeStarted(mode: ActionMode) {
+		actionModeDelegate.onSupportActionModeStarted(mode)
+		val ctx = requireContext()
+		val actionModeColor = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+			ColorUtils.compositeColors(
+				ContextCompat.getColor(ctx, com.google.android.material.R.color.m3_appbar_overlay_color),
+				ctx.getThemeColor(com.google.android.material.R.attr.colorSurface),
+			)
+		} else {
+			ContextCompat.getColor(ctx, R.color.kotatsu_surface)
+		}
+		dialog?.window?.let {
+			defaultStatusBarColor = it.statusBarColor
+			it.statusBarColor = actionModeColor
+		}
+		val insets = ViewCompat.getRootWindowInsets(requireView())
+			?.getInsets(WindowInsetsCompat.Type.systemBars()) ?: return
+		dialog?.window?.decorView?.findViewById<ActionBarContextView?>(androidx.appcompat.R.id.action_mode_bar)?.apply {
+			setBackgroundColor(actionModeColor)
+			updateLayoutParams<ViewGroup.MarginLayoutParams> {
+				topMargin = insets.top
+			}
+		}
+	}
+
+	@CallSuper
+	protected open fun dispatchSupportActionModeFinished(mode: ActionMode) {
+		actionModeDelegate.onSupportActionModeFinished(mode)
+		dialog?.window?.statusBarColor = defaultStatusBarColor
 	}
 
 	fun addSheetCallback(callback: AdaptiveSheetCallback) {
@@ -81,7 +136,16 @@ abstract class BaseAdaptiveSheet<B : ViewBinding> : AppCompatDialogFragment() {
 
 	protected open fun onViewBindingCreated(binding: B, savedInstanceState: Bundle?) = Unit
 
+	fun startSupportActionMode(callback: ActionMode.Callback): ActionMode? {
+		val appCompatDialog = dialog as? AppCompatDialog ?: return null
+		return appCompatDialog.delegate.startSupportActionMode(callback)
+	}
+
 	protected fun setExpanded(isExpanded: Boolean, isLocked: Boolean) {
+		this.isLocked = isLocked
+		if (!isLocked) {
+			lockCounter = 0
+		}
 		val b = behavior ?: return
 		if (isExpanded) {
 			b.state = BottomSheetBehavior.STATE_EXPANDED
@@ -109,6 +173,20 @@ abstract class BaseAdaptiveSheet<B : ViewBinding> : AppCompatDialogFragment() {
 		}
 	}
 
+	@CallSuper
+	open fun expandAndLock() {
+		lockCounter++
+		setExpanded(isExpanded = true, isLocked = true)
+	}
+
+	@CallSuper
+	open fun unlock() {
+		lockCounter--
+		if (lockCounter <= 0) {
+			setExpanded(isExpanded, false)
+		}
+	}
+
 	fun requireViewBinding(): B = checkNotNull(viewBinding) {
 		"Fragment $this did not return a ViewBinding from onCreateView() or this was called before onCreateView()."
 	}
@@ -171,4 +249,38 @@ abstract class BaseAdaptiveSheet<B : ViewBinding> : AppCompatDialogFragment() {
 
 		override fun onSlide(sheet: View, slideOffset: Float) {}
 	}
+
+	private inner class SideSheetDialogImpl(context: Context, theme: Int) : SideSheetDialog(context, theme) {
+
+		override fun onSupportActionModeStarted(mode: ActionMode?) {
+			super.onSupportActionModeStarted(mode)
+			if (mode != null) {
+				dispatchSupportActionModeStarted(mode)
+			}
+		}
+
+		override fun onSupportActionModeFinished(mode: ActionMode?) {
+			super.onSupportActionModeFinished(mode)
+			if (mode != null) {
+				dispatchSupportActionModeFinished(mode)
+			}
+		}
+	}
+
+	private inner class BottomSheetDialogImpl(context: Context, theme: Int) : BottomSheetDialog(context, theme) {
+
+		override fun onSupportActionModeStarted(mode: ActionMode?) {
+			super.onSupportActionModeStarted(mode)
+			if (mode != null) {
+				dispatchSupportActionModeStarted(mode)
+			}
+		}
+
+		override fun onSupportActionModeFinished(mode: ActionMode?) {
+			super.onSupportActionModeFinished(mode)
+			if (mode != null) {
+				dispatchSupportActionModeFinished(mode)
+			}
+		}
+	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/core/ui/widgets/ChipsView.kt

@@ -110,7 +110,7 @@ class ChipsView @JvmOverloads constructor(
 		chip.isChipIconVisible = false
 		chip.isCloseIconVisible = onChipCloseClickListener != null
 		chip.setOnCloseIconClickListener(chipOnCloseListener)
-		chip.setEnsureMinTouchTargetSize(false) // TODO remove
+		chip.setEnsureMinTouchTargetSize(false)
 		chip.setOnClickListener(chipOnClickListener)
 		addView(chip)
 		return chip

app/src/main/kotlin/org/koitharu/kotatsu/core/ui/widgets/CoverImageView.kt

@@ -10,8 +10,8 @@ import com.google.android.material.imageview.ShapeableImageView
 import org.koitharu.kotatsu.R
 import kotlin.math.roundToInt
 
-private const val ASPECT_RATIO_HEIGHT = 18f
-private const val ASPECT_RATIO_WIDTH = 13f
+private const val ASPECT_RATIO_HEIGHT = 3f
+private const val ASPECT_RATIO_WIDTH = 2f
 
 class CoverImageView @JvmOverloads constructor(
 	context: Context,

app/src/main/kotlin/org/koitharu/kotatsu/core/ui/widgets/ProgressButton.kt

@@ -0,0 +1,155 @@
+package org.koitharu.kotatsu.core.ui.widgets
+
+import android.animation.ValueAnimator
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Outline
+import android.graphics.Paint
+import android.util.AttributeSet
+import android.view.Gravity
+import android.view.View
+import android.view.ViewOutlineProvider
+import android.view.animation.AccelerateDecelerateInterpolator
+import android.widget.TextView
+import androidx.annotation.StringRes
+import androidx.appcompat.widget.LinearLayoutCompat
+import androidx.core.content.withStyledAttributes
+import androidx.core.view.children
+import androidx.core.widget.TextViewCompat
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.util.ext.getAnimationDuration
+import org.koitharu.kotatsu.core.util.ext.getThemeColor
+import org.koitharu.kotatsu.core.util.ext.resolveDp
+import org.koitharu.kotatsu.core.util.ext.setTextAndVisible
+import org.koitharu.kotatsu.core.util.ext.textAndVisible
+import com.google.android.material.R as materialR
+
+class ProgressButton @JvmOverloads constructor(
+	context: Context,
+	attrs: AttributeSet? = null,
+	defStyleAttr: Int = 0,
+) : LinearLayoutCompat(context, attrs, defStyleAttr), ValueAnimator.AnimatorUpdateListener {
+
+	private val textViewTitle = TextView(context)
+	private val textViewSubtitle = TextView(context)
+	private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+
+	private var progress = 0f
+	private var colorBase = context.getThemeColor(materialR.attr.colorPrimaryContainer)
+	private var colorProgress = context.getThemeColor(materialR.attr.colorPrimary)
+	private var colorText = context.getThemeColor(materialR.attr.colorOnPrimaryContainer)
+	private var progressAnimator: ValueAnimator? = null
+
+	var title: CharSequence?
+		get() = textViewTitle.textAndVisible
+		set(value) {
+			textViewTitle.textAndVisible = value
+		}
+
+	var subtitle: CharSequence?
+		get() = textViewSubtitle.textAndVisible
+		set(value) {
+			textViewSubtitle.textAndVisible = value
+		}
+
+	init {
+		orientation = VERTICAL
+		outlineProvider = OutlineProvider()
+		clipToOutline = true
+
+		context.withStyledAttributes(attrs, R.styleable.ProgressButton, defStyleAttr) {
+			val textAppearanceFallback = androidx.appcompat.R.style.TextAppearance_AppCompat
+			TextViewCompat.setTextAppearance(
+				textViewTitle,
+				getResourceId(R.styleable.ProgressButton_titleTextAppearance, textAppearanceFallback),
+			)
+			TextViewCompat.setTextAppearance(
+				textViewSubtitle,
+				getResourceId(R.styleable.ProgressButton_subtitleTextAppearance, textAppearanceFallback),
+			)
+			textViewTitle.text = getText(R.styleable.ProgressButton_title)
+			textViewSubtitle.text = getText(R.styleable.ProgressButton_subtitle)
+			colorBase = getColor(R.styleable.ProgressButton_baseColor, colorBase)
+			colorProgress = getColor(R.styleable.ProgressButton_progressColor, colorProgress)
+			colorText = getColor(R.styleable.ProgressButton_textColor, colorText)
+			textViewTitle.setTextColor(colorText)
+			textViewSubtitle.setTextColor(colorText)
+			progress = getInt(R.styleable.ProgressButton_android_progress, 0).toFloat() /
+				getInt(R.styleable.ProgressButton_android_max, 100).toFloat()
+		}
+
+		addView(textViewTitle, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT))
+		addView(
+			textViewSubtitle,
+			LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT).also { lp ->
+				lp.topMargin = context.resources.resolveDp(2)
+			},
+		)
+
+		paint.style = Paint.Style.FILL
+		paint.color = colorProgress
+		paint.alpha = 84 // 255 * 0.33F
+		applyGravity()
+		setWillNotDraw(false)
+	}
+
+	override fun onDraw(canvas: Canvas) {
+		super.onDraw(canvas)
+		canvas.drawColor(colorBase)
+		canvas.drawRect(0f, 0f, width * progress, height.toFloat(), paint)
+	}
+
+	override fun setGravity(gravity: Int) {
+		super.setGravity(gravity)
+		if (childCount != 0) {
+			applyGravity()
+		}
+	}
+
+	override fun setEnabled(enabled: Boolean) {
+		super.setEnabled(enabled)
+		children.forEach { it.isEnabled = enabled }
+	}
+
+	override fun onAnimationUpdate(animation: ValueAnimator) {
+		progress = animation.animatedValue as Float
+		invalidate()
+	}
+
+	fun setTitle(@StringRes titleResId: Int) {
+		textViewTitle.setTextAndVisible(titleResId)
+	}
+
+	fun setSubtitle(@StringRes titleResId: Int) {
+		textViewSubtitle.setTextAndVisible(titleResId)
+	}
+
+	fun setProgress(value: Float, animate: Boolean) {
+		progressAnimator?.cancel()
+		if (animate) {
+			progressAnimator = ValueAnimator.ofFloat(progress, value).apply {
+				duration = context.getAnimationDuration(android.R.integer.config_shortAnimTime)
+				interpolator = AccelerateDecelerateInterpolator()
+				addUpdateListener(this@ProgressButton)
+				start()
+			}
+		} else {
+			progressAnimator = null
+			progress = value
+			invalidate()
+		}
+	}
+
+	private fun applyGravity() {
+		val value = (gravity and Gravity.HORIZONTAL_GRAVITY_MASK) or Gravity.CENTER_VERTICAL
+		textViewTitle.gravity = value
+		textViewSubtitle.gravity = value
+	}
+
+	private class OutlineProvider : ViewOutlineProvider() {
+
+		override fun getOutline(view: View, outline: Outline) {
+			outline.setRoundRect(0, 0, view.width, view.height, view.height / 2f)
+		}
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/core/ui/widgets/TipView.kt

@@ -75,7 +75,7 @@ class TipView @JvmOverloads constructor(
 			val shapeAppearanceModel = ShapeAppearanceModel.builder(context, attrs, defStyleAttr, 0).build()
 			background = MaterialShapeDrawable(shapeAppearanceModel).also {
 				it.fillColor = getColorStateList(R.styleable.TipView_cardBackgroundColor)
-					?: context.getThemeColorStateList(R.attr.m3ColorExploreButton)
+					?: context.getThemeColorStateList(com.google.android.material.R.attr.colorSurfaceContainerHigh)
 				it.strokeWidth = getDimension(R.styleable.TipView_strokeWidth, 0f)
 				it.strokeColor = getColorStateList(R.styleable.TipView_strokeColor)
 				it.elevation = getDimension(R.styleable.TipView_elevation, 0f)

app/src/main/kotlin/org/koitharu/kotatsu/core/util/KotatsuColors.kt

@@ -33,7 +33,7 @@ object KotatsuColors {
 			val hue = (manga.id.absoluteValue % 360).toFloat()
 			ColorUtils.HSLToColor(floatArrayOf(hue, 0.5f, 0.5f))
 		} else {
-			context.getThemeColor(R.attr.colorSurface)
+			context.getThemeColor(R.attr.colorOutline)
 		}
 		val backgroundColor = context.getThemeColor(R.attr.colorSurfaceContainerHigh)
 		return MaterialColors.harmonize(color, backgroundColor)

app/src/main/kotlin/org/koitharu/kotatsu/core/util/ext/Android.kt

@@ -14,7 +14,7 @@ import android.content.ContextWrapper
 import android.content.OperationApplicationException
 import android.content.SharedPreferences
 import android.content.SyncResult
-import android.content.pm.PackageManager
+import android.content.pm.PackageManager.PERMISSION_GRANTED
 import android.content.pm.ResolveInfo
 import android.database.SQLException
 import android.graphics.Bitmap
@@ -31,10 +31,15 @@ import android.webkit.WebView
 import androidx.activity.result.ActivityResultLauncher
 import androidx.annotation.IntegerRes
 import androidx.annotation.WorkerThread
+import androidx.appcompat.app.AppCompatActivity
+import androidx.appcompat.app.AppCompatDelegate
+import androidx.appcompat.app.AppCompatDialog
 import androidx.core.app.ActivityOptionsCompat
 import androidx.core.app.NotificationManagerCompat
 import androidx.core.content.ContextCompat
 import androidx.core.os.LocaleListCompat
+import androidx.fragment.app.DialogFragment
+import androidx.fragment.app.Fragment
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.coroutineScope
 import androidx.work.CoroutineWorker
@@ -136,7 +141,7 @@ fun Window.setNavigationBarTransparentCompat(context: Context, elevation: Float,
 	} else {
 		// Set navbar scrim 70% of navigationBarColor
 		ElevationOverlayProvider(context).compositeOverlayIfNeeded(
-			context.getThemeColor(R.attr.m3ColorBottomMenuBackground, alphaFactor),
+			context.getThemeColor(com.google.android.material.R.attr.colorSurfaceContainer, alphaFactor),
 			elevation,
 		)
 	}
@@ -216,10 +221,26 @@ fun Context.findActivity(): Activity? = when (this) {
 	else -> null
 }
 
-fun Context.checkNotificationPermission(): Boolean = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-	ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED
-} else {
-	NotificationManagerCompat.from(this).areNotificationsEnabled()
+fun Fragment.findAppCompatDelegate(): AppCompatDelegate? {
+	((this as? DialogFragment)?.dialog as? AppCompatDialog)?.run {
+		return delegate
+	}
+	return parentFragment?.findAppCompatDelegate() ?: (activity as? AppCompatActivity)?.delegate
+}
+
+fun Context.checkNotificationPermission(channelId: String?): Boolean {
+	val hasPermission = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+		ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) == PERMISSION_GRANTED
+	} else {
+		NotificationManagerCompat.from(this).areNotificationsEnabled()
+	}
+	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && hasPermission && channelId != null) {
+		val channel = NotificationManagerCompat.from(this).getNotificationChannel(channelId)
+		if (channel != null && channel.importance == NotificationManagerCompat.IMPORTANCE_NONE) {
+			return false
+		}
+	}
+	return hasPermission
 }
 
 @WorkerThread

app/src/main/kotlin/org/koitharu/kotatsu/core/util/ext/Coil.kt

@@ -25,7 +25,7 @@ fun ImageView.newImageRequest(lifecycleOwner: LifecycleOwner, data: Any?): Image
 	}
 	// disposeImageRequest()
 	return ImageRequest.Builder(context)
-		.data(data?.takeUnless { it == "" })
+		.data(data?.takeUnless { it == "" || it == 0 })
 		.lifecycle(lifecycleOwner)
 		.crossfade(context)
 		.target(this)

app/src/main/kotlin/org/koitharu/kotatsu/core/util/ext/Date.kt

@@ -18,6 +18,7 @@ fun calculateTimeAgo(instant: Instant, showMonths: Boolean = false): DateTimeAgo
 			if (instant.until(Instant.now(), ChronoUnit.MINUTES) < 3) DateTimeAgo.JustNow
 			else DateTimeAgo.Today
 		}
+
 		diffDays == 1L -> DateTimeAgo.Yesterday
 		diffDays < 6 -> DateTimeAgo.DaysAgo(diffDays.toInt())
 		else -> {
@@ -30,3 +31,5 @@ fun calculateTimeAgo(instant: Instant, showMonths: Boolean = false): DateTimeAgo
 		}
 	}
 }
+
+fun Long.toInstantOrNull() = if (this == 0L) null else Instant.ofEpochMilli(this)

app/src/main/kotlin/org/koitharu/kotatsu/core/util/ext/Fragment.kt

@@ -60,3 +60,25 @@ fun DialogFragment.showDistinct(fm: FragmentManager, tag: String) {
 	}
 	show(fm, tag)
 }
+
+tailrec fun Fragment.dismissParentDialog(): Boolean {
+	return when (val parent = parentFragment) {
+		null -> return false
+		is DialogFragment -> {
+			parent.dismiss()
+			true
+		}
+
+		else -> parent.dismissParentDialog()
+	}
+}
+
+@Suppress("UNCHECKED_CAST")
+tailrec fun <T> Fragment.findParentCallback(cls: Class<T>): T? {
+	val parent = parentFragment
+	return when {
+		parent == null -> cls.castOrNull(activity)
+		cls.isInstance(parent) -> parent as T
+		else -> parent.findParentCallback(cls)
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/core/util/ext/Http.kt

@@ -1,11 +1,13 @@
 package org.koitharu.kotatsu.core.util.ext
 
 import okhttp3.Cookie
+import okhttp3.Headers
 import okhttp3.HttpUrl
 import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.RequestBody.Companion.toRequestBody
 import okhttp3.Response
 import okhttp3.internal.closeQuietly
+import okhttp3.internal.isSensitiveHeader
 import okio.IOException
 import org.json.JSONObject
 import org.jsoup.HttpStatusException
@@ -59,3 +61,16 @@ fun Cookie.newBuilder(): Cookie.Builder = Cookie.Builder().also { c ->
 		c.httpOnly()
 	}
 }
+
+fun String.sanitizeHeaderValue(): String {
+	return if (all(Char::isValidForHeaderValue)) {
+		this // fast path
+	} else {
+		filter(Char::isValidForHeaderValue)
+	}
+}
+
+private fun Char.isValidForHeaderValue(): Boolean {
+	// from okhttp3.Headers$Companion.checkValue
+	return this == '\t' || this in '\u0020'..'\u007e'
+}

app/src/main/kotlin/org/koitharu/kotatsu/core/util/ext/Primitive.kt

@@ -2,6 +2,8 @@ package org.koitharu.kotatsu.core.util.ext
 
 inline fun Int.ifZero(defaultValue: () -> Int): Int = if (this == 0) defaultValue() else this
 
+inline fun Long.ifZero(defaultValue: () -> Long): Long = if (this == 0L) defaultValue() else this
+
 fun longOf(a: Int, b: Int): Long {
 	return a.toLong() shl 32 or (b.toLong() and 0xffffffffL)
 }

app/src/main/kotlin/org/koitharu/kotatsu/core/util/ext/Throwable.kt

@@ -8,12 +8,13 @@ import coil.network.HttpException
 import okio.FileNotFoundException
 import okio.IOException
 import org.acra.ktx.sendWithAcra
-import org.json.JSONException
 import org.jsoup.HttpStatusException
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.exceptions.BadBackupFormatException
 import org.koitharu.kotatsu.core.exceptions.CaughtException
 import org.koitharu.kotatsu.core.exceptions.CloudFlareProtectedException
 import org.koitharu.kotatsu.core.exceptions.EmptyHistoryException
+import org.koitharu.kotatsu.core.exceptions.NoDataReceivedException
 import org.koitharu.kotatsu.core.exceptions.SyncApiException
 import org.koitharu.kotatsu.core.exceptions.TooManyRequestExceptions
 import org.koitharu.kotatsu.core.exceptions.UnsupportedFileException
@@ -43,6 +44,7 @@ fun Throwable.getDisplayMessage(resources: Resources): String = when (this) {
 
 	is TooManyRequestExceptions -> resources.getString(R.string.too_many_requests_message)
 	is UnsupportedFileException -> resources.getString(R.string.text_file_not_supported)
+	is BadBackupFormatException -> resources.getString(R.string.unsupported_backup_message)
 	is FileNotFoundException -> resources.getString(R.string.file_not_found)
 	is AccessDeniedException -> resources.getString(R.string.no_access_to_file)
 	is EmptyHistoryException -> resources.getString(R.string.history_is_empty)
@@ -55,6 +57,8 @@ fun Throwable.getDisplayMessage(resources: Resources): String = when (this) {
 	is SocketTimeoutException,
 	-> resources.getString(R.string.network_error)
 
+	is NoDataReceivedException -> resources.getString(R.string.error_no_data_received)
+
 	is WrongPasswordException -> resources.getString(R.string.wrong_password)
 	is NotFoundException -> resources.getString(R.string.not_found_404)
 	is UnsupportedSourceException -> resources.getString(R.string.unsupported_source)
@@ -110,13 +114,12 @@ fun Throwable.report() {
 }
 
 private val reportableExceptions = arraySetOf<Class<*>>(
-	ParseException::class.java,
-	JSONException::class.java,
 	RuntimeException::class.java,
 	IllegalStateException::class.java,
 	IllegalArgumentException::class.java,
 	ConcurrentModificationException::class.java,
 	UnsupportedOperationException::class.java,
+	NoDataReceivedException::class.java,
 )
 
 fun Throwable.isWebViewUnavailable(): Boolean {

app/src/main/kotlin/org/koitharu/kotatsu/details/data/ReadingTime.kt

@@ -19,4 +19,11 @@ data class ReadingTime(
 			resources.getQuantityString(R.plurals.minutes, minutes, minutes),
 		)
 	}
+
+	fun formatShort(resources: Resources): String? = when {
+		hours == 0 && minutes == 0 -> null
+		hours == 0 -> resources.getString(R.string.minutes_short, minutes)
+		minutes == 0 -> resources.getString(R.string.hours_short, hours)
+		else -> resources.getString(R.string.hours_minutes_short, hours, minutes)
+	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/details/domain/DetailsInteractor.kt

@@ -6,6 +6,7 @@ import kotlinx.coroutines.flow.distinctUntilChangedBy
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.map
+import org.koitharu.kotatsu.core.model.FavouriteCategory
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.prefs.observeAsFlow
 import org.koitharu.kotatsu.details.data.MangaDetails
@@ -35,6 +36,10 @@ class DetailsInteractor @Inject constructor(
 			.map { it.isNotEmpty() }
 	}
 
+	fun observeFavourite(mangaId: Long): Flow<Set<FavouriteCategory>> {
+		return favouritesRepository.observeCategories(mangaId)
+	}
+
 	fun observeNewChapters(mangaId: Long): Flow<Int> {
 		return settings.observeAsFlow(AppSettings.KEY_TRACKER_ENABLED) { isTrackerEnabled }
 			.flatMapLatest { isEnabled ->

app/src/main/kotlin/org/koitharu/kotatsu/details/domain/DetailsLoadUseCase.kt

@@ -54,7 +54,8 @@ class DetailsLoadUseCase @Inject constructor(
 		} catch (e: IOException) {
 			local?.await()?.manga?.also { localManga ->
 				send(MangaDetails(localManga, null, localManga.description?.parseAsHtml(withImages = false), true))
-			} ?: throw e
+			}
+			throw e
 		}
 	}
 

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/ChapterPagesMenuProvider.kt

@@ -0,0 +1,126 @@
+package org.koitharu.kotatsu.details.ui
+
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
+import androidx.activity.OnBackPressedCallback
+import androidx.appcompat.widget.SearchView
+import androidx.core.view.MenuProvider
+import androidx.viewpager2.widget.ViewPager2
+import com.google.android.material.slider.LabelFormatter
+import com.google.android.material.slider.Slider
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.core.ui.sheet.BaseAdaptiveSheet
+import org.koitharu.kotatsu.core.util.ext.setValueRounded
+import org.koitharu.kotatsu.core.util.progress.IntPercentLabelFormatter
+import org.koitharu.kotatsu.details.ui.pager.ChaptersPagesSheet.Companion.TAB_CHAPTERS
+import org.koitharu.kotatsu.details.ui.pager.ChaptersPagesSheet.Companion.TAB_PAGES
+import java.lang.ref.WeakReference
+
+class ChapterPagesMenuProvider(
+	private val viewModel: DetailsViewModel,
+	private val sheet: BaseAdaptiveSheet<*>,
+	private val pager: ViewPager2,
+	private val settings: AppSettings,
+) : OnBackPressedCallback(false), MenuProvider, SearchView.OnQueryTextListener, MenuItem.OnActionExpandListener,
+	Slider.OnChangeListener {
+
+	private var expandedItemRef: WeakReference<MenuItem>? = null
+
+	override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
+		val tab = getCurrentTab()
+		when (tab) {
+			TAB_CHAPTERS -> {
+				menuInflater.inflate(R.menu.opt_chapters, menu)
+				menu.findItem(R.id.action_search)?.run {
+					setOnActionExpandListener(this@ChapterPagesMenuProvider)
+					(actionView as? SearchView)?.setupChaptersSearchView()
+				}
+				menu.findItem(R.id.action_search)?.isVisible = viewModel.isChaptersEmpty.value == false
+				menu.findItem(R.id.action_reversed)?.isChecked = viewModel.isChaptersReversed.value == true
+				menu.findItem(R.id.action_grid_view)?.isChecked = viewModel.isChaptersInGridView.value == true
+			}
+
+			TAB_PAGES -> {
+				menuInflater.inflate(R.menu.opt_pages, menu)
+				menu.findItem(R.id.action_grid_size)?.run {
+					setOnActionExpandListener(this@ChapterPagesMenuProvider)
+					(actionView as? Slider)?.setupPagesSizeSlider()
+				}
+			}
+		}
+	}
+
+	override fun onMenuItemSelected(menuItem: MenuItem): Boolean = when (menuItem.itemId) {
+		R.id.action_reversed -> {
+			viewModel.setChaptersReversed(!menuItem.isChecked)
+			true
+		}
+
+		R.id.action_grid_view -> {
+			viewModel.setChaptersInGridView(!menuItem.isChecked)
+			true
+		}
+
+		else -> false
+	}
+
+	override fun handleOnBackPressed() {
+		expandedItemRef?.get()?.collapseActionView()
+	}
+
+	override fun onMenuItemActionExpand(item: MenuItem): Boolean {
+		expandedItemRef = WeakReference(item)
+		sheet.expandAndLock()
+		isEnabled = true
+		return true
+	}
+
+	override fun onMenuItemActionCollapse(item: MenuItem): Boolean {
+		expandedItemRef = null
+		isEnabled = false
+		(item.actionView as? SearchView)?.setQuery("", false)
+		viewModel.performChapterSearch(null)
+		sheet.unlock()
+		return true
+	}
+
+	override fun onQueryTextSubmit(query: String?): Boolean = false
+
+	override fun onQueryTextChange(newText: String?): Boolean {
+		viewModel.performChapterSearch(newText)
+		return true
+	}
+
+	override fun onValueChange(slider: Slider, value: Float, fromUser: Boolean) {
+		if (fromUser) {
+			settings.gridSizePages = value.toInt()
+		}
+	}
+
+	private fun SearchView.setupChaptersSearchView() {
+		setOnQueryTextListener(this@ChapterPagesMenuProvider)
+		setIconifiedByDefault(false)
+		queryHint = context.getString(R.string.search_chapters)
+	}
+
+	private fun Slider.setupPagesSizeSlider() {
+		valueFrom = 50f
+		valueTo = 150f
+		stepSize = 5f
+		isTickVisible = false
+		labelBehavior = LabelFormatter.LABEL_FLOATING
+		setLabelFormatter(IntPercentLabelFormatter(context))
+		setValueRounded(settings.gridSizePages.toFloat())
+		addOnChangeListener(this@ChapterPagesMenuProvider)
+	}
+
+	private fun getCurrentTab(): Int {
+		var page = pager.currentItem
+		if (page > 0 && pager.adapter?.itemCount == 2) { // no Pages page
+			page++ // shift
+		}
+		return page
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/DetailsActivity.kt

@@ -29,6 +29,7 @@ import androidx.core.view.isGone
 import androidx.core.view.isVisible
 import androidx.core.view.updateLayoutParams
 import androidx.core.view.updatePadding
+import androidx.preference.PreferenceManager
 import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.android.material.snackbar.Snackbar
 import com.google.android.material.tabs.TabLayoutMediator
@@ -376,12 +377,13 @@ class DetailsActivity :
 	}
 
 	private fun initPager() {
-		val adapter = DetailsPagerAdapter(this)
+		val adapter = DetailsPagerAdapter(this, settings)
 		viewBinding.pager.recyclerView?.isNestedScrollingEnabled = false
 		viewBinding.pager.offscreenPageLimit = 1
 		viewBinding.pager.adapter = adapter
 		TabLayoutMediator(viewBinding.tabs, viewBinding.pager, adapter).attach()
 		viewBinding.pager.setCurrentItem(settings.defaultDetailsTab, false)
+		viewBinding.tabs.isVisible = adapter.itemCount > 1
 	}
 
 	private fun showBottomSheet(isVisible: Boolean) {
@@ -421,15 +423,25 @@ class DetailsActivity :
 	companion object {
 
 		const val TIP_BUTTON = "btn_read"
+		private const val KEY_NEW_ACTIVITY = "new_details_screen"
 
 		fun newIntent(context: Context, manga: Manga): Intent {
-			return Intent(context, DetailsActivity::class.java)
+			return getActivityIntent(context)
 				.putExtra(MangaIntent.KEY_MANGA, ParcelableManga(manga))
 		}
 
 		fun newIntent(context: Context, mangaId: Long): Intent {
-			return Intent(context, DetailsActivity::class.java)
+			return getActivityIntent(context)
 				.putExtra(MangaIntent.KEY_ID, mangaId)
 		}
+
+		private fun getActivityIntent(context: Context): Intent {
+			val prefs = PreferenceManager.getDefaultSharedPreferences(context)
+			val useNewActivity = prefs.getBoolean(KEY_NEW_ACTIVITY, false)
+			return Intent(
+				context,
+				if (useNewActivity) DetailsActivity2::class.java else DetailsActivity::class.java,
+			)
+		}
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/DetailsActivity2.kt

@@ -0,0 +1,703 @@
+package org.koitharu.kotatsu.details.ui
+
+import android.content.Context
+import android.content.Intent
+import android.graphics.Color
+import android.os.Bundle
+import android.text.style.DynamicDrawableSpan
+import android.text.style.ForegroundColorSpan
+import android.text.style.ImageSpan
+import android.text.style.RelativeSizeSpan
+import android.transition.TransitionManager
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewTreeObserver
+import android.widget.Toast
+import androidx.activity.viewModels
+import androidx.appcompat.widget.PopupMenu
+import androidx.core.graphics.Insets
+import androidx.core.text.buildSpannedString
+import androidx.core.text.inSpans
+import androidx.core.text.method.LinkMovementMethodCompat
+import androidx.core.view.isGone
+import androidx.core.view.isVisible
+import androidx.core.view.updatePadding
+import androidx.swiperefreshlayout.widget.CircularProgressDrawable
+import coil.ImageLoader
+import coil.request.ImageRequest
+import coil.request.SuccessResult
+import coil.transform.CircleCropTransformation
+import coil.util.CoilUtils
+import com.google.android.material.chip.Chip
+import com.google.android.material.snackbar.Snackbar
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.flow.FlowCollector
+import kotlinx.coroutines.flow.filterNotNull
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.bookmarks.domain.Bookmark
+import org.koitharu.kotatsu.core.exceptions.resolve.SnackbarErrorObserver
+import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.core.model.iconResId
+import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
+import org.koitharu.kotatsu.core.model.titleResId
+import org.koitharu.kotatsu.core.os.AppShortcutManager
+import org.koitharu.kotatsu.core.parser.MangaIntent
+import org.koitharu.kotatsu.core.parser.favicon.faviconUri
+import org.koitharu.kotatsu.core.ui.BaseActivity
+import org.koitharu.kotatsu.core.ui.BaseListAdapter
+import org.koitharu.kotatsu.core.ui.image.ChipIconTarget
+import org.koitharu.kotatsu.core.ui.image.CoverSizeResolver
+import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
+import org.koitharu.kotatsu.core.ui.list.decor.SpacingItemDecoration
+import org.koitharu.kotatsu.core.ui.util.MenuInvalidator
+import org.koitharu.kotatsu.core.ui.util.ReversibleActionObserver
+import org.koitharu.kotatsu.core.ui.widgets.ChipsView
+import org.koitharu.kotatsu.core.util.FileSize
+import org.koitharu.kotatsu.core.util.ViewBadge
+import org.koitharu.kotatsu.core.util.ext.crossfade
+import org.koitharu.kotatsu.core.util.ext.enqueueWith
+import org.koitharu.kotatsu.core.util.ext.getThemeColor
+import org.koitharu.kotatsu.core.util.ext.ifNullOrEmpty
+import org.koitharu.kotatsu.core.util.ext.isTextTruncated
+import org.koitharu.kotatsu.core.util.ext.observe
+import org.koitharu.kotatsu.core.util.ext.observeEvent
+import org.koitharu.kotatsu.core.util.ext.parentView
+import org.koitharu.kotatsu.core.util.ext.scaleUpActivityOptionsOf
+import org.koitharu.kotatsu.core.util.ext.setOnContextClickListenerCompat
+import org.koitharu.kotatsu.core.util.ext.source
+import org.koitharu.kotatsu.core.util.ext.textAndVisible
+import org.koitharu.kotatsu.databinding.ActivityDetailsNewBinding
+import org.koitharu.kotatsu.details.data.MangaDetails
+import org.koitharu.kotatsu.details.data.ReadingTime
+import org.koitharu.kotatsu.details.service.MangaPrefetchService
+import org.koitharu.kotatsu.details.ui.model.ChapterListItem
+import org.koitharu.kotatsu.details.ui.model.HistoryInfo
+import org.koitharu.kotatsu.details.ui.pager.ChaptersPagesSheet
+import org.koitharu.kotatsu.details.ui.related.RelatedMangaActivity
+import org.koitharu.kotatsu.details.ui.scrobbling.ScrobblingItemDecoration
+import org.koitharu.kotatsu.details.ui.scrobbling.ScrollingInfoAdapter
+import org.koitharu.kotatsu.download.ui.worker.DownloadStartedObserver
+import org.koitharu.kotatsu.favourites.ui.categories.select.FavoriteSheet
+import org.koitharu.kotatsu.image.ui.ImageActivity
+import org.koitharu.kotatsu.list.domain.ListExtraProvider
+import org.koitharu.kotatsu.list.ui.adapter.ListItemType
+import org.koitharu.kotatsu.list.ui.adapter.mangaGridItemAD
+import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.list.ui.model.MangaItemModel
+import org.koitharu.kotatsu.list.ui.size.StaticItemSizeResolver
+import org.koitharu.kotatsu.local.ui.info.LocalInfoDialog
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.parsers.util.ellipsize
+import org.koitharu.kotatsu.reader.ui.ReaderActivity.IntentBuilder
+import org.koitharu.kotatsu.scrobbling.common.domain.model.ScrobblingInfo
+import org.koitharu.kotatsu.scrobbling.common.ui.selector.ScrobblingSelectorSheet
+import org.koitharu.kotatsu.search.ui.MangaListActivity
+import org.koitharu.kotatsu.search.ui.SearchActivity
+import org.koitharu.kotatsu.stats.ui.sheet.MangaStatsSheet
+import javax.inject.Inject
+import com.google.android.material.R as materialR
+
+@AndroidEntryPoint
+class DetailsActivity2 :
+	BaseActivity<ActivityDetailsNewBinding>(),
+	View.OnClickListener,
+	View.OnLongClickListener, PopupMenu.OnMenuItemClickListener, View.OnLayoutChangeListener,
+	ViewTreeObserver.OnDrawListener, ChipsView.OnChipClickListener, OnListItemClickListener<Bookmark> {
+
+	@Inject
+	lateinit var shortcutManager: AppShortcutManager
+
+	@Inject
+	lateinit var coil: ImageLoader
+
+	@Inject
+	lateinit var tagHighlighter: ListExtraProvider
+
+	private val viewModel: DetailsViewModel by viewModels()
+
+	var bottomSheetMediator: ChaptersBottomSheetMediator? = null
+		private set
+
+	private lateinit var chaptersBadge: ViewBadge
+
+	override fun onCreate(savedInstanceState: Bundle?) {
+		super.onCreate(savedInstanceState)
+		setContentView(ActivityDetailsNewBinding.inflate(layoutInflater))
+		supportActionBar?.run {
+			setDisplayHomeAsUpEnabled(true)
+			setDisplayShowTitleEnabled(false)
+		}
+		viewBinding.buttonRead.setOnClickListener(this)
+		viewBinding.buttonRead.setOnLongClickListener(this)
+		viewBinding.buttonRead.setOnContextClickListenerCompat(this)
+		viewBinding.buttonChapters.setOnClickListener(this)
+		viewBinding.infoLayout.chipBranch.setOnClickListener(this)
+		viewBinding.infoLayout.chipSize.setOnClickListener(this)
+		viewBinding.infoLayout.chipSource.setOnClickListener(this)
+		viewBinding.infoLayout.chipFavorite.setOnClickListener(this)
+		viewBinding.infoLayout.chipAuthor.setOnClickListener(this)
+		viewBinding.infoLayout.chipTime.setOnClickListener(this)
+		viewBinding.imageViewCover.setOnClickListener(this)
+		viewBinding.buttonDescriptionMore.setOnClickListener(this)
+		viewBinding.buttonScrobblingMore.setOnClickListener(this)
+		viewBinding.buttonRelatedMore.setOnClickListener(this)
+		viewBinding.infoLayout.chipSource.setOnClickListener(this)
+		viewBinding.infoLayout.chipSize.setOnClickListener(this)
+		viewBinding.textViewDescription.addOnLayoutChangeListener(this)
+		viewBinding.textViewDescription.viewTreeObserver.addOnDrawListener(this)
+		viewBinding.textViewDescription.movementMethod = LinkMovementMethodCompat.getInstance()
+		viewBinding.chipsTags.onChipClickListener = this
+		viewBinding.recyclerViewRelated.addItemDecoration(
+			SpacingItemDecoration(resources.getDimensionPixelOffset(R.dimen.grid_spacing)),
+		)
+		TitleScrollCoordinator(viewBinding.textViewTitle).attach(viewBinding.scrollView)
+
+		chaptersBadge = ViewBadge(viewBinding.buttonChapters, this)
+
+		viewModel.details.filterNotNull().observe(this, ::onMangaUpdated)
+		viewModel.onMangaRemoved.observeEvent(this, ::onMangaRemoved)
+		viewModel.newChaptersCount.observe(this, ::onNewChaptersChanged)
+		viewModel.onError.observeEvent(
+			this,
+			SnackbarErrorObserver(viewBinding.scrollView, null, exceptionResolver) {
+				if (it) viewModel.reload()
+			},
+		)
+		viewModel.onActionDone.observeEvent(this, ReversibleActionObserver(viewBinding.scrollView, null))
+		viewModel.historyInfo.observe(this, ::onHistoryChanged)
+		viewModel.isLoading.observe(this, ::onLoadingStateChanged)
+		viewModel.scrobblingInfo.observe(this, ::onScrobblingInfoChanged)
+		viewModel.localSize.observe(this, ::onLocalSizeChanged)
+		viewModel.relatedManga.observe(this, ::onRelatedMangaChanged)
+		// viewModel.chapters.observe(this, ::onChaptersChanged)
+		viewModel.readingTime.observe(this, ::onReadingTimeChanged)
+		viewModel.selectedBranch.observe(this) {
+			viewBinding.infoLayout.chipBranch.text = it.ifNullOrEmpty { getString(R.string.system_default) }
+		}
+		viewModel.favouriteCategories.observe(this, ::onFavoritesChanged)
+		val menuInvalidator = MenuInvalidator(this)
+		viewModel.isStatsAvailable.observe(this, menuInvalidator)
+		viewModel.remoteManga.observe(this, menuInvalidator)
+		viewModel.branches.observe(this) {
+			viewBinding.infoLayout.chipBranch.isVisible = it.size > 1
+		}
+		viewModel.chapters.observe(this, PrefetchObserver(this))
+		viewModel.onDownloadStarted.observeEvent(
+			this,
+			DownloadStartedObserver(viewBinding.scrollView),
+		)
+
+		addMenuProvider(
+			DetailsMenuProvider(
+				activity = this,
+				viewModel = viewModel,
+				snackbarHost = viewBinding.scrollView,
+				appShortcutManager = shortcutManager,
+			),
+		)
+	}
+
+	override fun onClick(v: View) {
+		when (v.id) {
+			R.id.button_read -> openReader(isIncognitoMode = false)
+			R.id.chip_branch -> showBranchPopupMenu(v)
+			R.id.button_chapters -> {
+				ChaptersPagesSheet.show(supportFragmentManager)
+			}
+
+			R.id.chip_author -> {
+				val manga = viewModel.manga.value ?: return
+				startActivity(
+					SearchActivity.newIntent(
+						context = v.context,
+						source = manga.source,
+						query = manga.author ?: return,
+					),
+				)
+			}
+
+			R.id.chip_source -> {
+				val manga = viewModel.manga.value ?: return
+				startActivity(
+					MangaListActivity.newIntent(
+						context = v.context,
+						source = manga.source,
+					),
+				)
+			}
+
+			R.id.chip_size -> {
+				val manga = viewModel.manga.value ?: return
+				LocalInfoDialog.show(supportFragmentManager, manga)
+			}
+
+			R.id.chip_favorite -> {
+				val manga = viewModel.manga.value ?: return
+				FavoriteSheet.show(supportFragmentManager, manga)
+			}
+
+			R.id.chip_time -> {
+				if (viewModel.isStatsAvailable.value) {
+					val manga = viewModel.manga.value ?: return
+					MangaStatsSheet.show(supportFragmentManager, manga)
+				} else {
+					// TODO
+				}
+			}
+
+			R.id.imageView_cover -> {
+				val manga = viewModel.manga.value ?: return
+				startActivity(
+					ImageActivity.newIntent(
+						v.context,
+						manga.largeCoverUrl.ifNullOrEmpty { manga.coverUrl },
+						manga.source,
+					),
+					scaleUpActivityOptionsOf(v),
+				)
+			}
+
+			R.id.button_description_more -> {
+				val tv = viewBinding.textViewDescription
+				TransitionManager.beginDelayedTransition(tv.parentView)
+				if (tv.maxLines in 1 until Integer.MAX_VALUE) {
+					tv.maxLines = Integer.MAX_VALUE
+				} else {
+					tv.maxLines = resources.getInteger(R.integer.details_description_lines)
+				}
+			}
+
+			R.id.button_scrobbling_more -> {
+				val manga = viewModel.manga.value ?: return
+				ScrobblingSelectorSheet.show(supportFragmentManager, manga, null)
+			}
+
+			R.id.button_related_more -> {
+				val manga = viewModel.manga.value ?: return
+				startActivity(RelatedMangaActivity.newIntent(v.context, manga))
+			}
+		}
+	}
+
+	override fun onChipClick(chip: Chip, data: Any?) {
+		val tag = data as? MangaTag ?: return
+		startActivity(MangaListActivity.newIntent(this, setOf(tag)))
+	}
+
+	override fun onLongClick(v: View): Boolean = when (v.id) {
+		R.id.button_read -> {
+			val menu = PopupMenu(v.context, v)
+			menu.inflate(R.menu.popup_read)
+			menu.menu.findItem(R.id.action_forget)?.isVisible = viewModel.historyInfo.value.run {
+				!isIncognitoMode && history != null
+			}
+			menu.setOnMenuItemClickListener(this)
+			menu.setForceShowIcon(true)
+			menu.show()
+			true
+		}
+
+		else -> false
+	}
+
+	override fun onMenuItemClick(item: MenuItem): Boolean {
+		return when (item.itemId) {
+			R.id.action_incognito -> {
+				openReader(isIncognitoMode = true)
+				true
+			}
+
+			R.id.action_forget -> {
+				viewModel.removeFromHistory()
+				true
+			}
+
+			else -> false
+		}
+	}
+
+	override fun onItemClick(item: Bookmark, view: View) {
+		startActivity(
+			IntentBuilder(view.context).bookmark(item).incognito(true).build(),
+		)
+		Toast.makeText(view.context, R.string.incognito_mode, Toast.LENGTH_SHORT).show()
+	}
+
+	override fun onDraw() {
+		viewBinding.run {
+			buttonDescriptionMore.isVisible = textViewDescription.maxLines == Int.MAX_VALUE ||
+				textViewDescription.isTextTruncated
+		}
+	}
+
+	override fun onLayoutChange(
+		v: View?,
+		left: Int,
+		top: Int,
+		right: Int,
+		bottom: Int,
+		oldLeft: Int,
+		oldTop: Int,
+		oldRight: Int,
+		oldBottom: Int
+	) {
+		with(viewBinding) {
+			buttonDescriptionMore.isVisible = textViewDescription.isTextTruncated
+		}
+	}
+
+	private fun onChaptersChanged(chapters: List<ChapterListItem>?) {
+		// TODO
+	}
+
+	private fun onFavoritesChanged(categories: Set<FavouriteCategory>) {
+		val chip = viewBinding.infoLayout.chipFavorite
+		chip.setChipIconResource(if (categories.isEmpty()) R.drawable.ic_heart_outline else R.drawable.ic_heart)
+		chip.text = if (categories.isEmpty()) {
+			getString(R.string.add_to_favourites)
+		} else {
+			if (categories.size == 1) {
+				categories.first().title.ellipsize(FAV_LABEL_LIMIT)
+			}
+			buildString(FAV_LABEL_LIMIT + 6) {
+				for ((i, cat) in categories.withIndex()) {
+					if (i == 0) {
+						append(cat.title.ellipsize(FAV_LABEL_LIMIT - 4))
+					} else if (length + cat.title.length > FAV_LABEL_LIMIT) {
+						append(", ")
+						append(getString(R.string.list_ellipsize_pattern, categories.size - i))
+						break
+					} else {
+						append(", ")
+						append(cat.title)
+					}
+				}
+			}
+		}
+	}
+
+	private fun onReadingTimeChanged(time: ReadingTime?) {
+		val chip = viewBinding.infoLayout.chipTime
+		chip.textAndVisible = time?.formatShort(chip.resources)
+	}
+
+	private fun onDescriptionChanged(description: CharSequence?) {
+		val tv = viewBinding.textViewDescription
+		if (description.isNullOrBlank()) {
+			tv.setText(R.string.no_description)
+		} else {
+			tv.text = description
+		}
+	}
+
+	private fun onLocalSizeChanged(size: Long) {
+		val chip = viewBinding.infoLayout.chipSize
+		if (size == 0L) {
+			chip.isVisible = false
+		} else {
+			chip.text = FileSize.BYTES.format(chip.context, size)
+			chip.isVisible = true
+		}
+	}
+
+	private fun onRelatedMangaChanged(related: List<MangaItemModel>) {
+		if (related.isEmpty()) {
+			viewBinding.groupRelated.isVisible = false
+			return
+		}
+		val rv = viewBinding.recyclerViewRelated
+
+		@Suppress("UNCHECKED_CAST")
+		val adapter = (rv.adapter as? BaseListAdapter<ListModel>) ?: BaseListAdapter<ListModel>()
+			.addDelegate(
+				ListItemType.MANGA_GRID,
+				mangaGridItemAD(
+					coil, this,
+					StaticItemSizeResolver(resources.getDimensionPixelSize(R.dimen.smaller_grid_width)),
+				) { item, view ->
+					startActivity(DetailsActivity.newIntent(view.context, item))
+				},
+			).also { rv.adapter = it }
+		adapter.items = related
+		viewBinding.groupRelated.isVisible = true
+	}
+
+	private fun onLoadingStateChanged(isLoading: Boolean) {
+		val button = viewBinding.buttonChapters
+		if (isLoading) {
+			button.setImageDrawable(
+				CircularProgressDrawable(this).also {
+					it.setStyle(CircularProgressDrawable.LARGE)
+					it.setColorSchemeColors(getThemeColor(materialR.attr.colorControlNormal))
+					it.start()
+				},
+			)
+		} else {
+			button.setImageResource(R.drawable.ic_list_sheet)
+		}
+	}
+
+	private fun onScrobblingInfoChanged(scrobblings: List<ScrobblingInfo>) {
+		var adapter = viewBinding.recyclerViewScrobbling.adapter as? ScrollingInfoAdapter
+		viewBinding.groupScrobbling.isGone = scrobblings.isEmpty()
+		if (adapter != null) {
+			adapter.items = scrobblings
+		} else {
+			adapter = ScrollingInfoAdapter(this, coil, supportFragmentManager)
+			adapter.items = scrobblings
+			viewBinding.recyclerViewScrobbling.adapter = adapter
+			viewBinding.recyclerViewScrobbling.addItemDecoration(ScrobblingItemDecoration())
+		}
+	}
+
+	private fun onMangaUpdated(details: MangaDetails) {
+		with(viewBinding) {
+			val manga = details.toManga()
+			val hasChapters = !manga.chapters.isNullOrEmpty()
+			// Main
+			loadCover(manga)
+			textViewTitle.text = manga.title
+			textViewSubtitle.textAndVisible = manga.altTitle
+			infoLayout.chipAuthor.textAndVisible = manga.author
+			if (manga.hasRating) {
+				ratingBar.rating = manga.rating * ratingBar.numStars
+				ratingBar.isVisible = true
+			} else {
+				ratingBar.isVisible = false
+			}
+
+			manga.state?.let { state ->
+				textViewState.textAndVisible = resources.getString(state.titleResId)
+				imageViewState.setImageResource(state.iconResId)
+			} ?: run {
+				textViewState.isVisible = false
+				imageViewState.isVisible = false
+			}
+
+			if (manga.source == MangaSource.LOCAL || manga.source == MangaSource.DUMMY) {
+				infoLayout.chipSource.isVisible = false
+			} else {
+				infoLayout.chipSource.text = manga.source.title
+				infoLayout.chipSource.isVisible = true
+			}
+
+			textViewNsfw.isVisible = manga.isNsfw
+
+			// Chips
+			bindTags(manga)
+
+			textViewDescription.text = details.description.ifNullOrEmpty { getString(R.string.no_description) }
+
+			viewBinding.infoLayout.chipSource.also { chip ->
+				ImageRequest.Builder(this@DetailsActivity2)
+					.data(manga.source.faviconUri())
+					.lifecycle(this@DetailsActivity2)
+					.crossfade(false)
+					.size(resources.getDimensionPixelSize(materialR.dimen.m3_chip_icon_size))
+					.target(ChipIconTarget(chip))
+					.placeholder(R.drawable.ic_web)
+					.fallback(R.drawable.ic_web)
+					.error(R.drawable.ic_web)
+					.source(manga.source)
+					.transformations(CircleCropTransformation())
+					.allowRgb565(true)
+					.enqueueWith(coil)
+			}
+
+			buttonChapters.isEnabled = hasChapters
+			title = manga.title
+			buttonRead.isEnabled = hasChapters
+			invalidateOptionsMenu()
+		}
+	}
+
+	private fun onMangaRemoved(manga: Manga) {
+		Toast.makeText(
+			this,
+			getString(R.string._s_deleted_from_local_storage, manga.title),
+			Toast.LENGTH_SHORT,
+		).show()
+		finishAfterTransition()
+	}
+
+	override fun onWindowInsetsChanged(insets: Insets) {
+		viewBinding.root.updatePadding(
+			left = insets.left,
+			right = insets.right,
+			bottom = insets.bottom
+		)
+	}
+
+	private fun onHistoryChanged(info: HistoryInfo) {
+		with(viewBinding.buttonRead) {
+			if (info.history != null) {
+				setTitle(R.string._continue)
+			} else {
+				setTitle(R.string.read)
+			}
+		}
+		viewBinding.buttonRead.subtitle = when {
+			!info.isValid -> getString(R.string.loading_)
+			info.currentChapter >= 0 -> getString(
+				R.string.chapter_d_of_d,
+				info.currentChapter + 1,
+				info.totalChapters,
+			)
+
+			info.totalChapters == 0 -> getString(R.string.no_chapters)
+			else -> resources.getQuantityString(
+				R.plurals.chapters,
+				info.totalChapters,
+				info.totalChapters,
+			)
+		}
+		viewBinding.buttonRead.setProgress(info.history?.percent?.coerceIn(0f, 1f) ?: 0f, true)
+	}
+
+	private fun onNewChaptersChanged(count: Int) {
+		chaptersBadge.counter = count
+	}
+
+	private fun showBranchPopupMenu(v: View) {
+		val menu = PopupMenu(v.context, v)
+		val branches = viewModel.branches.value
+		for ((i, branch) in branches.withIndex()) {
+			val title = buildSpannedString {
+				if (branch.isCurrent) {
+					inSpans(
+						ImageSpan(
+							this@DetailsActivity2,
+							R.drawable.ic_current_chapter,
+							DynamicDrawableSpan.ALIGN_BASELINE,
+						),
+					) {
+						append(' ')
+					}
+					append(' ')
+				}
+				append(branch.name ?: getString(R.string.system_default))
+				append(' ')
+				append(' ')
+				inSpans(
+					ForegroundColorSpan(
+						v.context.getThemeColor(
+							android.R.attr.textColorSecondary,
+							Color.LTGRAY,
+						),
+					),
+					RelativeSizeSpan(0.74f),
+				) {
+					append(branch.count.toString())
+				}
+			}
+			val item = menu.menu.add(R.id.group_branches, Menu.NONE, i, title)
+			item.isCheckable = true
+			item.isChecked = branch.isSelected
+		}
+		menu.menu.setGroupCheckable(R.id.group_branches, true, true)
+		menu.setOnMenuItemClickListener {
+			viewModel.setSelectedBranch(branches.getOrNull(it.order)?.name)
+			true
+		}
+		menu.show()
+	}
+
+	private fun openReader(isIncognitoMode: Boolean) {
+		val manga = viewModel.manga.value ?: return
+		val chapterId = viewModel.historyInfo.value.history?.chapterId
+		if (chapterId != null && manga.chapters?.none { x -> x.id == chapterId } == true) {
+			Snackbar.make(viewBinding.scrollView, R.string.chapter_is_missing, Snackbar.LENGTH_SHORT)
+				.show()
+		} else {
+			startActivity(
+				IntentBuilder(this)
+					.manga(manga)
+					.branch(viewModel.selectedBranchValue)
+					.incognito(isIncognitoMode)
+					.build(),
+			)
+			if (isIncognitoMode) {
+				Toast.makeText(this, R.string.incognito_mode, Toast.LENGTH_SHORT).show()
+			}
+		}
+	}
+
+	private fun bindTags(manga: Manga) {
+		viewBinding.chipsTags.isVisible = manga.tags.isNotEmpty()
+		viewBinding.chipsTags.setChips(
+			manga.tags.map { tag ->
+				ChipsView.ChipModel(
+					title = tag.title,
+					tint = tagHighlighter.getTagTint(tag),
+					icon = 0,
+					data = tag,
+					isCheckable = false,
+					isChecked = false,
+				)
+			},
+		)
+	}
+
+	private fun loadCover(manga: Manga) {
+		val imageUrl = manga.largeCoverUrl.ifNullOrEmpty { manga.coverUrl }
+		val lastResult = CoilUtils.result(viewBinding.imageViewCover)
+		if (lastResult is SuccessResult && lastResult.request.data == imageUrl) {
+			return
+		}
+		val request = ImageRequest.Builder(this)
+			.target(viewBinding.imageViewCover)
+			.size(CoverSizeResolver(viewBinding.imageViewCover))
+			.data(imageUrl)
+			.tag(manga.source)
+			.crossfade(this)
+			.lifecycle(this)
+			.placeholderMemoryCacheKey(manga.coverUrl)
+		val previousDrawable = lastResult?.drawable
+		if (previousDrawable != null) {
+			request.fallback(previousDrawable)
+				.placeholder(previousDrawable)
+				.error(previousDrawable)
+		} else {
+			request.fallback(R.drawable.ic_placeholder)
+				.placeholder(R.drawable.ic_placeholder)
+				.error(R.drawable.ic_error_placeholder)
+		}
+		request.enqueueWith(coil)
+	}
+
+	private class PrefetchObserver(
+		private val context: Context,
+	) : FlowCollector<List<ChapterListItem>?> {
+
+		private var isCalled = false
+
+		override suspend fun emit(value: List<ChapterListItem>?) {
+			if (value.isNullOrEmpty()) {
+				return
+			}
+			if (!isCalled) {
+				isCalled = true
+				val item = value.find { it.isCurrent } ?: value.first()
+				MangaPrefetchService.prefetchPages(context, item.chapter)
+			}
+		}
+	}
+
+	companion object {
+
+		private const val FAV_LABEL_LIMIT = 10
+
+		fun newIntent(context: Context, manga: Manga): Intent {
+			return Intent(context, DetailsActivity2::class.java)
+				.putExtra(MangaIntent.KEY_MANGA, ParcelableManga(manga))
+		}
+
+		fun newIntent(context: Context, mangaId: Long): Intent {
+			return Intent(context, DetailsActivity2::class.java)
+				.putExtra(MangaIntent.KEY_ID, mangaId)
+		}
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/DetailsFragment.kt

@@ -189,7 +189,7 @@ class DetailsFragment :
 					isVisible = false
 				}
 			}
-			if (manga.source == MangaSource.LOCAL) {
+			if (manga.source == MangaSource.LOCAL || manga.source == MangaSource.DUMMY) {
 				infoLayout.textViewSource.isVisible = false
 			} else {
 				infoLayout.textViewSource.text = manga.source.title
@@ -223,7 +223,7 @@ class DetailsFragment :
 		}
 		binding.approximateReadTime.text = time.format(resources)
 		binding.approximateReadTimeTitle.setText(
-			if (time.isContinue) R.string.approximate_remaining_time else R.string.approximate_reading_time
+			if (time.isContinue) R.string.approximate_remaining_time else R.string.approximate_reading_time,
 		)
 		binding.approximateReadTimeLayout.isVisible = true
 	}

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/DetailsMenuProvider.kt

@@ -35,6 +35,7 @@ class DetailsMenuProvider(
 
 	override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
 		menuInflater.inflate(R.menu.opt_details, menu)
+		menu.findItem(R.id.action_favourite).isVisible = activity is DetailsActivity
 	}
 
 	override fun onPrepareMenu(menu: Menu) {
@@ -48,7 +49,7 @@ class DetailsMenuProvider(
 		menu.findItem(R.id.action_online).isVisible = viewModel.remoteManga.value != null
 		menu.findItem(R.id.action_stats).isVisible = viewModel.isStatsAvailable.value
 		menu.findItem(R.id.action_favourite).setIcon(
-			if (viewModel.favouriteCategories.value) R.drawable.ic_heart else R.drawable.ic_heart_outline,
+			if (viewModel.favouriteCategories.value.isNotEmpty()) R.drawable.ic_heart else R.drawable.ic_heart_outline,
 		)
 	}
 
@@ -89,7 +90,7 @@ class DetailsMenuProvider(
 
 			R.id.action_browser -> {
 				viewModel.manga.value?.let {
-					activity.startActivity(BrowserActivity.newIntent(activity, it.publicUrl, it.title))
+					activity.startActivity(BrowserActivity.newIntent(activity, it.publicUrl, it.source, it.title))
 				}
 			}
 

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/DetailsViewModel.kt

@@ -101,8 +101,8 @@ class DetailsViewModel @Inject constructor(
 	val history = historyRepository.observeOne(mangaId)
 		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, null)
 
-	val favouriteCategories = interactor.observeIsFavourite(mangaId)
-		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, false)
+	val favouriteCategories = interactor.observeFavourite(mangaId)
+		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, emptySet())
 
 	val isStatsAvailable = statsRepository.observeHasStats(mangaId)
 		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, false)

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/adapter/ChaptersSelectionDecoration.kt

@@ -36,7 +36,7 @@ class ChaptersSelectionDecoration(context: Context) : AbstractSelectionItemDecor
 			98,
 		)
 		paint.style = Paint.Style.FILL
-		hasBackground = false
+		hasBackground = true
 		hasForeground = true
 		isIncludeDecorAndMargins = false
 

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/pager/ChaptersPagesSheet.kt

@@ -0,0 +1,116 @@
+package org.koitharu.kotatsu.details.ui.pager
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.appcompat.view.ActionMode
+import androidx.core.view.isVisible
+import androidx.fragment.app.FragmentManager
+import androidx.fragment.app.activityViewModels
+import com.google.android.material.tabs.TabLayoutMediator
+import dagger.hilt.android.AndroidEntryPoint
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.core.ui.sheet.BaseAdaptiveSheet
+import org.koitharu.kotatsu.core.ui.util.ActionModeListener
+import org.koitharu.kotatsu.core.util.ext.doOnPageChanged
+import org.koitharu.kotatsu.core.util.ext.menuView
+import org.koitharu.kotatsu.core.util.ext.recyclerView
+import org.koitharu.kotatsu.core.util.ext.setTabsEnabled
+import org.koitharu.kotatsu.core.util.ext.showDistinct
+import org.koitharu.kotatsu.core.util.ext.withArgs
+import org.koitharu.kotatsu.databinding.SheetChaptersPagesBinding
+import org.koitharu.kotatsu.details.ui.ChapterPagesMenuProvider
+import org.koitharu.kotatsu.details.ui.DetailsViewModel
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class ChaptersPagesSheet : BaseAdaptiveSheet<SheetChaptersPagesBinding>(), ActionModeListener {
+
+	@Inject
+	lateinit var settings: AppSettings
+
+	private val viewModel by activityViewModels<DetailsViewModel>()
+
+	override fun onCreateViewBinding(inflater: LayoutInflater, container: ViewGroup?): SheetChaptersPagesBinding {
+		return SheetChaptersPagesBinding.inflate(inflater, container, false)
+	}
+
+	override fun onViewBindingCreated(binding: SheetChaptersPagesBinding, savedInstanceState: Bundle?) {
+		super.onViewBindingCreated(binding, savedInstanceState)
+		disableFitToContents()
+
+		val args = arguments ?: Bundle.EMPTY
+		val adapter = DetailsPagerAdapter2(this, args.getBoolean(ARG_SHOW_PAGES, settings.isPagesTabEnabled))
+		binding.pager.recyclerView?.isNestedScrollingEnabled = false
+		binding.pager.offscreenPageLimit = adapter.itemCount
+		binding.pager.adapter = adapter
+		binding.pager.doOnPageChanged(::onPageChanged)
+		TabLayoutMediator(binding.tabs, binding.pager, adapter).attach()
+		binding.pager.setCurrentItem(args.getInt(ARG_TAB, settings.defaultDetailsTab), false)
+		binding.tabs.isVisible = adapter.itemCount > 1
+
+		val menuProvider = ChapterPagesMenuProvider(viewModel, this, binding.pager, settings)
+		onBackPressedDispatcher.addCallback(viewLifecycleOwner, menuProvider)
+		binding.toolbar.addMenuProvider(menuProvider)
+
+		actionModeDelegate.addListener(this, viewLifecycleOwner)
+	}
+
+	override fun onActionModeStarted(mode: ActionMode) {
+		expandAndLock()
+		viewBinding?.toolbar?.menuView?.isEnabled = false
+	}
+
+	override fun onActionModeFinished(mode: ActionMode) {
+		unlock()
+		viewBinding?.toolbar?.menuView?.isEnabled = true
+	}
+
+	override fun expandAndLock() {
+		super.expandAndLock()
+		adjustLockState()
+	}
+
+	override fun unlock() {
+		super.unlock()
+		adjustLockState()
+	}
+
+	private fun adjustLockState() {
+		viewBinding?.run {
+			pager.isUserInputEnabled = !isLocked
+			tabs.setTabsEnabled(!isLocked)
+		}
+	}
+
+	private fun onPageChanged(position: Int) {
+		viewBinding?.toolbar?.invalidateMenu()
+	}
+
+	companion object {
+
+		const val TAB_CHAPTERS = 0
+		const val TAB_PAGES = 1
+		const val TAB_BOOKMARKS = 2
+		private const val ARG_TAB = "tag"
+		private const val ARG_SHOW_PAGES = "pages"
+		private const val TAG = "ChaptersPagesSheet"
+
+		fun show(fm: FragmentManager) {
+			ChaptersPagesSheet().showDistinct(fm, TAG)
+		}
+
+		fun show(fm: FragmentManager, showPagesTab: Boolean) {
+			ChaptersPagesSheet().withArgs(1) {
+				putBoolean(ARG_SHOW_PAGES, showPagesTab)
+			}.showDistinct(fm, TAG)
+		}
+
+		fun show(fm: FragmentManager, showPagesTab: Boolean, defaultTab: Int) {
+			ChaptersPagesSheet().withArgs(2) {
+				putBoolean(ARG_SHOW_PAGES, showPagesTab)
+				putInt(ARG_TAB, defaultTab)
+			}.showDistinct(fm, TAG)
+		}
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/pager/DetailsPagerAdapter.kt

@@ -6,13 +6,19 @@ import androidx.viewpager2.adapter.FragmentStateAdapter
 import com.google.android.material.tabs.TabLayout
 import com.google.android.material.tabs.TabLayoutMediator
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.details.ui.pager.chapters.ChaptersFragment
 import org.koitharu.kotatsu.details.ui.pager.pages.PagesFragment
 
-class DetailsPagerAdapter(activity: FragmentActivity) : FragmentStateAdapter(activity),
+class DetailsPagerAdapter(
+	activity: FragmentActivity,
+	settings: AppSettings,
+) : FragmentStateAdapter(activity),
 	TabLayoutMediator.TabConfigurationStrategy {
 
-	override fun getItemCount(): Int = 2
+	val isPagesTabEnabled = settings.isPagesTabEnabled
+
+	override fun getItemCount(): Int = if (isPagesTabEnabled) 2 else 1
 
 	override fun createFragment(position: Int): Fragment = when (position) {
 		0 -> ChaptersFragment()

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/pager/DetailsPagerAdapter2.kt

@@ -0,0 +1,38 @@
+package org.koitharu.kotatsu.details.ui.pager
+
+import androidx.fragment.app.Fragment
+import androidx.viewpager2.adapter.FragmentStateAdapter
+import com.google.android.material.tabs.TabLayout
+import com.google.android.material.tabs.TabLayoutMediator
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.details.ui.pager.bookmarks.MangaBookmarksFragment
+import org.koitharu.kotatsu.details.ui.pager.chapters.ChaptersFragment
+import org.koitharu.kotatsu.details.ui.pager.pages.PagesFragment
+
+class DetailsPagerAdapter2(
+	fragment: Fragment,
+	val isPagesTabEnabled: Boolean,
+) : FragmentStateAdapter(fragment),
+	TabLayoutMediator.TabConfigurationStrategy {
+
+	override fun getItemCount(): Int = if (isPagesTabEnabled) 3 else 2
+
+	override fun createFragment(position: Int): Fragment = when (position) {
+		0 -> ChaptersFragment()
+		1 -> if (isPagesTabEnabled) PagesFragment() else MangaBookmarksFragment()
+		2 -> MangaBookmarksFragment()
+		else -> throw IllegalArgumentException("Invalid position $position")
+	}
+
+	override fun onConfigureTab(tab: TabLayout.Tab, position: Int) {
+		tab.setText(
+			when (position) {
+				0 -> R.string.chapters
+				1 -> if (isPagesTabEnabled) R.string.pages else R.string.bookmarks
+				2 -> R.string.bookmarks
+				else -> 0
+			},
+		)
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/pager/bookmarks/MangaBookmarksFragment.kt

@@ -0,0 +1,137 @@
+package org.koitharu.kotatsu.details.ui.pager.bookmarks
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.core.graphics.Insets
+import androidx.fragment.app.activityViewModels
+import androidx.fragment.app.viewModels
+import androidx.recyclerview.widget.GridLayoutManager
+import coil.ImageLoader
+import dagger.hilt.android.AndroidEntryPoint
+import org.koitharu.kotatsu.bookmarks.domain.Bookmark
+import org.koitharu.kotatsu.bookmarks.ui.sheet.BookmarksAdapter
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.core.ui.BaseFragment
+import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
+import org.koitharu.kotatsu.core.util.ext.dismissParentDialog
+import org.koitharu.kotatsu.core.util.ext.findParentCallback
+import org.koitharu.kotatsu.core.util.ext.observe
+import org.koitharu.kotatsu.databinding.FragmentMangaBookmarksBinding
+import org.koitharu.kotatsu.details.ui.DetailsViewModel
+import org.koitharu.kotatsu.list.ui.MangaListSpanResolver
+import org.koitharu.kotatsu.list.ui.adapter.ListItemType
+import org.koitharu.kotatsu.list.ui.adapter.TypedListSpacingDecoration
+import org.koitharu.kotatsu.reader.ui.ReaderActivity.IntentBuilder
+import org.koitharu.kotatsu.reader.ui.ReaderNavigationCallback
+import org.koitharu.kotatsu.reader.ui.ReaderState
+import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
+import org.koitharu.kotatsu.reader.ui.thumbnails.OnPageSelectListener
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class MangaBookmarksFragment : BaseFragment<FragmentMangaBookmarksBinding>(),
+	OnListItemClickListener<Bookmark> {
+
+	private val activityViewModel by activityViewModels<DetailsViewModel>()
+	private val viewModel by viewModels<MangaBookmarksViewModel>()
+
+	@Inject
+	lateinit var coil: ImageLoader
+
+	@Inject
+	lateinit var settings: AppSettings
+
+	private var bookmarksAdapter: BookmarksAdapter? = null
+	private var spanResolver: MangaListSpanResolver? = null
+
+	private val spanSizeLookup = SpanSizeLookup()
+	private val listCommitCallback = Runnable {
+		spanSizeLookup.invalidateCache()
+	}
+
+	override fun onCreate(savedInstanceState: Bundle?) {
+		super.onCreate(savedInstanceState)
+		activityViewModel.manga.observe(this, viewModel)
+	}
+
+	override fun onCreateViewBinding(inflater: LayoutInflater, container: ViewGroup?): FragmentMangaBookmarksBinding {
+		return FragmentMangaBookmarksBinding.inflate(inflater, container, false)
+	}
+
+	override fun onViewBindingCreated(binding: FragmentMangaBookmarksBinding, savedInstanceState: Bundle?) {
+		super.onViewBindingCreated(binding, savedInstanceState)
+		spanResolver = MangaListSpanResolver(binding.root.resources)
+		bookmarksAdapter = BookmarksAdapter(
+			coil = coil,
+			lifecycleOwner = viewLifecycleOwner,
+			clickListener = this@MangaBookmarksFragment,
+			headerClickListener = null,
+		)
+		with(binding.recyclerView) {
+			addItemDecoration(TypedListSpacingDecoration(context, false))
+			adapter = bookmarksAdapter
+			addOnLayoutChangeListener(spanResolver)
+			spanResolver?.setGridSize(settings.gridSize / 100f, this)
+			(layoutManager as GridLayoutManager).spanSizeLookup = spanSizeLookup
+		}
+		viewModel.content.observe(viewLifecycleOwner, checkNotNull(bookmarksAdapter))
+	}
+
+	override fun onDestroyView() {
+		spanResolver = null
+		bookmarksAdapter = null
+		spanSizeLookup.invalidateCache()
+		super.onDestroyView()
+	}
+
+	override fun onPause() {
+		// required for BottomSheetBehavior
+		requireViewBinding().recyclerView.isNestedScrollingEnabled = false
+		super.onPause()
+	}
+
+	override fun onResume() {
+		requireViewBinding().recyclerView.isNestedScrollingEnabled = true
+		super.onResume()
+	}
+
+	override fun onWindowInsetsChanged(insets: Insets) = Unit
+
+	override fun onItemClick(item: Bookmark, view: View) {
+		val listener = findParentCallback(ReaderNavigationCallback::class.java)
+		if (listener != null && listener.onBookmarkSelected(item)) {
+			dismissParentDialog()
+		} else {
+			val intent = IntentBuilder(view.context)
+				.manga(activityViewModel.manga.value ?: return)
+				.bookmark(item)
+				.incognito(true)
+				.build()
+			startActivity(intent)
+		}
+	}
+
+	private inner class SpanSizeLookup : GridLayoutManager.SpanSizeLookup() {
+
+		init {
+			isSpanIndexCacheEnabled = true
+			isSpanGroupIndexCacheEnabled = true
+		}
+
+		override fun getSpanSize(position: Int): Int {
+			val total = (viewBinding?.recyclerView?.layoutManager as? GridLayoutManager)?.spanCount ?: return 1
+			return when (bookmarksAdapter?.getItemViewType(position)) {
+				ListItemType.PAGE_THUMB.ordinal -> 1
+				else -> total
+			}
+		}
+
+		fun invalidateCache() {
+			invalidateSpanGroupIndexCache()
+			invalidateSpanIndexCache()
+		}
+	}
+}
+

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/pager/bookmarks/MangaBookmarksViewModel.kt

@@ -0,0 +1,68 @@
+package org.koitharu.kotatsu.details.ui.pager.bookmarks
+
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.FlowCollector
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.plus
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.bookmarks.domain.Bookmark
+import org.koitharu.kotatsu.bookmarks.domain.BookmarksRepository
+import org.koitharu.kotatsu.core.ui.BaseViewModel
+import org.koitharu.kotatsu.list.ui.model.EmptyState
+import org.koitharu.kotatsu.list.ui.model.ListHeader
+import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.list.ui.model.LoadingState
+import org.koitharu.kotatsu.parsers.model.Manga
+import javax.inject.Inject
+
+@HiltViewModel
+class MangaBookmarksViewModel @Inject constructor(
+	bookmarksRepository: BookmarksRepository,
+) : BaseViewModel(), FlowCollector<Manga?> {
+
+	private val manga = MutableStateFlow<Manga?>(null)
+
+	val content: StateFlow<List<ListModel>> = manga.filterNotNull().flatMapLatest { m ->
+		bookmarksRepository.observeBookmarks(m)
+			.map { mapList(m, it) }
+	}.withErrorHandling()
+		.filterNotNull()
+		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Lazily, listOf(LoadingState))
+
+	override suspend fun emit(value: Manga?) {
+		manga.value = value
+	}
+
+	private suspend fun mapList(manga: Manga, bookmarks: List<Bookmark>): List<ListModel>? {
+		val chapters = manga.chapters ?: return null
+		val bookmarksMap = bookmarks.groupBy { it.chapterId }
+		val result = ArrayList<ListModel>(bookmarks.size + bookmarksMap.size)
+		for (chapter in chapters) {
+			val b = bookmarksMap[chapter.id]
+			if (b.isNullOrEmpty()) {
+				continue
+			}
+			result += ListHeader(chapter.name)
+			result.addAll(b)
+		}
+		if (result.isEmpty()) {
+			result.add(
+				EmptyState(
+					icon = 0,
+					textPrimary = R.string.no_bookmarks_yet,
+					textSecondary = R.string.no_bookmarks_summary,
+					actionStringRes = 0,
+				),
+			)
+		}
+		return result
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/pager/chapters/ChaptersFragment.kt

@@ -22,6 +22,9 @@ import org.koitharu.kotatsu.core.ui.BaseFragment
 import org.koitharu.kotatsu.core.ui.list.ListSelectionController
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.core.util.RecyclerViewScrollCallback
+import org.koitharu.kotatsu.core.util.ext.dismissParentDialog
+import org.koitharu.kotatsu.core.util.ext.findAppCompatDelegate
+import org.koitharu.kotatsu.core.util.ext.findParentCallback
 import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.core.util.ext.observeEvent
 import org.koitharu.kotatsu.databinding.FragmentChaptersBinding
@@ -37,6 +40,7 @@ import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.local.ui.LocalChaptersRemoveService
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.reader.ui.ReaderActivity.IntentBuilder
+import org.koitharu.kotatsu.reader.ui.ReaderNavigationCallback
 import org.koitharu.kotatsu.reader.ui.ReaderState
 import kotlin.math.roundToInt
 
@@ -59,7 +63,7 @@ class ChaptersFragment :
 		super.onViewBindingCreated(binding, savedInstanceState)
 		chaptersAdapter = ChaptersAdapter(this)
 		selectionController = ListSelectionController(
-			activity = requireActivity(),
+			appCompatDelegate = checkNotNull(findAppCompatDelegate()),
 			decoration = ChaptersSelectionDecoration(binding.root.context),
 			registryOwner = this,
 			callback = this,
@@ -121,12 +125,17 @@ class ChaptersFragment :
 		if (selectionController?.onItemClick(item.chapter.id) == true) {
 			return
 		}
-		startActivity(
-			IntentBuilder(view.context)
-				.manga(viewModel.manga.value ?: return)
-				.state(ReaderState(item.chapter.id, 0, 0))
-				.build(),
-		)
+		val listener = findParentCallback(ReaderNavigationCallback::class.java)
+		if (listener != null && listener.onChapterSelected(item.chapter)) {
+			dismissParentDialog()
+		} else {
+			startActivity(
+				IntentBuilder(view.context)
+					.manga(viewModel.manga.value ?: return)
+					.state(ReaderState(item.chapter.id, 0, 0))
+					.build(),
+			)
+		}
 	}
 
 	override fun onItemLongClick(item: ChapterListItem, view: View): Boolean {

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/pager/pages/PagesFragment.kt

@@ -23,16 +23,18 @@ import org.koitharu.kotatsu.core.ui.BaseFragment
 import org.koitharu.kotatsu.core.ui.list.BoundsScrollListener
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.core.util.RecyclerViewScrollCallback
+import org.koitharu.kotatsu.core.util.ext.dismissParentDialog
+import org.koitharu.kotatsu.core.util.ext.findParentCallback
 import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.core.util.ext.observeEvent
 import org.koitharu.kotatsu.core.util.ext.showOrHide
 import org.koitharu.kotatsu.databinding.FragmentPagesBinding
 import org.koitharu.kotatsu.details.ui.DetailsViewModel
-import org.koitharu.kotatsu.list.ui.MangaListSpanResolver
 import org.koitharu.kotatsu.list.ui.adapter.ListItemType
 import org.koitharu.kotatsu.list.ui.adapter.TypedListSpacingDecoration
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.reader.ui.ReaderActivity.IntentBuilder
+import org.koitharu.kotatsu.reader.ui.ReaderNavigationCallback
 import org.koitharu.kotatsu.reader.ui.ReaderState
 import org.koitharu.kotatsu.reader.ui.thumbnails.PageThumbnail
 import org.koitharu.kotatsu.reader.ui.thumbnails.adapter.PageThumbnailAdapter
@@ -54,7 +56,7 @@ class PagesFragment :
 	lateinit var settings: AppSettings
 
 	private var thumbnailsAdapter: PageThumbnailAdapter? = null
-	private var spanResolver: MangaListSpanResolver? = null
+	private var spanResolver: PagesGridSpanResolver? = null
 	private var scrollListener: ScrollListener? = null
 
 	private val spanSizeLookup = SpanSizeLookup()
@@ -81,19 +83,19 @@ class PagesFragment :
 
 	override fun onViewBindingCreated(binding: FragmentPagesBinding, savedInstanceState: Bundle?) {
 		super.onViewBindingCreated(binding, savedInstanceState)
-		spanResolver = MangaListSpanResolver(binding.root.resources)
+		spanResolver = PagesGridSpanResolver(binding.root.resources)
 		thumbnailsAdapter = PageThumbnailAdapter(
 			coil = coil,
 			lifecycleOwner = viewLifecycleOwner,
 			clickListener = this@PagesFragment,
 		)
+		viewModel.gridScale.observe(viewLifecycleOwner, ::onGridScaleChanged) // before rv initialization
 		with(binding.recyclerView) {
 			addItemDecoration(TypedListSpacingDecoration(context, false))
 			adapter = thumbnailsAdapter
 			setHasFixedSize(true)
 			isNestedScrollingEnabled = false
 			addOnLayoutChangeListener(spanResolver)
-			spanResolver?.setGridSize(settings.gridSize / 100f, this)
 			addOnScrollListener(ScrollListener().also { scrollListener = it })
 			(layoutManager as GridLayoutManager).let {
 				it.spanSizeLookup = spanSizeLookup
@@ -130,10 +132,17 @@ class PagesFragment :
 	override fun onWindowInsetsChanged(insets: Insets) = Unit
 
 	override fun onItemClick(item: PageThumbnail, view: View) {
-		val manga = detailsViewModel.manga.value ?: return
-		val state = ReaderState(item.page.chapterId, item.page.index, 0)
-		val intent = IntentBuilder(view.context).manga(manga).state(state).build()
-		startActivity(intent)
+		val listener = findParentCallback(ReaderNavigationCallback::class.java)
+		if (listener != null && listener.onPageSelected(item.page)) {
+			dismissParentDialog()
+		} else {
+			startActivity(
+				IntentBuilder(view.context)
+					.manga(detailsViewModel.manga.value ?: return)
+					.state(ReaderState(item.page.chapterId, item.page.index, 0))
+					.build(),
+			)
+		}
 	}
 
 	private suspend fun onThumbnailsChanged(list: List<ListModel>) {
@@ -163,6 +172,11 @@ class PagesFragment :
 		}
 	}
 
+	private fun onGridScaleChanged(scale: Float) {
+		spanSizeLookup.invalidateCache()
+		spanResolver?.setGridSize(scale, requireViewBinding().recyclerView)
+	}
+
 	private fun onNoChaptersChanged(isNoChapters: Boolean) {
 		with(viewBinding ?: return) {
 			textViewHolder.isVisible = isNoChapters

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/pager/pages/PagesGridSpanResolver.kt

@@ -0,0 +1,59 @@
+package org.koitharu.kotatsu.details.ui.pager.pages
+
+import android.content.res.Resources
+import android.view.View
+import androidx.recyclerview.widget.GridLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import org.koitharu.kotatsu.R
+import kotlin.math.abs
+import kotlin.math.roundToInt
+
+class PagesGridSpanResolver(
+	resources: Resources,
+) : View.OnLayoutChangeListener {
+
+	var spanCount = 3
+		private set
+
+	private val gridWidth = resources.getDimension(R.dimen.preferred_grid_width)
+	private val spacing = resources.getDimension(R.dimen.grid_spacing)
+	private var cellWidth = -1f
+
+	override fun onLayoutChange(
+		v: View?,
+		left: Int,
+		top: Int,
+		right: Int,
+		bottom: Int,
+		oldLeft: Int,
+		oldTop: Int,
+		oldRight: Int,
+		oldBottom: Int,
+	) {
+		if (cellWidth <= 0f) {
+			return
+		}
+		val rv = v as? RecyclerView ?: return
+		val width = abs(right - left)
+		if (width == 0) {
+			return
+		}
+		resolveGridSpanCount(width)
+		(rv.layoutManager as? GridLayoutManager)?.spanCount = spanCount
+	}
+
+	fun setGridSize(scaleFactor: Float, rv: RecyclerView) {
+		cellWidth = (gridWidth * scaleFactor) + spacing
+		val lm = rv.layoutManager as? GridLayoutManager ?: return
+		val innerWidth = lm.width - lm.paddingEnd - lm.paddingStart
+		if (innerWidth > 0) {
+			resolveGridSpanCount(innerWidth)
+			lm.spanCount = spanCount
+		}
+	}
+
+	private fun resolveGridSpanCount(width: Int) {
+		val estimatedCount = (width / cellWidth).roundToInt()
+		spanCount = estimatedCount.coerceAtLeast(2)
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/pager/pages/PagesViewModel.kt

@@ -1,11 +1,15 @@
 package org.koitharu.kotatsu.details.ui.pager.pages
 
+import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.plus
 import org.koitharu.kotatsu.core.model.MangaHistory
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.core.prefs.observeAsStateFlow
 import org.koitharu.kotatsu.core.ui.BaseViewModel
 import org.koitharu.kotatsu.core.util.ext.firstNotNull
 import org.koitharu.kotatsu.details.data.MangaDetails
@@ -18,6 +22,7 @@ import javax.inject.Inject
 @HiltViewModel
 class PagesViewModel @Inject constructor(
 	private val chaptersLoader: ChaptersLoader,
+	private val settings: AppSettings,
 ) : BaseViewModel() {
 
 	private var loadingJob: Job? = null
@@ -29,6 +34,12 @@ class PagesViewModel @Inject constructor(
 	val isLoadingUp = MutableStateFlow(false)
 	val isLoadingDown = MutableStateFlow(false)
 
+	val gridScale = settings.observeAsStateFlow(
+		scope = viewModelScope + Dispatchers.Default,
+		key = AppSettings.KEY_GRID_SIZE_PAGES,
+		valueProducer = { gridSizePages / 100f },
+	)
+
 	init {
 		loadingJob = launchLoadingJob(Dispatchers.Default) {
 			val firstState = state.firstNotNull()

app/src/main/kotlin/org/koitharu/kotatsu/download/ui/list/DownloadsActivity.kt

@@ -44,7 +44,7 @@ class DownloadsActivity : BaseActivity<ActivityDownloadsBinding>(),
 		val downloadsAdapter = DownloadsAdapter(this, coil, this)
 		val decoration = TypedListSpacingDecoration(this, false)
 		selectionController = ListSelectionController(
-			activity = this,
+			appCompatDelegate = delegate,
 			decoration = DownloadsSelectionDecoration(this),
 			registryOwner = this,
 			callback = this,

app/src/main/kotlin/org/koitharu/kotatsu/favourites/data/FavouritesDao.kt

@@ -50,6 +50,9 @@ abstract class FavouritesDao {
 	@Query("SELECT * FROM favourites WHERE deleted_at = 0 ORDER BY created_at DESC LIMIT :limit OFFSET :offset")
 	abstract suspend fun findAllRaw(offset: Int, limit: Int): List<FavouriteManga>
 
+	@Query("SELECT DISTINCT manga_id FROM favourites WHERE deleted_at = 0 AND category_id IN (SELECT category_id FROM favourite_categories WHERE track = 1)")
+	abstract suspend fun findIdsWithTrack(): LongArray
+
 	@Transaction
 	@Query(
 		"SELECT * FROM favourites WHERE category_id = :categoryId AND deleted_at = 0 " +
@@ -118,6 +121,9 @@ abstract class FavouritesDao {
 	@Query("SELECT * FROM favourites WHERE manga_id = :id AND deleted_at = 0 GROUP BY manga_id")
 	abstract suspend fun find(id: Long): FavouriteManga?
 
+	@Query("SELECT * FROM favourites WHERE manga_id = :mangaId AND deleted_at = 0")
+	abstract suspend fun findAllRaw(mangaId: Long): List<FavouriteEntity>
+
 	@Transaction
 	@Deprecated("Ignores order")
 	@Query("SELECT * FROM favourites WHERE manga_id = :id AND deleted_at = 0 GROUP BY manga_id")
@@ -126,9 +132,15 @@ abstract class FavouritesDao {
 	@Query("SELECT DISTINCT category_id FROM favourites WHERE manga_id = :id AND deleted_at = 0")
 	abstract fun observeIds(id: Long): Flow<List<Long>>
 
-	@Query("SELECT DISTINCT category_id FROM favourites WHERE manga_id IN (:mangaIds) AND deleted_at = 0")
+	@Query("SELECT favourite_categories.* FROM favourites LEFT JOIN favourite_categories ON favourite_categories.category_id = favourites.category_id WHERE favourites.manga_id = :mangaId AND favourites.deleted_at = 0")
+	abstract fun observeCategories(mangaId: Long): Flow<List<FavouriteCategoryEntity>>
+
+	@Query("SELECT DISTINCT category_id FROM favourites WHERE manga_id IN (:mangaIds) AND deleted_at = 0 ORDER BY favourites.created_at ASC")
 	abstract suspend fun findCategoriesIds(mangaIds: Collection<Long>): List<Long>
 
+	@Query("SELECT DISTINCT favourite_categories.category_id FROM favourites LEFT JOIN favourite_categories ON favourites.category_id = favourite_categories.category_id WHERE manga_id = :mangaId AND favourites.deleted_at = 0 AND favourite_categories.deleted_at = 0 AND favourite_categories.track = 1")
+	abstract suspend fun findCategoriesIdsWithTrack(mangaId: Long): List<Long>
+
 	/** INSERT **/
 
 	@Insert(onConflict = OnConflictStrategy.REPLACE)

app/src/main/kotlin/org/koitharu/kotatsu/favourites/domain/FavouritesRepository.kt

@@ -107,6 +107,12 @@ class FavouritesRepository @Inject constructor(
 		return db.getFavouritesDao().observeIds(mangaId).map { it.toSet() }
 	}
 
+	fun observeCategories(mangaId: Long): Flow<Set<FavouriteCategory>> {
+		return db.getFavouritesDao().observeCategories(mangaId).map {
+			it.mapTo(LinkedHashSet(it.size)) { x -> x.toFavouriteCategory() }
+		}
+	}
+
 	suspend fun getCategory(id: Long): FavouriteCategory {
 		return db.getFavouriteCategoriesDao().find(id.toInt()).toFavouriteCategory()
 	}

app/src/main/kotlin/org/koitharu/kotatsu/favourites/ui/categories/FavouriteCategoriesActivity.kt

@@ -51,7 +51,7 @@ class FavouriteCategoriesActivity :
 		supportActionBar?.setDisplayHomeAsUpEnabled(true)
 		adapter = CategoriesAdapter(coil, this, this, this)
 		selectionController = ListSelectionController(
-			activity = this,
+			appCompatDelegate = delegate,
 			decoration = CategoriesSelectionDecoration(this),
 			registryOwner = this,
 			callback = CategoriesSelectionCallback(viewBinding.recyclerView, viewModel),

app/src/main/kotlin/org/koitharu/kotatsu/favourites/ui/categories/select/adapter/MangaCategoryAD.kt

@@ -1,5 +1,6 @@
 package org.koitharu.kotatsu.favourites.ui.categories.select.adapter
 
+import androidx.core.view.isGone
 import androidx.core.view.isVisible
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
@@ -23,6 +24,6 @@ fun mangaCategoryAD(
 		binding.checkableImageView.setChecked(item.isChecked, ListModelDiffCallback.PAYLOAD_CHECKED_CHANGED in payloads)
 		binding.textViewTitle.text = item.category.title
 		binding.imageViewTracker.isVisible = item.category.isTrackingEnabled && item.isTrackerEnabled
-		binding.imageViewVisible.isVisible = item.category.isVisibleInLibrary
+		binding.imageViewHidden.isGone = item.category.isVisibleInLibrary
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/history/data/HistoryDao.kt

@@ -58,6 +58,9 @@ abstract class HistoryDao {
 	@Query("SELECT * FROM manga WHERE manga_id IN (SELECT manga_id FROM history WHERE deleted_at = 0)")
 	abstract suspend fun findAllManga(): List<MangaEntity>
 
+	@Query("SELECT manga_id FROM history WHERE deleted_at = 0")
+	abstract suspend fun findAllIds(): LongArray
+
 	@Query(
 		"""SELECT tags.* FROM tags
 		LEFT JOIN manga_tags ON tags.tag_id = manga_tags.tag_id
@@ -78,6 +81,9 @@ abstract class HistoryDao {
 	@Query("SELECT COUNT(*) FROM history WHERE deleted_at = 0")
 	abstract fun observeCount(): Flow<Int>
 
+	@Query("SELECT COUNT(*) FROM history WHERE deleted_at = 0")
+	abstract suspend fun getCount(): Int
+
 	@Query("SELECT percent FROM history WHERE manga_id = :id AND deleted_at = 0")
 	abstract suspend fun findProgress(id: Long): Float?
 

app/src/main/kotlin/org/koitharu/kotatsu/history/data/HistoryRepository.kt

@@ -45,6 +45,10 @@ class HistoryRepository @Inject constructor(
 		return entities.map { it.manga.toManga(it.tags.toMangaTags()) }
 	}
 
+	suspend fun getCount(): Int {
+		return db.getHistoryDao().getCount()
+	}
+
 	suspend fun getLastOrNull(): Manga? {
 		val entity = db.getHistoryDao().findAll(0, 1).firstOrNull() ?: return null
 		return entity.manga.toManga(entity.tags.toMangaTags())

app/src/main/kotlin/org/koitharu/kotatsu/image/ui/ImageActivity.kt

@@ -10,8 +10,8 @@ import android.view.ViewGroup
 import androidx.core.graphics.Insets
 import androidx.core.graphics.drawable.toBitmap
 import androidx.core.view.isVisible
+import androidx.core.view.marginBottom
 import androidx.core.view.updateLayoutParams
-import androidx.core.view.updatePadding
 import coil.ImageLoader
 import coil.request.CachePolicy
 import coil.request.ErrorResult
@@ -21,6 +21,7 @@ import coil.target.ViewTarget
 import com.davemorrissey.labs.subscaleview.ImageSource
 import com.davemorrissey.labs.subscaleview.SubsamplingScaleImageView
 import dagger.hilt.android.AndroidEntryPoint
+import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.ui.BaseActivity
 import org.koitharu.kotatsu.core.util.ext.enqueueWith
 import org.koitharu.kotatsu.core.util.ext.getDisplayIcon
@@ -42,27 +43,25 @@ class ImageActivity : BaseActivity<ActivityImageBinding>(), ImageRequest.Listene
 	override fun onCreate(savedInstanceState: Bundle?) {
 		super.onCreate(savedInstanceState)
 		setContentView(ActivityImageBinding.inflate(layoutInflater))
-		supportActionBar?.run {
-			setDisplayHomeAsUpEnabled(true)
-			setDisplayShowTitleEnabled(false)
-		}
+		viewBinding.buttonBack.setOnClickListener(this)
 		loadImage(intent.data)
 	}
 
 	override fun onWindowInsetsChanged(insets: Insets) {
-		with(viewBinding.toolbar) {
-			updatePadding(
-				left = insets.left,
-				right = insets.right,
-			)
+		with(viewBinding.buttonBack) {
 			updateLayoutParams<ViewGroup.MarginLayoutParams> {
-				topMargin = insets.top
+				topMargin = insets.top + marginBottom
+				leftMargin = insets.left + marginBottom
+				rightMargin = insets.right + marginBottom
 			}
 		}
 	}
 
-	override fun onClick(v: View?) {
-		loadImage(intent.data)
+	override fun onClick(v: View) {
+		when (v.id) {
+			R.id.button_back -> dispatchNavigateUp()
+			else -> loadImage(intent.data)
+		}
 	}
 
 	override fun onError(request: ImageRequest, result: ErrorResult) {

app/src/main/kotlin/org/koitharu/kotatsu/list/ui/MangaListFragment.kt

@@ -31,8 +31,10 @@ import org.koitharu.kotatsu.core.ui.list.ListSelectionController
 import org.koitharu.kotatsu.core.ui.list.PaginationScrollListener
 import org.koitharu.kotatsu.core.ui.list.fastscroll.FastScroller
 import org.koitharu.kotatsu.core.ui.util.ReversibleActionObserver
+import org.koitharu.kotatsu.core.ui.widgets.TipView
 import org.koitharu.kotatsu.core.util.ShareHelper
 import org.koitharu.kotatsu.core.util.ext.addMenuProvider
+import org.koitharu.kotatsu.core.util.ext.findAppCompatDelegate
 import org.koitharu.kotatsu.core.util.ext.measureHeight
 import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.core.util.ext.observeEvent
@@ -98,7 +100,7 @@ abstract class MangaListFragment :
 		listAdapter = onCreateAdapter()
 		spanResolver = MangaListSpanResolver(binding.root.resources)
 		selectionController = ListSelectionController(
-			activity = requireActivity(),
+			appCompatDelegate = checkNotNull(findAppCompatDelegate()),
 			decoration = MangaSelectionDecoration(binding.root.context),
 			registryOwner = this,
 			callback = this,
@@ -230,6 +232,10 @@ abstract class MangaListFragment :
 
 	override fun onListHeaderClick(item: ListHeader, view: View) = Unit
 
+	override fun onPrimaryButtonClick(tipView: TipView) = Unit
+
+	override fun onSecondaryButtonClick(tipView: TipView) = Unit
+
 	override fun onRetryClick(error: Throwable) {
 		resolveException(error)
 	}

app/src/main/kotlin/org/koitharu/kotatsu/list/ui/adapter/MangaListAdapter.kt

@@ -24,5 +24,6 @@ open class MangaListAdapter(
 		addDelegate(ListItemType.STATE_EMPTY, emptyStateListAD(coil, lifecycleOwner, listener))
 		addDelegate(ListItemType.HINT_EMPTY, emptyHintAD(coil, lifecycleOwner, listener))
 		addDelegate(ListItemType.HEADER, listHeaderAD(listener))
+		addDelegate(ListItemType.TIP, tipAD(listener))
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/list/ui/adapter/MangaListDetailedItemAD.kt

@@ -1,16 +1,13 @@
 package org.koitharu.kotatsu.list.ui.adapter
 
 import android.view.View
-import androidx.core.view.isVisible
 import androidx.lifecycle.LifecycleOwner
 import coil.ImageLoader
 import com.google.android.material.badge.BadgeDrawable
-import com.google.android.material.chip.Chip
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.ui.image.CoverSizeResolver
 import org.koitharu.kotatsu.core.ui.image.TrimTransformation
-import org.koitharu.kotatsu.core.ui.widgets.ChipsView
 import org.koitharu.kotatsu.core.util.ext.enqueueWith
 import org.koitharu.kotatsu.core.util.ext.newImageRequest
 import org.koitharu.kotatsu.core.util.ext.setOnContextClickListenerCompat
@@ -20,7 +17,6 @@ import org.koitharu.kotatsu.databinding.ItemMangaListDetailsBinding
 import org.koitharu.kotatsu.list.ui.ListModelDiffCallback
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.list.ui.model.MangaListDetailedModel
-import org.koitharu.kotatsu.parsers.model.MangaTag
 
 fun mangaListDetailedItemAD(
 	coil: ImageLoader,
@@ -31,28 +27,18 @@ fun mangaListDetailedItemAD(
 ) {
 	var badge: BadgeDrawable? = null
 
-	val listenerAdapter = object : View.OnClickListener, View.OnLongClickListener, ChipsView.OnChipClickListener {
-		override fun onClick(v: View) = when (v.id) {
-			R.id.button_read -> clickListener.onReadClick(item.manga, v)
-			else -> clickListener.onItemClick(item.manga, v)
-		}
+	val listenerAdapter = object : View.OnClickListener, View.OnLongClickListener {
+		override fun onClick(v: View) = clickListener.onItemClick(item.manga, v)
 
 		override fun onLongClick(v: View): Boolean = clickListener.onItemLongClick(item.manga, v)
-
-		override fun onChipClick(chip: Chip, data: Any?) {
-			val tag = data as? MangaTag ?: return
-			clickListener.onTagClick(item.manga, tag, chip)
-		}
 	}
 	itemView.setOnClickListener(listenerAdapter)
 	itemView.setOnLongClickListener(listenerAdapter)
 	itemView.setOnContextClickListenerCompat(listenerAdapter)
-	binding.buttonRead.setOnClickListener(listenerAdapter)
-	binding.chipsTags.onChipClickListener = listenerAdapter
 
 	bind { payloads ->
 		binding.textViewTitle.text = item.title
-		binding.textViewSubtitle.textAndVisible = item.subtitle
+		binding.textViewAuthor.textAndVisible = item.manga.author
 		binding.progressView.setPercent(item.progress, ListModelDiffCallback.PAYLOAD_PROGRESS_CHANGED in payloads)
 		binding.imageViewCover.newImageRequest(lifecycleOwner, item.coverUrl)?.run {
 			size(CoverSizeResolver(binding.imageViewCover))
@@ -65,12 +51,7 @@ fun mangaListDetailedItemAD(
 			source(item.source)
 			enqueueWith(coil)
 		}
-		if (payloads.isEmpty()) {
-			binding.scrollViewTags.scrollTo(0, 0)
-		}
-		binding.chipsTags.setChips(item.tags)
-		binding.ratingBar.isVisible = item.manga.hasRating
-		binding.ratingBar.rating = binding.ratingBar.numStars * item.manga.rating
+		binding.textViewTags.text = item.tags.joinToString(separator = ", ") { it.title }
 		badge = itemView.bindBadge(badge, item.counter)
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/list/ui/adapter/MangaListListener.kt

@@ -1,9 +1,11 @@
 package org.koitharu.kotatsu.list.ui.adapter
 
 import android.view.View
+import org.koitharu.kotatsu.core.ui.widgets.TipView
 import org.koitharu.kotatsu.parsers.model.MangaTag
 
-interface MangaListListener : MangaDetailsClickListener, ListStateHolderListener, ListHeaderClickListener {
+interface MangaListListener : MangaDetailsClickListener, ListStateHolderListener, ListHeaderClickListener,
+	TipView.OnButtonClickListener {
 
 	fun onUpdateFilter(tags: Set<MangaTag>)
 

app/src/main/kotlin/org/koitharu/kotatsu/local/data/LocalStorageManager.kt

@@ -1,11 +1,16 @@
 package org.koitharu.kotatsu.local.data
 
+import android.Manifest
 import android.content.ContentResolver
 import android.content.Context
 import android.content.Intent
+import android.content.pm.PackageManager
 import android.net.Uri
+import android.os.Build
+import android.os.Environment
 import android.os.StatFs
 import androidx.annotation.WorkerThread
+import androidx.core.content.ContextCompat
 import androidx.core.net.toFile
 import dagger.Reusable
 import dagger.hilt.android.qualifiers.ApplicationContext
@@ -101,6 +106,23 @@ class LocalStorageManager @Inject constructor(
 		contentResolver.takePersistableUriPermission(uri, flags)
 	}
 
+	fun isOnExternalStorage(file: File): Boolean {
+		return !file.absolutePath.contains(context.packageName)
+	}
+
+	fun hasExternalStoragePermission(isReadOnly: Boolean): Boolean {
+		return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+			Environment.isExternalStorageManager()
+		} else {
+			val permission = if (isReadOnly) {
+				Manifest.permission.READ_EXTERNAL_STORAGE
+			} else {
+				Manifest.permission.WRITE_EXTERNAL_STORAGE
+			}
+			ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED
+		}
+	}
+
 	suspend fun getDirectoryDisplayName(dir: File, isFullPath: Boolean): String = runInterruptible(Dispatchers.IO) {
 		val packageName = context.packageName
 		if (dir.absolutePath.contains(packageName)) {

app/src/main/kotlin/org/koitharu/kotatsu/local/data/PagesCache.kt

@@ -12,6 +12,7 @@ import okio.Source
 import okio.buffer
 import okio.sink
 import okio.use
+import org.koitharu.kotatsu.core.exceptions.NoDataReceivedException
 import org.koitharu.kotatsu.core.util.FileSize
 import org.koitharu.kotatsu.core.util.ext.compressToPNG
 import org.koitharu.kotatsu.core.util.ext.longHashCode
@@ -62,7 +63,9 @@ class PagesCache @Inject constructor(@ApplicationContext context: Context) {
 			val bytes = file.sink(append = false).buffer().use {
 				it.writeAllCancellable(source)
 			}
-			check(bytes != 0L) { "No data has been written" }
+			if (bytes == 0L) {
+				throw NoDataReceivedException(url)
+			}
 			lruCache.get().put(url, file)
 		} finally {
 			file.delete()

app/src/main/kotlin/org/koitharu/kotatsu/local/ui/ImportWorker.kt

@@ -50,7 +50,7 @@ class ImportWorker @AssistedInject constructor(
 		val result = runCatchingCancellable {
 			importer.import(uri).manga
 		}
-		if (applicationContext.checkNotificationPermission()) {
+		if (applicationContext.checkNotificationPermission(CHANNEL_ID)) {
 			val notification = buildNotification(result)
 			notificationManager.notify(uri.hashCode(), notification)
 		}

app/src/main/kotlin/org/koitharu/kotatsu/local/ui/LocalListFragment.kt

@@ -1,9 +1,12 @@
 package org.koitharu.kotatsu.local.ui
 
+import android.Manifest
+import android.os.Build
 import android.os.Bundle
 import android.view.Menu
 import android.view.MenuItem
 import android.view.View
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.view.ActionMode
 import androidx.core.net.toFile
 import androidx.core.net.toUri
@@ -12,9 +15,11 @@ import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.snackbar.Snackbar
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.ui.list.ListSelectionController
+import org.koitharu.kotatsu.core.ui.widgets.TipView
 import org.koitharu.kotatsu.core.util.ShareHelper
 import org.koitharu.kotatsu.core.util.ext.addMenuProvider
 import org.koitharu.kotatsu.core.util.ext.observeEvent
+import org.koitharu.kotatsu.core.util.ext.tryLaunch
 import org.koitharu.kotatsu.core.util.ext.withArgs
 import org.koitharu.kotatsu.databinding.FragmentListBinding
 import org.koitharu.kotatsu.filter.ui.FilterOwner
@@ -23,9 +28,23 @@ import org.koitharu.kotatsu.filter.ui.sheet.FilterSheetFragment
 import org.koitharu.kotatsu.list.ui.MangaListFragment
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.remotelist.ui.RemoteListFragment
+import org.koitharu.kotatsu.settings.storage.RequestStorageManagerPermissionContract
+import org.koitharu.kotatsu.settings.storage.directories.MangaDirectoriesActivity
 
 class LocalListFragment : MangaListFragment(), FilterOwner {
 
+	private val permissionRequestLauncher = registerForActivityResult(
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+			RequestStorageManagerPermissionContract()
+		} else {
+			ActivityResultContracts.RequestPermission()
+		},
+	) {
+		if (it) {
+			viewModel.onRefresh()
+		}
+	}
+
 	init {
 		withArgs(1) {
 			putSerializable(
@@ -54,6 +73,16 @@ class LocalListFragment : MangaListFragment(), FilterOwner {
 		FilterSheetFragment.show(childFragmentManager)
 	}
 
+	override fun onPrimaryButtonClick(tipView: TipView) {
+		if (!permissionRequestLauncher.tryLaunch(Manifest.permission.READ_EXTERNAL_STORAGE)) {
+			Snackbar.make(tipView, R.string.operation_not_supported, Snackbar.LENGTH_SHORT).show()
+		}
+	}
+
+	override fun onSecondaryButtonClick(tipView: TipView) {
+		startActivity(MangaDirectoriesActivity.newIntent(tipView.context))
+	}
+
 	override fun onScrolledToEnd() = viewModel.loadNextPage()
 
 	override fun onCreateActionMode(

app/src/main/kotlin/org/koitharu/kotatsu/local/ui/LocalListViewModel.kt

@@ -10,12 +10,18 @@ import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.util.ext.MutableEventFlow
 import org.koitharu.kotatsu.core.util.ext.call
+import org.koitharu.kotatsu.core.util.ext.toFileOrNull
+import org.koitharu.kotatsu.core.util.ext.toUriOrNull
 import org.koitharu.kotatsu.download.ui.worker.DownloadWorker
 import org.koitharu.kotatsu.explore.domain.ExploreRepository
 import org.koitharu.kotatsu.filter.ui.FilterCoordinator
 import org.koitharu.kotatsu.list.domain.ListExtraProvider
 import org.koitharu.kotatsu.list.ui.model.EmptyState
+import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.list.ui.model.MangaItemModel
+import org.koitharu.kotatsu.list.ui.model.TipModel
 import org.koitharu.kotatsu.local.data.LocalStorageChanges
+import org.koitharu.kotatsu.local.data.LocalStorageManager
 import org.koitharu.kotatsu.local.domain.DeleteLocalMangaUseCase
 import org.koitharu.kotatsu.local.domain.model.LocalManga
 import org.koitharu.kotatsu.remotelist.ui.RemoteListViewModel
@@ -32,6 +38,7 @@ class LocalListViewModel @Inject constructor(
 	private val deleteLocalMangaUseCase: DeleteLocalMangaUseCase,
 	exploreRepository: ExploreRepository,
 	@LocalStorageChanges private val localStorageChanges: SharedFlow<LocalManga?>,
+	private val localStorageManager: LocalStorageManager,
 ) : RemoteListViewModel(
 	savedStateHandle,
 	mangaRepositoryFactory,
@@ -54,6 +61,31 @@ class LocalListViewModel @Inject constructor(
 		settings.subscribe(this)
 	}
 
+	override suspend fun onBuildList(list: MutableList<ListModel>) {
+		super.onBuildList(list)
+		if (localStorageManager.hasExternalStoragePermission(isReadOnly = true)) {
+			return
+		}
+		for (item in list) {
+			if (item !is MangaItemModel) {
+				continue
+			}
+			val file = item.manga.url.toUriOrNull()?.toFileOrNull() ?: continue
+			if (localStorageManager.isOnExternalStorage(file)) {
+				val tip = TipModel(
+					key = "permission",
+					title = R.string.external_storage,
+					text = R.string.missing_storage_permission,
+					icon = R.drawable.ic_storage,
+					primaryButtonText = R.string.fix,
+					secondaryButtonText = R.string.settings,
+				)
+				list.add(0, tip)
+				return
+			}
+		}
+	}
+
 	override fun onCleared() {
 		settings.unsubscribe(this)
 		super.onCleared()

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/ChaptersSheet.kt

@@ -30,6 +30,7 @@ import java.time.Instant
 import javax.inject.Inject
 import kotlin.math.roundToInt
 
+@Deprecated("Use ChaptersPagesSheet instead")
 @AndroidEntryPoint
 class ChaptersSheet : BaseAdaptiveSheet<SheetChaptersBinding>(),
 	OnListItemClickListener<ChapterListItem> {
@@ -105,13 +106,13 @@ class ChaptersSheet : BaseAdaptiveSheet<SheetChaptersBinding>(),
 		((parentFragment as? OnChapterChangeListener)
 			?: (activity as? OnChapterChangeListener))?.let {
 			dismiss()
-			it.onChapterChanged(item.chapter)
+			it.onChapterSelected(item.chapter)
 		}
 	}
 
 	fun interface OnChapterChangeListener {
 
-		fun onChapterChanged(chapter: MangaChapter)
+		fun onChapterSelected(chapter: MangaChapter): Boolean
 	}
 
 	companion object {

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/ReaderActivity.kt

@@ -74,6 +74,7 @@ class ReaderActivity :
 	ReaderConfigSheet.Callback,
 	ReaderControlDelegate.OnInteractionListener,
 	OnApplyWindowInsetsListener,
+	ReaderNavigationCallback,
 	IdlingDetector.Callback,
 	ActivityResultCallback<Uri?>,
 	ZoomControl.ZoomControlListener {
@@ -257,11 +258,12 @@ class ReaderActivity :
 		return controlDelegate.onKeyUp(keyCode, event) || super.onKeyUp(keyCode, event)
 	}
 
-	override fun onChapterChanged(chapter: MangaChapter) {
+	override fun onChapterSelected(chapter: MangaChapter): Boolean {
 		viewModel.switchChapter(chapter.id, 0)
+		return true
 	}
 
-	override fun onPageSelected(page: ReaderPage) {
+	override fun onPageSelected(page: ReaderPage): Boolean {
 		lifecycleScope.launch(Dispatchers.Default) {
 			val pages = viewModel.content.value.pages
 			val index = pages.indexOfFirst { it.chapterId == page.chapterId && it.id == page.id }
@@ -273,6 +275,7 @@ class ReaderActivity :
 				viewModel.switchChapter(page.chapterId, page.index)
 			}
 		}
+		return true
 	}
 
 	override fun onReaderModeChanged(mode: ReaderMode) {

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/ReaderBottomMenuProvider.kt

@@ -6,6 +6,7 @@ import android.view.MenuItem
 import androidx.core.view.MenuProvider
 import androidx.fragment.app.FragmentActivity
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.details.ui.pager.ChaptersPagesSheet
 import org.koitharu.kotatsu.reader.ui.config.ReaderConfigSheet
 import org.koitharu.kotatsu.reader.ui.thumbnails.PagesThumbnailsSheet
 import org.koitharu.kotatsu.settings.SettingsActivity
@@ -42,13 +43,7 @@ class ReaderBottomMenuProvider(
 			}
 
 			R.id.action_pages_thumbs -> {
-				val state = viewModel.getCurrentState() ?: return false
-				PagesThumbnailsSheet.show(
-					activity.supportFragmentManager,
-					viewModel.manga?.toManga() ?: return false,
-					state.chapterId,
-					state.page,
-				)
+				ChaptersPagesSheet.show(activity.supportFragmentManager, true, ChaptersPagesSheet.TAB_PAGES)
 				true
 			}
 

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/ReaderNavigationCallback.kt

@@ -0,0 +1,16 @@
+package org.koitharu.kotatsu.reader.ui
+
+import org.koitharu.kotatsu.bookmarks.domain.Bookmark
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
+
+interface ReaderNavigationCallback {
+
+	fun onPageSelected(page: ReaderPage): Boolean
+
+	fun onChapterSelected(chapter: MangaChapter): Boolean
+
+	fun onBookmarkSelected(bookmark: Bookmark): Boolean = onPageSelected(
+		ReaderPage(bookmark.toMangaPage(), bookmark.page, bookmark.chapterId),
+	)
+}

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/ReaderTopMenuProvider.kt

@@ -8,6 +8,7 @@ import androidx.fragment.app.FragmentActivity
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.util.ext.DIALOG_THEME_CENTERED
+import org.koitharu.kotatsu.details.ui.pager.ChaptersPagesSheet
 
 class ReaderTopMenuProvider(
 	private val activity: FragmentActivity,
@@ -25,7 +26,7 @@ class ReaderTopMenuProvider(
 	override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
 		return when (menuItem.itemId) {
 			R.id.action_chapters -> {
-				ChaptersSheet.show(activity.supportFragmentManager)
+				ChaptersPagesSheet.show(activity.supportFragmentManager, true, ChaptersPagesSheet.TAB_CHAPTERS)
 				true
 			}
 

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/pager/webtoon/WebtoonReaderFragment.kt

@@ -59,6 +59,9 @@ class WebtoonReaderFragment : BaseReaderFragment<FragmentReaderWebtoonBinding>()
 		viewModel.defaultWebtoonZoomOut.take(1).observe(viewLifecycleOwner) {
 			binding.frame.zoom = 1f - it
 		}
+		viewModel.readerSettings.observe(viewLifecycleOwner) {
+			it.applyBackground(binding.root)
+		}
 	}
 
 	override fun onDestroyView() {

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/thumbnails/OnPageSelectListener.kt

@@ -2,7 +2,8 @@ package org.koitharu.kotatsu.reader.ui.thumbnails
 
 import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
 
+@Deprecated("")
 fun interface OnPageSelectListener {
 
-	fun onPageSelected(page: ReaderPage)
+	fun onPageSelected(page: ReaderPage): Boolean
 }

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/thumbnails/PagesThumbnailsSheet.kt

@@ -38,6 +38,7 @@ import org.koitharu.kotatsu.reader.ui.thumbnails.adapter.PageThumbnailAdapter
 import javax.inject.Inject
 import kotlin.math.roundToInt
 
+@Deprecated("Use ChaptersPagesSheet instead")
 @AndroidEntryPoint
 class PagesThumbnailsSheet :
 	BaseAdaptiveSheet<SheetPagesBinding>(),

app/src/main/kotlin/org/koitharu/kotatsu/remotelist/ui/RemoteListViewModel.kt

@@ -12,7 +12,6 @@ import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.debounce
-import kotlinx.coroutines.flow.getAndUpdate
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
@@ -33,6 +32,7 @@ import org.koitharu.kotatsu.filter.ui.MangaFilter
 import org.koitharu.kotatsu.list.domain.ListExtraProvider
 import org.koitharu.kotatsu.list.ui.MangaListViewModel
 import org.koitharu.kotatsu.list.ui.model.EmptyState
+import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.list.ui.model.LoadingFooter
 import org.koitharu.kotatsu.list.ui.model.LoadingState
 import org.koitharu.kotatsu.list.ui.model.toErrorFooter
@@ -72,7 +72,7 @@ open class RemoteListViewModel @Inject constructor(
 		get() = repository.isSearchSupported
 
 	override val content = combine(
-		mangaList.map { it?.distinctById()?.skipNsfwIfNeeded() },
+		mangaList.map { it?.skipNsfwIfNeeded() },
 		listMode,
 		listError,
 		hasNextPage,
@@ -90,6 +90,7 @@ open class RemoteListViewModel @Inject constructor(
 					}
 				}
 			}
+			onBuildList(this)
 		}
 	}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, listOf(LoadingState))
 
@@ -136,17 +137,16 @@ open class RemoteListViewModel @Inject constructor(
 					offset = if (append) mangaList.value?.size ?: 0 else 0,
 					filter = filterState,
 				)
-				val oldList = mangaList.getAndUpdate { oldList ->
-					if (!append || oldList.isNullOrEmpty()) {
-						list
-					} else {
-						oldList + list
-					}
-				}.orEmpty()
+				val prevList = mangaList.value.orEmpty()
+				if (!append) {
+					mangaList.value = list.distinctById()
+				} else if (list.isNotEmpty()) {
+					mangaList.value = (prevList + list).distinctById()
+				}
 				hasNextPage.value = if (append) {
-					list.isNotEmpty()
+					prevList != mangaList.value
 				} else {
-					list.size > oldList.size || hasNextPage.value
+					list.size > prevList.size || hasNextPage.value
 				}
 			} catch (e: CancellationException) {
 				throw e
@@ -168,6 +168,8 @@ open class RemoteListViewModel @Inject constructor(
 		actionStringRes = if (canResetFilter) R.string.reset_filter else 0,
 	)
 
+	protected open suspend fun onBuildList(list: MutableList<ListModel>) = Unit
+
 	fun openRandom() {
 		if (randomJob?.isActive == true) {
 			return

app/src/main/kotlin/org/koitharu/kotatsu/search/ui/SearchViewModel.kt

@@ -9,9 +9,11 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.plus
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.model.distinctById
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.util.ext.require
@@ -46,7 +48,7 @@ class SearchViewModel @Inject constructor(
 	private var loadingJob: Job? = null
 
 	override val content = combine(
-		mangaList,
+		mangaList.map { it?.skipNsfwIfNeeded() },
 		listMode,
 		listError,
 		hasNextPage,
@@ -102,14 +104,19 @@ class SearchViewModel @Inject constructor(
 				listError.value = null
 				val list = repository.getList(
 					offset = if (append) mangaList.value?.size ?: 0 else 0,
-					filter = MangaListFilter.Search(query)
+					filter = MangaListFilter.Search(query),
 				)
+				val prevList = mangaList.value.orEmpty()
 				if (!append) {
-					mangaList.value = list
+					mangaList.value = list.distinctById()
 				} else if (list.isNotEmpty()) {
-					mangaList.value = mangaList.value?.plus(list) ?: list
+					mangaList.value = (prevList + list).distinctById()
+				}
+				hasNextPage.value = if (append) {
+					prevList != mangaList.value
+				} else {
+					list.isNotEmpty()
 				}
-				hasNextPage.value = list.isNotEmpty()
 			} catch (e: CancellationException) {
 				throw e
 			} catch (e: Throwable) {

app/src/main/kotlin/org/koitharu/kotatsu/search/ui/multi/MultiSearchActivity.kt

@@ -18,6 +18,7 @@ import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.ui.BaseActivity
 import org.koitharu.kotatsu.core.ui.list.ListSelectionController
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
+import org.koitharu.kotatsu.core.ui.widgets.TipView
 import org.koitharu.kotatsu.core.util.ShareHelper
 import org.koitharu.kotatsu.core.util.ext.invalidateNestedItemDecorations
 import org.koitharu.kotatsu.core.util.ext.observe
@@ -66,7 +67,7 @@ class MultiSearchActivity :
 		val sizeResolver = DynamicItemSizeResolver(resources, settings, adjustWidth = true)
 		val selectionDecoration = MangaSelectionDecoration(this)
 		selectionController = ListSelectionController(
-			activity = this,
+			appCompatDelegate = delegate,
 			decoration = selectionDecoration,
 			registryOwner = this,
 			callback = this,
@@ -140,6 +141,10 @@ class MultiSearchActivity :
 
 	override fun onListHeaderClick(item: ListHeader, view: View) = Unit
 
+	override fun onPrimaryButtonClick(tipView: TipView) = Unit
+
+	override fun onSecondaryButtonClick(tipView: TipView) = Unit
+
 	override fun onSelectionChanged(controller: ListSelectionController, count: Int) {
 		viewBinding.recyclerView.invalidateNestedItemDecorations()
 	}

app/src/main/kotlin/org/koitharu/kotatsu/settings/SuggestionsSettingsFragment.kt

@@ -4,6 +4,7 @@ import android.content.SharedPreferences
 import android.os.Bundle
 import androidx.lifecycle.lifecycleScope
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.prefs.AppSettings
@@ -15,8 +16,7 @@ import org.koitharu.kotatsu.suggestions.ui.SuggestionsWorker
 import javax.inject.Inject
 
 @AndroidEntryPoint
-class SuggestionsSettingsFragment :
-	BasePreferenceFragment(R.string.suggestions),
+class SuggestionsSettingsFragment : BasePreferenceFragment(R.string.suggestions),
 	SharedPreferences.OnSharedPreferenceChangeListener {
 
 	@Inject
@@ -48,16 +48,17 @@ class SuggestionsSettingsFragment :
 	}
 
 	override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences?, key: String?) {
-		if (key == AppSettings.KEY_SUGGESTIONS && settings.isSuggestionsEnabled) {
-			onSuggestionsEnabled()
+		if (settings.isSuggestionsEnabled && (key == AppSettings.KEY_SUGGESTIONS
+				|| key == AppSettings.KEY_SUGGESTIONS_EXCLUDE_TAGS
+				|| key == AppSettings.KEY_SUGGESTIONS_EXCLUDE_NSFW)
+		) {
+			updateSuggestions()
 		}
 	}
 
-	private fun onSuggestionsEnabled() {
-		lifecycleScope.launch {
-			if (repository.isEmpty()) {
-				suggestionsScheduler.startNow()
-			}
+	private fun updateSuggestions() {
+		lifecycleScope.launch(Dispatchers.Default) {
+			suggestionsScheduler.startNow()
 		}
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/settings/backup/AppBackupAgent.kt

@@ -13,7 +13,9 @@ import org.koitharu.kotatsu.core.backup.BackupRepository
 import org.koitharu.kotatsu.core.backup.BackupZipInput
 import org.koitharu.kotatsu.core.backup.BackupZipOutput
 import org.koitharu.kotatsu.core.db.MangaDatabase
+import org.koitharu.kotatsu.core.exceptions.BadBackupFormatException
 import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
 import java.io.File
 import java.io.FileDescriptor
 import java.io.FileInputStream
@@ -88,7 +90,12 @@ class AppBackupAgent : BackupAgent() {
 				input.copyLimitedTo(output, size)
 			}
 		}
-		val backup = BackupZipInput(tempFile)
+		val backup = try {
+			BackupZipInput.from(tempFile)
+		} catch (e: BadBackupFormatException) {
+			tempFile.delete()
+			throw e
+		}
 		try {
 			runBlocking {
 				backup.getEntry(BackupEntry.Name.HISTORY)?.let { repository.restoreHistory(it) }

app/src/main/kotlin/org/koitharu/kotatsu/settings/backup/RestoreViewModel.kt

@@ -1,6 +1,8 @@
 package org.koitharu.kotatsu.settings.backup
 
+import android.content.ContentResolver
 import android.content.Context
+import android.net.Uri
 import androidx.lifecycle.SavedStateHandle
 import dagger.hilt.android.lifecycle.HiltViewModel
 import dagger.hilt.android.qualifiers.ApplicationContext
@@ -11,6 +13,8 @@ import org.koitharu.kotatsu.core.backup.BackupEntry
 import org.koitharu.kotatsu.core.backup.BackupRepository
 import org.koitharu.kotatsu.core.backup.BackupZipInput
 import org.koitharu.kotatsu.core.backup.CompositeResult
+import org.koitharu.kotatsu.core.exceptions.BadBackupFormatException
+import org.koitharu.kotatsu.core.exceptions.UnsupportedFileException
 import org.koitharu.kotatsu.core.ui.BaseViewModel
 import org.koitharu.kotatsu.core.util.ext.MutableEventFlow
 import org.koitharu.kotatsu.core.util.ext.call
@@ -41,7 +45,7 @@ class RestoreViewModel @Inject constructor(
 					input.copyTo(output)
 				}
 			}
-			BackupZipInput(tempFile)
+			BackupZipInput.from(tempFile)
 		}
 	}
 

app/src/main/kotlin/org/koitharu/kotatsu/settings/sources/auth/SourceAuthActivity.kt

@@ -82,16 +82,6 @@ class SourceAuthActivity : BaseActivity<ActivityBrowserBinding>(), BrowserCallba
 		viewBinding.webView.loadUrl(url)
 	}
 
-	override fun onSaveInstanceState(outState: Bundle) {
-		super.onSaveInstanceState(outState)
-		viewBinding.webView.saveState(outState)
-	}
-
-	override fun onRestoreInstanceState(savedInstanceState: Bundle) {
-		super.onRestoreInstanceState(savedInstanceState)
-		viewBinding.webView.restoreState(savedInstanceState)
-	}
-
 	override fun onDestroy() {
 		super.onDestroy()
 		viewBinding.webView.destroy()

app/src/main/kotlin/org/koitharu/kotatsu/settings/storage/directories/MangaDirectoriesActivity.kt

@@ -13,13 +13,16 @@ import androidx.core.graphics.Insets
 import androidx.core.view.isVisible
 import androidx.core.view.updateLayoutParams
 import androidx.core.view.updatePadding
+import com.google.android.material.snackbar.Snackbar
 import com.hannesdorfmann.adapterdelegates4.AsyncListDifferDelegationAdapter
 import dagger.hilt.android.AndroidEntryPoint
+import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.exceptions.resolve.SnackbarErrorObserver
 import org.koitharu.kotatsu.core.ui.BaseActivity
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.core.util.ext.observeEvent
+import org.koitharu.kotatsu.core.util.ext.tryLaunch
 import org.koitharu.kotatsu.databinding.ActivityMangaDirectoriesBinding
 import org.koitharu.kotatsu.settings.storage.DirectoryDiffCallback
 import org.koitharu.kotatsu.settings.storage.DirectoryModel
@@ -42,7 +45,11 @@ class MangaDirectoriesActivity : BaseActivity<ActivityMangaDirectoriesBinding>()
 	) {
 		if (it) {
 			viewModel.updateList()
-			pickFileTreeLauncher.launch(null)
+			if (!pickFileTreeLauncher.tryLaunch(null)) {
+				Snackbar.make(
+					viewBinding.recyclerView, R.string.operation_not_supported, Snackbar.LENGTH_SHORT,
+				).show()
+			}
 		}
 	}
 
@@ -68,7 +75,11 @@ class MangaDirectoriesActivity : BaseActivity<ActivityMangaDirectoriesBinding>()
 	}
 
 	override fun onClick(v: View?) {
-		permissionRequestLauncher.launch(Manifest.permission.WRITE_EXTERNAL_STORAGE)
+		if (!permissionRequestLauncher.tryLaunch(Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
+			Snackbar.make(
+				viewBinding.recyclerView, R.string.operation_not_supported, Snackbar.LENGTH_SHORT,
+			).show()
+		}
 	}
 
 	override fun onWindowInsetsChanged(insets: Insets) {

app/src/main/kotlin/org/koitharu/kotatsu/suggestions/ui/SuggestionsViewModel.kt

@@ -64,6 +64,8 @@ class SuggestionsViewModel @Inject constructor(
 	override fun onRetry() = Unit
 
 	fun updateSuggestions() {
-		suggestionsScheduler.startNow()
+		launchJob(Dispatchers.Default) {
+			suggestionsScheduler.startNow()
+		}
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/suggestions/ui/SuggestionsWorker.kt

@@ -1,11 +1,12 @@
 package org.koitharu.kotatsu.suggestions.ui
 
-import android.annotation.SuppressLint
+import android.Manifest
 import android.app.PendingIntent
 import android.content.Context
 import android.content.pm.ServiceInfo
 import android.os.Build
 import androidx.annotation.FloatRange
+import androidx.annotation.RequiresPermission
 import androidx.core.app.NotificationChannelCompat
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
@@ -50,6 +51,7 @@ import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.util.ext.almostEquals
 import org.koitharu.kotatsu.core.util.ext.asArrayList
 import org.koitharu.kotatsu.core.util.ext.awaitUniqueWorkInfoByName
+import org.koitharu.kotatsu.core.util.ext.awaitWorkInfosByTag
 import org.koitharu.kotatsu.core.util.ext.checkNotificationPermission
 import org.koitharu.kotatsu.core.util.ext.flatten
 import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
@@ -189,7 +191,9 @@ class SuggestionsWorker @AssistedInject constructor(
 			.sortedBy { it.relevance }
 			.take(MAX_RESULTS)
 		suggestionRepository.replace(suggestions)
-		if (appSettings.isSuggestionsNotificationAvailable && applicationContext.checkNotificationPermission()) {
+		if (appSettings.isSuggestionsNotificationAvailable
+			&& applicationContext.checkNotificationPermission(MANGA_CHANNEL_ID)
+		) {
 			for (i in 0..3) {
 				try {
 					val manga = suggestions[Random.nextInt(0, suggestions.size / 3)]
@@ -252,7 +256,7 @@ class SuggestionsWorker @AssistedInject constructor(
 		e.printStackTraceDebug()
 	}.getOrDefault(emptyList())
 
-	@SuppressLint("MissingPermission")
+	@RequiresPermission(Manifest.permission.POST_NOTIFICATIONS)
 	private suspend fun showNotification(manga: Manga) {
 		val channel = NotificationChannelCompat.Builder(MANGA_CHANNEL_ID, NotificationManagerCompat.IMPORTANCE_DEFAULT)
 			.setName(applicationContext.getString(R.string.suggestions))
@@ -393,7 +397,10 @@ class SuggestionsWorker @AssistedInject constructor(
 				.any { !it.state.isFinished }
 		}
 
-		fun startNow() {
+		suspend fun startNow() {
+			if (workManager.awaitWorkInfosByTag(TAG_ONESHOT).any { !it.state.isFinished }) {
+				return
+			}
 			val constraints = Constraints.Builder()
 				.setRequiredNetworkType(NetworkType.CONNECTED)
 				.build()
@@ -402,7 +409,7 @@ class SuggestionsWorker @AssistedInject constructor(
 				.addTag(TAG_ONESHOT)
 				.setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
 				.build()
-			workManager.enqueue(request)
+			workManager.enqueue(request).await()
 		}
 
 		private fun createConstraints() = Constraints.Builder()

app/src/main/kotlin/org/koitharu/kotatsu/tracker/data/TrackEntity.kt

@@ -20,11 +20,27 @@ import org.koitharu.kotatsu.core.db.entity.MangaEntity
 class TrackEntity(
 	@PrimaryKey(autoGenerate = false)
 	@ColumnInfo(name = "manga_id") val mangaId: Long,
-	@get:Deprecated(message = "Should not be used", level = DeprecationLevel.WARNING)
-	@ColumnInfo(name = "chapters_total") val totalChapters: Int,
 	@ColumnInfo(name = "last_chapter_id") val lastChapterId: Long,
 	@ColumnInfo(name = "chapters_new") val newChapters: Int,
-	@ColumnInfo(name = "last_check") val lastCheck: Long,
-	@get:Deprecated(message = "Should not be used", level = DeprecationLevel.WARNING)
-	@ColumnInfo(name = "last_notified_id") val lastNotifiedChapterId: Long
-)
+	@ColumnInfo(name = "last_check_time") val lastCheckTime: Long,
+	@ColumnInfo(name = "last_chapter_date") val lastChapterDate: Long,
+	@ColumnInfo(name = "last_result") val lastResult: Int,
+) {
+
+	companion object {
+
+		const val RESULT_NONE = 0
+		const val RESULT_HAS_UPDATE = 1
+		const val RESULT_NO_UPDATE = 2
+		const val RESULT_FAILED = 3
+
+		fun create(mangaId: Long) = TrackEntity(
+			mangaId = mangaId,
+			lastChapterId = 0L,
+			newChapters = 0,
+			lastCheckTime = 0L,
+			lastChapterDate = 0,
+			lastResult = RESULT_NONE,
+		)
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/tracker/data/TrackLogEntity.kt

@@ -13,14 +13,14 @@ import org.koitharu.kotatsu.core.db.entity.MangaEntity
 			entity = MangaEntity::class,
 			parentColumns = ["manga_id"],
 			childColumns = ["manga_id"],
-			onDelete = ForeignKey.CASCADE
-		)
-	]
+			onDelete = ForeignKey.CASCADE,
+		),
+	],
 )
 class TrackLogEntity(
 	@PrimaryKey(autoGenerate = true)
 	@ColumnInfo(name = "id") val id: Long = 0L,
 	@ColumnInfo(name = "manga_id", index = true) val mangaId: Long,
 	@ColumnInfo(name = "chapters") val chapters: String,
-	@ColumnInfo(name = "created_at") val createdAt: Long = System.currentTimeMillis(),
-)
+	@ColumnInfo(name = "created_at") val createdAt: Long,
+)

app/src/main/kotlin/org/koitharu/kotatsu/tracker/data/TrackWithManga.kt

@@ -0,0 +1,14 @@
+package org.koitharu.kotatsu.tracker.data
+
+import androidx.room.Embedded
+import androidx.room.Relation
+import org.koitharu.kotatsu.core.db.entity.MangaEntity
+
+class TrackWithManga(
+	@Embedded val track: TrackEntity,
+	@Relation(
+		parentColumn = "manga_id",
+		entityColumn = "manga_id",
+	)
+	val manga: MangaEntity,
+)

app/src/main/kotlin/org/koitharu/kotatsu/tracker/data/TracksDao.kt

@@ -14,6 +14,13 @@ abstract class TracksDao {
 	@Query("SELECT * FROM tracks")
 	abstract suspend fun findAll(): List<TrackEntity>
 
+	@Transaction
+	@Query("SELECT * FROM tracks ORDER BY last_check_time ASC LIMIT :limit OFFSET :offset")
+	abstract suspend fun findAll(offset: Int, limit: Int): List<TrackWithManga>
+
+	@Query("SELECT manga_id FROM tracks")
+	abstract suspend fun findAllIds(): LongArray
+
 	@Query("SELECT * FROM tracks WHERE manga_id IN (:ids)")
 	abstract suspend fun findAll(ids: Collection<Long>): List<TrackEntity>
 

app/src/main/kotlin/org/koitharu/kotatsu/tracker/domain/Tracker.kt

@@ -1,7 +1,6 @@
 package org.koitharu.kotatsu.tracker.domain
 
 import androidx.annotation.VisibleForTesting
-import androidx.collection.MutableLongSet
 import coil.request.CachePolicy
 import org.koitharu.kotatsu.core.model.getPreferredBranch
 import org.koitharu.kotatsu.core.parser.MangaRepository
@@ -10,6 +9,7 @@ import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.util.CompositeMutex2
 import org.koitharu.kotatsu.history.data.HistoryRepository
 import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
 import org.koitharu.kotatsu.tracker.domain.model.MangaTracking
 import org.koitharu.kotatsu.tracker.domain.model.MangaUpdates
 import org.koitharu.kotatsu.tracker.work.TrackerNotificationChannels
@@ -26,55 +26,19 @@ class Tracker @Inject constructor(
 	private val mangaRepositoryFactory: MangaRepository.Factory,
 ) {
 
-	suspend fun getAllTracks(): List<TrackingItem> {
-		val sources = settings.trackSources
-		if (sources.isEmpty()) {
-			return emptyList()
-		}
-		val knownManga = MutableLongSet()
-		val result = ArrayList<TrackingItem>()
-		// Favourites
-		if (AppSettings.TRACK_FAVOURITES in sources) {
-			val favourites = repository.getAllFavouritesManga()
-			channels.updateChannels(favourites.keys)
-			for ((category, mangaList) in favourites) {
-				if (!category.isTrackingEnabled || mangaList.isEmpty()) {
-					continue
-				}
-				val categoryTracks = repository.getTracks(mangaList)
-				val channelId = if (channels.isFavouriteNotificationsEnabled(category)) {
-					channels.getFavouritesChannelId(category.id)
+	suspend fun getTracks(limit: Int): List<TrackingItem> {
+		repository.updateTracks()
+		return repository.getTracks(0, limit).map {
+			val categoryId = repository.getCategoryId(it.manga.id)
+			TrackingItem(
+				tracking = it,
+				channelId = if (categoryId == 0L) {
+					channels.getHistoryChannelId()
 				} else {
-					null
-				}
-				for (track in categoryTracks) {
-					if (knownManga.add(track.manga.id)) {
-						result.add(TrackingItem(track, channelId))
-					}
-				}
-			}
+					channels.getFavouritesChannelId(categoryId)
+				},
+			)
 		}
-		// History
-		if (AppSettings.TRACK_HISTORY in sources) {
-			val history = repository.getAllHistoryManga()
-			val historyTracks = repository.getTracks(history)
-			val channelId = if (channels.isHistoryNotificationsEnabled()) {
-				channels.getHistoryChannelId()
-			} else {
-				null
-			}
-			for (track in historyTracks) {
-				if (knownManga.add(track.manga.id)) {
-					result.add(TrackingItem(track, channelId))
-				}
-			}
-		}
-		result.trimToSize()
-		return result
-	}
-
-	suspend fun getTracks(ids: Set<Long>): List<TrackingItem> {
-		return getAllTracks().filterTo(ArrayList(ids.size)) { x -> x.tracking.manga.id in ids }
 	}
 
 	suspend fun gc() {
@@ -84,11 +48,18 @@ class Tracker @Inject constructor(
 	suspend fun fetchUpdates(
 		track: MangaTracking,
 		commit: Boolean
-	): MangaUpdates.Success = withMangaLock(track.manga.id) {
-		val repo = mangaRepositoryFactory.create(track.manga.source)
-		require(repo is RemoteMangaRepository) { "Repository ${repo.javaClass.simpleName} is not supported" }
-		val manga = repo.getDetails(track.manga, CachePolicy.WRITE_ONLY)
-		val updates = compare(track, manga, getBranch(manga))
+	): MangaUpdates = withMangaLock(track.manga.id) {
+		val updates = runCatchingCancellable {
+			val repo = mangaRepositoryFactory.create(track.manga.source)
+			require(repo is RemoteMangaRepository) { "Repository ${repo.javaClass.simpleName} is not supported" }
+			val manga = repo.getDetails(track.manga, CachePolicy.WRITE_ONLY)
+			compare(track, manga, getBranch(manga))
+		}.getOrElse { error ->
+			MangaUpdates.Failure(
+				manga = track.manga,
+				error = error,
+			)
+		}
 		if (commit) {
 			repository.saveUpdates(updates)
 		}

app/src/main/kotlin/org/koitharu/kotatsu/tracker/domain/TrackingRepository.kt

@@ -1,7 +1,6 @@
 package org.koitharu.kotatsu.tracker.domain
 
 import androidx.annotation.VisibleForTesting
-import androidx.collection.MutableLongSet
 import androidx.room.withTransaction
 import dagger.Reusable
 import kotlinx.coroutines.flow.Flow
@@ -14,29 +13,34 @@ import org.koitharu.kotatsu.core.db.MangaDatabase
 import org.koitharu.kotatsu.core.db.entity.MangaEntity
 import org.koitharu.kotatsu.core.db.entity.toManga
 import org.koitharu.kotatsu.core.model.FavouriteCategory
-import org.koitharu.kotatsu.core.model.isLocal
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.core.util.ext.ifZero
 import org.koitharu.kotatsu.core.util.ext.mapItems
+import org.koitharu.kotatsu.core.util.ext.toInstantOrNull
 import org.koitharu.kotatsu.favourites.data.toFavouriteCategory
 import org.koitharu.kotatsu.local.data.LocalMangaRepository
 import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.parsers.util.mapToSet
 import org.koitharu.kotatsu.tracker.data.TrackEntity
 import org.koitharu.kotatsu.tracker.data.TrackLogEntity
 import org.koitharu.kotatsu.tracker.data.toTrackingLogItem
 import org.koitharu.kotatsu.tracker.domain.model.MangaTracking
 import org.koitharu.kotatsu.tracker.domain.model.MangaUpdates
 import org.koitharu.kotatsu.tracker.domain.model.TrackingLogItem
-import java.time.Instant
 import java.util.concurrent.atomic.AtomicBoolean
 import javax.inject.Inject
 import javax.inject.Provider
 
 private const val NO_ID = 0L
+
+@Deprecated("Use buckets")
 private const val MAX_QUERY_IDS = 100
+private const val MAX_BUCKET_SIZE = 20
+private const val MAX_LOG_SIZE = 120
 
 @Reusable
 class TrackingRepository @Inject constructor(
 	private val db: MangaDatabase,
+	private val settings: AppSettings,
 	private val localMangaRepositoryProvider: Provider<LocalMangaRepository>,
 ) {
 
@@ -65,35 +69,18 @@ class TrackingRepository @Inject constructor(
 			.onStart { gcIfNotCalled() }
 	}
 
-	suspend fun getTracks(mangaList: Collection<Manga>): List<MangaTracking> {
-		val ids = mangaList.mapToSet { it.id }
-		val dao = db.getTracksDao()
-		val tracks = if (ids.size <= MAX_QUERY_IDS) {
-			dao.findAll(ids)
-		} else {
-			// TODO split tracks in the worker
-			ids.windowed(MAX_QUERY_IDS, MAX_QUERY_IDS, true)
-				.flatMap { dao.findAll(it) }
-		}.groupBy { it.mangaId }
-		val idSet = MutableLongSet(mangaList.size)
-		val result = ArrayList<MangaTracking>(mangaList.size)
-		for (item in mangaList) {
-			val manga = if (item.isLocal) {
-				localMangaRepositoryProvider.get().getRemoteManga(item) ?: continue
-			} else {
-				item
-			}
-			if (!idSet.add(manga.id)) {
-				continue
-			}
-			val track = tracks[manga.id]?.lastOrNull()
-			result += MangaTracking(
-				manga = manga,
-				lastChapterId = track?.lastChapterId ?: NO_ID,
-				lastCheck = track?.lastCheck?.takeUnless { it == 0L }?.let(Instant::ofEpochMilli),
+	suspend fun getCategoryId(mangaId: Long): Long {
+		return db.getFavouritesDao().findCategoriesIdsWithTrack(mangaId).firstOrNull() ?: NO_ID
+	}
+
+	suspend fun getTracks(offset: Int, limit: Int): List<MangaTracking> {
+		return db.getTracksDao().findAll(offset, limit).map {
+			MangaTracking(
+				manga = it.manga.toManga(emptySet()),
+				lastChapterId = it.track.lastChapterId,
+				lastCheck = it.track.lastCheckTime.toInstantOrNull(),
 			)
 		}
-		return result
 	}
 
 	@VisibleForTesting
@@ -102,7 +89,7 @@ class TrackingRepository @Inject constructor(
 		return MangaTracking(
 			manga = manga,
 			lastChapterId = track?.lastChapterId ?: NO_ID,
-			lastCheck = track?.lastCheck?.takeUnless { it == 0L }?.let(Instant::ofEpochMilli),
+			lastCheck = track?.lastCheckTime?.toInstantOrNull(),
 		)
 	}
 
@@ -131,16 +118,19 @@ class TrackingRepository @Inject constructor(
 
 	suspend fun clearCounters() = db.getTracksDao().clearCounters()
 
-	suspend fun gc() {
+	suspend fun gc() = db.withTransaction {
 		db.getTracksDao().gc()
-		db.getTrackLogsDao().gc()
+		db.getTrackLogsDao().run {
+			gc()
+			trim(MAX_LOG_SIZE)
+		}
 	}
 
-	suspend fun saveUpdates(updates: MangaUpdates.Success) {
+	suspend fun saveUpdates(updates: MangaUpdates) {
 		db.withTransaction {
 			val track = getOrCreateTrack(updates.manga.id).mergeWith(updates)
 			db.getTracksDao().upsert(track)
-			if (updates.isValid && updates.newChapters.isNotEmpty()) {
+			if (updates is MangaUpdates.Success && updates.isValid && updates.newChapters.isNotEmpty()) {
 				updatePercent(updates)
 				val logEntity = TrackLogEntity(
 					mangaId = updates.manga.id,
@@ -172,7 +162,6 @@ class TrackingRepository @Inject constructor(
 		val lastChapterId = chapters.lastOrNull()?.id ?: NO_ID
 		val entity = TrackEntity(
 			mangaId = manga.id,
-			totalChapters = chapters.size,
 			lastChapterId = lastChapterId,
 			newChapters = when {
 				track.newChapters == 0 -> 0
@@ -180,8 +169,9 @@ class TrackingRepository @Inject constructor(
 				chapterIndex >= lastNewChapterIndex -> chapters.lastIndex - chapterIndex
 				else -> track.newChapters
 			},
-			lastCheck = System.currentTimeMillis(),
-			lastNotifiedChapterId = lastChapterId,
+			lastCheckTime = System.currentTimeMillis(),
+			lastChapterDate = maxOf(track.lastChapterDate, chapters.lastOrNull()?.uploadDate ?: 0L),
+			lastResult = track.lastResult,
 		)
 		db.getTracksDao().upsert(entity)
 	}
@@ -202,19 +192,38 @@ class TrackingRepository @Inject constructor(
 		}
 	}
 
-	suspend fun getAllHistoryManga(): List<Manga> {
-		return db.getHistoryDao().findAllManga().toMangaList()
+	suspend fun updateTracks() = db.withTransaction {
+		val dao = db.getTracksDao()
+		dao.gc()
+		val ids = dao.findAllIds().toMutableSet()
+		val size = ids.size
+		// history
+		if (AppSettings.TRACK_HISTORY in settings.trackSources) {
+			val historyIds = db.getHistoryDao().findAllIds()
+			for (mangaId in historyIds) {
+				if (!ids.remove(mangaId)) {
+					dao.upsert(TrackEntity.create(mangaId))
+				}
+			}
+		}
+		// favorites
+		if (AppSettings.TRACK_FAVOURITES in settings.trackSources) {
+			val favoritesIds = db.getFavouritesDao().findIdsWithTrack()
+			for (mangaId in favoritesIds) {
+				if (!ids.remove(mangaId)) {
+					dao.upsert(TrackEntity.create(mangaId))
+				}
+			}
+		}
+		// remove unused
+		for (mangaId in ids) {
+			dao.delete(mangaId)
+		}
+		size - ids.size
 	}
 
 	private suspend fun getOrCreateTrack(mangaId: Long): TrackEntity {
-		return db.getTracksDao().find(mangaId) ?: TrackEntity(
-			mangaId = mangaId,
-			totalChapters = 0,
-			lastChapterId = 0L,
-			newChapters = 0,
-			lastCheck = 0L,
-			lastNotifiedChapterId = 0L,
-		)
+		return db.getTracksDao().find(mangaId) ?: TrackEntity.create(mangaId)
 	}
 
 	private suspend fun updatePercent(updates: MangaUpdates.Success) {
@@ -232,16 +241,27 @@ class TrackingRepository @Inject constructor(
 		db.getHistoryDao().update(history.copy(percent = newPercent))
 	}
 
-	private fun TrackEntity.mergeWith(updates: MangaUpdates.Success): TrackEntity {
+	private fun TrackEntity.mergeWith(updates: MangaUpdates): TrackEntity {
 		val chapters = updates.manga.chapters.orEmpty()
-		return TrackEntity(
-			mangaId = mangaId,
-			totalChapters = chapters.size,
-			lastChapterId = chapters.lastOrNull()?.id ?: NO_ID,
-			newChapters = if (updates.isValid) newChapters + updates.newChapters.size else 0,
-			lastCheck = System.currentTimeMillis(),
-			lastNotifiedChapterId = NO_ID,
-		)
+		return when (updates) {
+			is MangaUpdates.Failure -> TrackEntity(
+				mangaId = mangaId,
+				lastChapterId = lastChapterId,
+				newChapters = newChapters,
+				lastCheckTime = System.currentTimeMillis(),
+				lastChapterDate = lastChapterDate,
+				lastResult = TrackEntity.RESULT_FAILED,
+			)
+
+			is MangaUpdates.Success -> TrackEntity(
+				mangaId = mangaId,
+				lastChapterId = chapters.lastOrNull()?.id ?: NO_ID,
+				newChapters = if (updates.isValid) newChapters + updates.newChapters.size else 0,
+				lastCheckTime = System.currentTimeMillis(),
+				lastChapterDate = updates.lastChapterDate().ifZero { lastChapterDate },
+				lastResult = if (updates.isNotEmpty()) TrackEntity.RESULT_HAS_UPDATE else TrackEntity.RESULT_NO_UPDATE,
+			)
+		}
 	}
 
 	private suspend fun gcIfNotCalled() {

app/src/main/kotlin/org/koitharu/kotatsu/tracker/domain/model/MangaUpdates.kt

@@ -1,6 +1,7 @@
 package org.koitharu.kotatsu.tracker.domain.model
 
 import org.koitharu.kotatsu.core.exceptions.TooManyRequestExceptions
+import org.koitharu.kotatsu.core.util.ext.ifZero
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaChapter
 
@@ -16,6 +17,15 @@ sealed interface MangaUpdates {
 	) : MangaUpdates {
 
 		fun isNotEmpty() = newChapters.isNotEmpty()
+
+		fun lastChapterDate(): Long {
+			val lastChapter = newChapters.lastOrNull()
+			return if (lastChapter == null) {
+				manga.chapters?.lastOrNull()?.uploadDate ?: 0L
+			} else {
+				lastChapter.uploadDate.ifZero { System.currentTimeMillis() }
+			}
+		}
 	}
 
 	data class Failure(

app/src/main/kotlin/org/koitharu/kotatsu/tracker/ui/feed/FeedFragment.kt

@@ -15,6 +15,7 @@ import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.exceptions.resolve.SnackbarErrorObserver
 import org.koitharu.kotatsu.core.ui.BaseFragment
 import org.koitharu.kotatsu.core.ui.list.PaginationScrollListener
+import org.koitharu.kotatsu.core.ui.widgets.TipView
 import org.koitharu.kotatsu.core.util.ext.addMenuProvider
 import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.core.util.ext.observeEvent
@@ -100,6 +101,10 @@ class FeedFragment :
 
 	override fun onEmptyActionClick() = Unit
 
+	override fun onPrimaryButtonClick(tipView: TipView) = Unit
+
+	override fun onSecondaryButtonClick(tipView: TipView) = Unit
+
 	override fun onListHeaderClick(item: ListHeader, view: View) {
 		val context = view.context
 		context.startActivity(UpdatesActivity.newIntent(context))

app/src/main/kotlin/org/koitharu/kotatsu/tracker/ui/feed/adapter/FeedItemAD.kt

@@ -1,10 +1,12 @@
 package org.koitharu.kotatsu.tracker.ui.feed.adapter
 
+import androidx.core.content.ContextCompat
 import androidx.lifecycle.LifecycleOwner
 import coil.ImageLoader
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
+import org.koitharu.kotatsu.core.util.ext.drawableStart
 import org.koitharu.kotatsu.core.util.ext.enqueueWith
 import org.koitharu.kotatsu.core.util.ext.newImageRequest
 import org.koitharu.kotatsu.core.util.ext.source
@@ -20,14 +22,13 @@ fun feedItemAD(
 ) = adapterDelegateViewBinding<FeedItem, ListModel, ItemFeedBinding>(
 	{ inflater, parent -> ItemFeedBinding.inflate(inflater, parent, false) },
 ) {
+	val indicatorNew = ContextCompat.getDrawable(context, R.drawable.ic_new)
+
 	itemView.setOnClickListener {
 		clickListener.onItemClick(item.manga, it)
 	}
 
 	bind {
-		val alpha = if (item.isNew) 1f else 0.5f
-		binding.textViewTitle.alpha = alpha
-		binding.textViewSummary.alpha = alpha
 		binding.imageViewCover.newImageRequest(lifecycleOwner, item.imageUrl)?.run {
 			placeholder(R.drawable.ic_placeholder)
 			fallback(R.drawable.ic_placeholder)
@@ -42,5 +43,10 @@ fun feedItemAD(
 			item.count,
 			item.count,
 		)
+		binding.textViewSummary.drawableStart = if (item.isNew) {
+			indicatorNew
+		} else {
+			null
+		}
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/tracker/work/TrackWorker.kt

@@ -11,7 +11,6 @@ import androidx.core.app.NotificationCompat.VISIBILITY_SECRET
 import androidx.core.app.NotificationManagerCompat
 import androidx.core.app.PendingIntentCompat
 import androidx.core.content.ContextCompat
-import androidx.core.content.edit
 import androidx.hilt.work.HiltWorker
 import androidx.work.BackoffPolicy
 import androidx.work.Constraints
@@ -34,14 +33,12 @@ import dagger.Reusable
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.channelFlow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.toList
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.runInterruptible
 import kotlinx.coroutines.sync.Semaphore
 import kotlinx.coroutines.sync.withPermit
 import kotlinx.coroutines.withContext
@@ -59,7 +56,6 @@ import org.koitharu.kotatsu.core.util.ext.trySetForeground
 import org.koitharu.kotatsu.details.ui.DetailsActivity
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaChapter
-import org.koitharu.kotatsu.parsers.util.mapToSet
 import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
 import org.koitharu.kotatsu.settings.SettingsActivity
 import org.koitharu.kotatsu.settings.work.PeriodicWorkScheduler
@@ -86,7 +82,7 @@ class TrackWorker @AssistedInject constructor(
 		trySetForeground()
 		logger.log("doWork(): attempt $runAttemptCount")
 		return try {
-			doWorkImpl()
+			doWorkImpl(isFullRun = TAG_ONESHOT in tags)
 		} catch (e: CancellationException) {
 			throw e
 		} catch (e: Throwable) {
@@ -100,49 +96,18 @@ class TrackWorker @AssistedInject constructor(
 		}
 	}
 
-	private suspend fun doWorkImpl(): Result {
+	private suspend fun doWorkImpl(isFullRun: Boolean): Result {
 		if (!settings.isTrackerEnabled) {
 			return Result.success(workDataOf(0, 0))
 		}
-		val retryIds = getRetryIds()
-		val tracks = if (retryIds.isNotEmpty()) {
-			tracker.getTracks(retryIds)
-		} else {
-			tracker.getAllTracks()
-		}
+		val tracks = tracker.getTracks(if (isFullRun) Int.MAX_VALUE else BATCH_SIZE)
 		logger.log("Total ${tracks.size} tracks")
 		if (tracks.isEmpty()) {
 			return Result.success(workDataOf(0, 0))
 		}
 
-		val results = checkUpdatesAsync(tracks)
-		tracker.gc()
-
-		var success = 0
-		var failed = 0
-		val retry = HashSet<Long>()
-		results.forEach { x ->
-			when (x) {
-				is MangaUpdates.Success -> success++
-				is MangaUpdates.Failure -> {
-					failed++
-					if (x.shouldRetry()) {
-						retry += x.manga.id
-					}
-				}
-			}
-		}
-		if (runAttemptCount > MAX_ATTEMPTS) {
-			retry.clear()
-		}
-		setRetryIds(retry)
-		logger.log("Result: success: $success, failed: $failed, retry: ${retry.size}")
-		val resultData = workDataOf(success, failed)
-		return when {
-			retry.isNotEmpty() -> Result.retry()
-			success == 0 && failed != 0 -> Result.failure(resultData)
-			else -> Result.success(resultData)
-		}
+		checkUpdatesAsync(tracks)
+		return Result.success()
 	}
 
 	private suspend fun checkUpdatesAsync(tracks: List<TrackingItem>): List<MangaUpdates> {
@@ -153,10 +118,13 @@ class TrackWorker @AssistedInject constructor(
 					semaphore.withPermit {
 						send(
 							runCatchingCancellable {
-								tracker.fetchUpdates(track, commit = true)
-									.copy(channelId = channelId)
-							}.onFailure { e ->
-								logger.log("checkUpdatesAsync", e)
+								tracker.fetchUpdates(track, commit = true).let {
+									if (it is MangaUpdates.Success) {
+										it.copy(channelId = channelId)
+									} else {
+										it
+									}
+								}
 							}.getOrElse { error ->
 								MangaUpdates.Failure(
 									manga = track.manga,
@@ -168,12 +136,13 @@ class TrackWorker @AssistedInject constructor(
 				}
 			}
 		}.onEachIndexed { index, it ->
-			if (applicationContext.checkNotificationPermission()) {
+			if (applicationContext.checkNotificationPermission(WORKER_CHANNEL_ID)) {
 				notificationManager.notify(WORKER_NOTIFICATION_ID, createWorkerNotification(tracks.size, index + 1))
 			}
 			when (it) {
 				is MangaUpdates.Failure -> {
 					val e = it.error
+					logger.log("checkUpdatesAsync", e)
 					if (e is CloudFlareProtectedException) {
 						CaptchaNotifier(applicationContext).notify(e)
 					}
@@ -197,7 +166,7 @@ class TrackWorker @AssistedInject constructor(
 		channelId: String?,
 		newChapters: List<MangaChapter>,
 	) {
-		if (newChapters.isEmpty() || channelId == null || !applicationContext.checkNotificationPermission()) {
+		if (newChapters.isEmpty() || channelId == null || !applicationContext.checkNotificationPermission(channelId)) {
 			return
 		}
 		val id = manga.url.hashCode()
@@ -323,22 +292,6 @@ class TrackWorker @AssistedInject constructor(
 		)
 	}.build()
 
-	private suspend fun setRetryIds(ids: Set<Long>) = runInterruptible(Dispatchers.IO) {
-		val prefs = applicationContext.getSharedPreferences(TAG, Context.MODE_PRIVATE)
-		prefs.edit(commit = true) {
-			if (ids.isEmpty()) {
-				remove(KEY_RETRY_IDS)
-			} else {
-				putStringSet(KEY_RETRY_IDS, ids.mapToSet { it.toString() })
-			}
-		}
-	}
-
-	private fun getRetryIds(): Set<Long> {
-		val prefs = applicationContext.getSharedPreferences(TAG, Context.MODE_PRIVATE)
-		return prefs.getStringSet(KEY_RETRY_IDS, null)?.mapToSet { it.toLong() }.orEmpty()
-	}
-
 	private fun workDataOf(success: Int, failed: Int): Data {
 		return Data.Builder()
 			.putInt(DATA_KEY_SUCCESS, success)
@@ -410,6 +363,6 @@ class TrackWorker @AssistedInject constructor(
 		const val MAX_ATTEMPTS = 3
 		const val DATA_KEY_SUCCESS = "success"
 		const val DATA_KEY_FAILED = "failed"
-		const val KEY_RETRY_IDS = "retry"
+		const val BATCH_SIZE = 20
 	}
 }

app/src/main/res/color-v23/colored_button.xml

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <selector xmlns:android="http://schemas.android.com/apk/res/android">
-	<item android:color="?attr/m3ColorExploreButton" />
+	<item android:color="?attr/colorSurfaceContainerHigh" />
 </selector>

app/src/main/res/color/colored_button.xml

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <selector xmlns:android="http://schemas.android.com/apk/res/android">
-	<item android:color="@android:color/white" />
+	<item android:color="@color/kotatsu_surfaceContainerHigh" />
 </selector>