Merge branch 'devel' into feature/mal

# Conflicts:
#	app/src/main/java/org/koitharu/kotatsu/core/prefs/AppSettings.kt
#	app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt
#	app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/model/ScrobblerService.kt
#	app/src/main/java/org/koitharu/kotatsu/settings/HistorySettingsFragment.kt
#	app/src/main/res/xml/pref_history.xml

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/gradle.xml

@@ -7,7 +7,7 @@
         <option name="testRunner" value="GRADLE" />
         <option name="distributionType" value="DEFAULT_WRAPPED" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleJvm" value="Embedded JDK" />
+        <option name="gradleJvm" value="jbr-17" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />

.idea/kotlinc.xml

@@ -4,6 +4,6 @@
     <option name="jvmTarget" value="1.8" />
   </component>
   <component name="KotlinJpsPluginSettings">
-    <option name="version" value="1.7.20" />
+    <option name="version" value="1.8.0" />
   </component>
 </project>

app/build.gradle

@@ -7,16 +7,16 @@ plugins {
 }
 
 android {
-	compileSdkVersion 33
+	compileSdk = 33
-	buildToolsVersion '33.0.0'
+	buildToolsVersion = '33.0.1'
-	namespace 'org.koitharu.kotatsu'
+	namespace = 'org.koitharu.kotatsu'
 
 	defaultConfig {
 		applicationId 'org.koitharu.kotatsu'
 		minSdkVersion 21
 		targetSdkVersion 33
-		versionCode 508
+		versionCode 512
-		versionName '4.1.1'
+		versionName '4.3.1'
 		generatedDensities = []
 		testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 
@@ -29,6 +29,8 @@ android {
 		// define this values in your local.properties file
 		buildConfigField 'String', 'SHIKIMORI_CLIENT_ID', "\"${localProperty('shikimori.clientId')}\""
 		buildConfigField 'String', 'SHIKIMORI_CLIENT_SECRET', "\"${localProperty('shikimori.clientSecret')}\""
+		buildConfigField 'String', 'ANILIST_CLIENT_ID', "\"${localProperty('anilist.clientId')}\""
+		buildConfigField 'String', 'ANILIST_CLIENT_SECRET', "\"${localProperty('anilist.clientSecret')}\""
 		resValue "string", "acra_login", "${localProperty('acra.login')}"
 		resValue "string", "acra_password", "${localProperty('acra.password')}"
 	}
@@ -56,6 +58,7 @@ android {
 	kotlinOptions {
 		jvmTarget = JavaVersion.VERSION_1_8.toString()
 		freeCompilerArgs += [
+			'-opt-in=kotlin.ExperimentalStdlibApi',
 			'-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi',
 			'-opt-in=kotlinx.coroutines.FlowPreview',
 			'-opt-in=kotlin.contracts.ExperimentalContracts',
@@ -83,12 +86,14 @@ afterEvaluate {
 	}
 }
 dependencies {
-	implementation('com.github.KotatsuApp:kotatsu-parsers:c4acb9725f') {
+	implementation('com.github.KotatsuApp:kotatsu-parsers:e5a6b82853') {
 		exclude group: 'org.json', module: 'json'
 	}
 
+	implementation 'org.jetbrains.kotlin:kotlin-stdlib:1.8.0'
 	implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
 
+	implementation "androidx.appcompat:appcompat:1.6.0"
 	implementation 'androidx.core:core-ktx:1.9.0'
 	implementation 'androidx.activity:activity-ktx:1.6.1'
 	implementation 'androidx.fragment:fragment-ktx:1.5.5'
@@ -103,17 +108,17 @@ dependencies {
 	implementation 'androidx.preference:preference-ktx:1.2.0'
 	implementation 'androidx.work:work-runtime-ktx:2.7.1'
 	implementation 'androidx.biometric:biometric-ktx:1.2.0-alpha05'
-	implementation 'com.google.android.material:material:1.7.0'
+	implementation 'com.google.android.material:material:1.8.0'
 	//noinspection LifecycleAnnotationProcessorWithJava8
 	kapt 'androidx.lifecycle:lifecycle-compiler:2.5.1'
 
-	implementation 'androidx.room:room-runtime:2.4.3'
+	implementation 'androidx.room:room-runtime:2.5.0'
-	implementation 'androidx.room:room-ktx:2.4.3'
+	implementation 'androidx.room:room-ktx:2.5.0'
-	kapt 'androidx.room:room-compiler:2.4.3'
+	kapt 'androidx.room:room-compiler:2.5.0'
 
 	implementation 'com.squareup.okhttp3:okhttp:4.10.0'
 	implementation 'com.squareup.okhttp3:okhttp-dnsoverhttps:4.9.3'
-	implementation 'com.squareup.okio:okio:3.2.0'
+	implementation 'com.squareup.okio:okio:3.3.0'
 
 	implementation 'com.hannesdorfmann:adapterdelegates4-kotlin-dsl:4.3.2'
 	implementation 'com.hannesdorfmann:adapterdelegates4-kotlin-dsl-viewbinding:4.3.2'
@@ -127,6 +132,7 @@ dependencies {
 	implementation 'io.coil-kt:coil-svg:2.2.2'
 	implementation 'com.github.KotatsuApp:subsampling-scale-image-view:1b19231b2f'
 	implementation 'com.github.solkin:disk-lru-cache:1.4'
+	implementation 'io.noties.markwon:core:4.6.2'
 
 	implementation 'ch.acra:acra-http:5.9.7'
 	implementation 'ch.acra:acra-dialog:5.9.7'
@@ -137,14 +143,14 @@ dependencies {
 	testImplementation 'org.json:json:20220924'
 	testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.4'
 
-	androidTestImplementation 'androidx.test:runner:1.5.1'
+	androidTestImplementation 'androidx.test:runner:1.5.2'
 	androidTestImplementation 'androidx.test:rules:1.5.0'
 	androidTestImplementation 'androidx.test:core-ktx:1.5.0'
-	androidTestImplementation 'androidx.test.ext:junit-ktx:1.1.4'
+	androidTestImplementation 'androidx.test.ext:junit-ktx:1.1.5'
 
 	androidTestImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.4'
 
-	androidTestImplementation 'androidx.room:room-testing:2.4.3'
+	androidTestImplementation 'androidx.room:room-testing:2.5.0'
 	androidTestImplementation 'com.squareup.moshi:moshi-kotlin:1.14.0'
 
 	androidTestImplementation 'com.google.dagger:hilt-android-testing:2.44.2'

app/proguard-rules.pro

@@ -14,3 +14,4 @@
 
 -keep class org.koitharu.kotatsu.core.exceptions.* { *; }
 -keep class org.koitharu.kotatsu.settings.NotificationSettingsLegacyFragment
+-keep class org.koitharu.kotatsu.core.prefs.ScreenshotsPolicy { *; }

app/src/debug/java/org/koitharu/kotatsu/core/network/CurlLoggingInterceptor.kt

@@ -0,0 +1,56 @@
+package org.koitharu.kotatsu.core.network
+
+import android.util.Log
+import okhttp3.Interceptor
+import okhttp3.Response
+import okio.Buffer
+import org.koitharu.kotatsu.core.network.CommonHeaders.ACCEPT_ENCODING
+
+class CurlLoggingInterceptor(
+	private val curlOptions: String? = null
+) : Interceptor {
+
+	override fun intercept(chain: Interceptor.Chain): Response {
+		val request = chain.request()
+		var isCompressed = false
+
+		val curlCmd = StringBuilder()
+		curlCmd.append("curl")
+		if (curlOptions != null) {
+			curlCmd.append(' ').append(curlOptions)
+		}
+		curlCmd.append(" -X ").append(request.method)
+
+		for ((name, value) in request.headers) {
+			if (name.equals(ACCEPT_ENCODING, ignoreCase = true) && value.equals("gzip", ignoreCase = true)) {
+				isCompressed = true
+			}
+			curlCmd.append(" -H \"").append(name).append(": ").append(value.escape()).append('\"')
+		}
+
+		val body = request.body
+		if (body != null) {
+			val buffer = Buffer()
+			body.writeTo(buffer)
+			val charset = body.contentType()?.charset() ?: Charsets.UTF_8
+			curlCmd.append(" --data-raw '")
+				.append(buffer.readString(charset).replace("\n", "\\n"))
+				.append("'")
+		}
+		if (isCompressed) {
+			curlCmd.append(" --compressed")
+		}
+		curlCmd.append(" \"").append(request.url).append('"')
+
+		log("---cURL (" + request.url + ")")
+		log(curlCmd.toString())
+
+		return chain.proceed(request)
+	}
+
+	private fun String.escape() = replace("\"", "\\\"")
+
+	private fun log(msg: String) {
+		Log.d("CURL", msg)
+	}
+}

app/src/main/AndroidManifest.xml

@@ -188,6 +188,9 @@
 				android:name="android.content.SyncAdapter"
 				android:resource="@xml/sync_history" />
 		</service>
+		<service
+			android:name="org.koitharu.kotatsu.details.service.MangaPrefetchService"
+			android:exported="false" />
 
 		<provider
 			android:name="org.koitharu.kotatsu.search.ui.MangaSuggestionsProvider"
@@ -250,7 +253,7 @@
 			android:value="true" />
 		<meta-data
 			android:name="com.samsung.android.icon_container.has_icon_container"
-			android:value="@bool/com_samsung_android_icon_container_has_icon_container"/>
+			android:value="@bool/com_samsung_android_icon_container_has_icon_container" />
 
 	</application>
 

app/src/main/java/org/koitharu/kotatsu/KotatsuApp.kt

@@ -50,6 +50,7 @@ class KotatsuApp : Application(), Configuration.Provider {
 			enableStrictMode()
 		}
 		AppCompatDelegate.setDefaultNightMode(settings.theme)
+		AppCompatDelegate.setApplicationLocales(settings.appLocales)
 		setupActivityLifecycleCallbacks()
 		processLifecycleScope.launch(Dispatchers.Default) {
 			setupDatabaseObservers()

app/src/main/java/org/koitharu/kotatsu/base/ui/util/ShrinkOnScrollBehavior.kt

@@ -8,10 +8,12 @@ import androidx.coordinatorlayout.widget.CoordinatorLayout.Behavior
 import androidx.core.view.ViewCompat
 import com.google.android.material.floatingactionbutton.ExtendedFloatingActionButton
 
-class ShrinkOnScrollBehavior : Behavior<ExtendedFloatingActionButton> {
+open class ShrinkOnScrollBehavior : Behavior<ExtendedFloatingActionButton> {
 
-	@Suppress("unused") constructor() : super()
+	@Suppress("unused")
-	@Suppress("unused") constructor(context: Context?, attrs: AttributeSet?) : super(context, attrs)
+	constructor() : super()
+	@Suppress("unused")
+	constructor(context: Context?, attrs: AttributeSet?) : super(context, attrs)
 
 	override fun onStartNestedScroll(
 		coordinatorLayout: CoordinatorLayout,
@@ -45,4 +47,4 @@ class ShrinkOnScrollBehavior : Behavior<ExtendedFloatingActionButton> {
 			}
 		}
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/core/AppModule.kt

@@ -24,6 +24,9 @@ import okhttp3.CookieJar
 import okhttp3.OkHttpClient
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.base.ui.util.ActivityRecreationHandle
+import org.koitharu.kotatsu.core.cache.ContentCache
+import org.koitharu.kotatsu.core.cache.MemoryContentCache
+import org.koitharu.kotatsu.core.cache.StubContentCache
 import org.koitharu.kotatsu.core.db.MangaDatabase
 import org.koitharu.kotatsu.core.network.*
 import org.koitharu.kotatsu.core.network.cookies.AndroidCookieJar
@@ -44,6 +47,7 @@ import org.koitharu.kotatsu.search.ui.MangaSuggestionsProvider
 import org.koitharu.kotatsu.settings.backup.BackupObserver
 import org.koitharu.kotatsu.sync.domain.SyncController
 import org.koitharu.kotatsu.utils.IncognitoModeIndicator
+import org.koitharu.kotatsu.utils.ext.activityManager
 import org.koitharu.kotatsu.utils.ext.connectivityManager
 import org.koitharu.kotatsu.utils.ext.isLowRamDevice
 import org.koitharu.kotatsu.utils.image.CoilImageGetter
@@ -95,6 +99,9 @@ interface AppModule {
 				addInterceptor(GZipInterceptor())
 				addInterceptor(UserAgentInterceptor())
 				addInterceptor(CloudFlareInterceptor())
+				if (BuildConfig.DEBUG) {
+					addInterceptor(CurlLoggingInterceptor())
+				}
 			}.build()
 		}
 
@@ -182,5 +189,17 @@ interface AppModule {
 			activityRecreationHandle,
 			incognitoModeIndicator,
 		)
+
+		@Provides
+		@Singleton
+		fun provideContentCache(
+			application: Application,
+		): ContentCache {
+			return if (application.activityManager?.isLowRamDevice == true) {
+				StubContentCache()
+			} else {
+				MemoryContentCache(application)
+			}
+		}
 	}
 }

app/src/main/java/org/koitharu/kotatsu/core/cache/ContentCache.kt

@@ -0,0 +1,23 @@
+package org.koitharu.kotatsu.core.cache
+
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.model.MangaSource
+
+interface ContentCache {
+
+	val isCachingEnabled: Boolean
+
+	suspend fun getDetails(source: MangaSource, url: String): Manga?
+
+	fun putDetails(source: MangaSource, url: String, details: SafeDeferred<Manga>)
+
+	suspend fun getPages(source: MangaSource, url: String): List<MangaPage>?
+
+	fun putPages(source: MangaSource, url: String, pages: SafeDeferred<List<MangaPage>>)
+
+	data class Key(
+		val source: MangaSource,
+		val url: String,
+	)
+}

app/src/main/java/org/koitharu/kotatsu/core/cache/DeferredLruCache.kt

@@ -0,0 +1,5 @@
+package org.koitharu.kotatsu.core.cache
+
+import androidx.collection.LruCache
+
+class DeferredLruCache<T>(maxSize: Int) : LruCache<ContentCache.Key, SafeDeferred<T>>(maxSize)

app/src/main/java/org/koitharu/kotatsu/core/cache/MemoryContentCache.kt

@@ -0,0 +1,59 @@
+package org.koitharu.kotatsu.core.cache
+
+import android.app.Application
+import android.content.ComponentCallbacks2
+import android.content.res.Configuration
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.model.MangaSource
+
+class MemoryContentCache(application: Application) : ContentCache, ComponentCallbacks2 {
+
+	init {
+		application.registerComponentCallbacks(this)
+	}
+
+	private val detailsCache = DeferredLruCache<Manga>(4)
+	private val pagesCache = DeferredLruCache<List<MangaPage>>(4)
+
+	override val isCachingEnabled: Boolean = true
+
+	override suspend fun getDetails(source: MangaSource, url: String): Manga? {
+		return detailsCache[ContentCache.Key(source, url)]?.awaitOrNull()
+	}
+
+	override fun putDetails(source: MangaSource, url: String, details: SafeDeferred<Manga>) {
+		detailsCache.put(ContentCache.Key(source, url), details)
+	}
+
+	override suspend fun getPages(source: MangaSource, url: String): List<MangaPage>? {
+		return pagesCache[ContentCache.Key(source, url)]?.awaitOrNull()
+	}
+
+	override fun putPages(source: MangaSource, url: String, pages: SafeDeferred<List<MangaPage>>) {
+		pagesCache.put(ContentCache.Key(source, url), pages)
+	}
+
+	override fun onConfigurationChanged(newConfig: Configuration) = Unit
+
+	override fun onLowMemory() = Unit
+
+	override fun onTrimMemory(level: Int) {
+		trimCache(detailsCache, level)
+		trimCache(pagesCache, level)
+	}
+
+	private fun trimCache(cache: DeferredLruCache<*>, level: Int) {
+		when (level) {
+			ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL,
+			ComponentCallbacks2.TRIM_MEMORY_COMPLETE,
+			ComponentCallbacks2.TRIM_MEMORY_MODERATE -> cache.evictAll()
+
+			ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN,
+			ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW,
+			ComponentCallbacks2.TRIM_MEMORY_BACKGROUND -> cache.trimToSize(1)
+
+			else -> cache.trimToSize(cache.maxSize() / 2)
+		}
+	}
+}

app/src/main/java/org/koitharu/kotatsu/core/cache/SafeDeferred.kt

@@ -0,0 +1,20 @@
+package org.koitharu.kotatsu.core.cache
+
+import kotlinx.coroutines.Deferred
+
+class SafeDeferred<T>(
+	private val delegate: Deferred<Result<T>>,
+) {
+
+	suspend fun await(): T {
+		return delegate.await().getOrThrow()
+	}
+
+	suspend fun awaitOrNull(): T? {
+		return delegate.await().getOrNull()
+	}
+
+	fun cancel() {
+		delegate.cancel()
+	}
+}

app/src/main/java/org/koitharu/kotatsu/core/cache/StubContentCache.kt

@@ -0,0 +1,18 @@
+package org.koitharu.kotatsu.core.cache
+
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.model.MangaSource
+
+class StubContentCache : ContentCache {
+
+	override val isCachingEnabled: Boolean = false
+
+	override suspend fun getDetails(source: MangaSource, url: String): Manga? = null
+
+	override fun putDetails(source: MangaSource, url: String, details: SafeDeferred<Manga>) = Unit
+
+	override suspend fun getPages(source: MangaSource, url: String): List<MangaPage>? = null
+
+	override fun putPages(source: MangaSource, url: String, pages: SafeDeferred<List<MangaPage>>) = Unit
+}

app/src/main/java/org/koitharu/kotatsu/core/db/dao/PreferencesDao.kt

@@ -13,16 +13,6 @@ abstract class PreferencesDao {
 	@Query("SELECT * FROM preferences WHERE manga_id = :mangaId")
 	abstract fun observe(mangaId: Long): Flow<MangaPrefsEntity?>
 
-	@Insert(onConflict = OnConflictStrategy.IGNORE)
+	@Upsert
-	abstract suspend fun insert(pref: MangaPrefsEntity): Long
+	abstract suspend fun upsert(pref: MangaPrefsEntity)
-
-	@Update
-	abstract suspend fun update(pref: MangaPrefsEntity): Int
-
-	@Transaction
-	open suspend fun upsert(pref: MangaPrefsEntity) {
-		if (update(pref) == 0) {
-			insert(pref)
-		}
-	}
 }

app/src/main/java/org/koitharu/kotatsu/core/db/dao/TagsDao.kt

@@ -14,7 +14,7 @@ abstract class TagsDao {
 		LEFT JOIN manga_tags ON tags.tag_id = manga_tags.tag_id
 		GROUP BY tags.title 
 		ORDER BY COUNT(manga_id) DESC 
-		LIMIT :limit"""
+		LIMIT :limit""",
 	)
 	abstract suspend fun findPopularTags(limit: Int): List<TagEntity>
 
@@ -24,7 +24,7 @@ abstract class TagsDao {
 		WHERE tags.source = :source 
 		GROUP BY tags.title
 		ORDER BY COUNT(manga_id) DESC 
-		LIMIT :limit"""
+		LIMIT :limit""",
 	)
 	abstract suspend fun findPopularTags(source: String, limit: Int): List<TagEntity>
 
@@ -34,7 +34,7 @@ abstract class TagsDao {
 		WHERE tags.source = :source AND title LIKE :query
 		GROUP BY tags.title
 		ORDER BY COUNT(manga_id) DESC 
-		LIMIT :limit"""
+		LIMIT :limit""",
 	)
 	abstract suspend fun findTags(source: String, query: String, limit: Int): List<TagEntity>
 
@@ -44,22 +44,10 @@ abstract class TagsDao {
 		WHERE title LIKE :query
 		GROUP BY tags.title
 		ORDER BY COUNT(manga_id) DESC 
-		LIMIT :limit"""
+		LIMIT :limit""",
 	)
 	abstract suspend fun findTags(query: String, limit: Int): List<TagEntity>
 
-	@Insert(onConflict = OnConflictStrategy.IGNORE)
+	@Upsert
-	abstract suspend fun insert(tag: TagEntity): Long
+	abstract suspend fun upsert(tags: Iterable<TagEntity>)
-
+}
-	@Update(onConflict = OnConflictStrategy.IGNORE)
-	abstract suspend fun update(tag: TagEntity): Int
-
-	@Transaction
-	open suspend fun upsert(tags: Iterable<TagEntity>) {
-		tags.forEach { tag ->
-			if (update(tag) <= 0) {
-				insert(tag)
-			}
-		}
-	}
-}

app/src/main/java/org/koitharu/kotatsu/core/github/AppUpdateRepository.kt

@@ -80,6 +80,12 @@ class AppUpdateRepository @Inject constructor(
 		return BuildConfig.DEBUG || getCertificateSHA1Fingerprint() == CERT_SHA1
 	}
 
+	suspend fun getCurrentVersionChangelog(): String? {
+		val currentVersion = VersionId(BuildConfig.VERSION_NAME)
+		val available = getAvailableVersions()
+		return available.find { x -> x.versionId == currentVersion }?.description
+	}
+
 	@Suppress("DEPRECATION")
 	@SuppressLint("PackageManagerGetSignatures")
 	private fun getCertificateSHA1Fingerprint(): String? = runCatching {

app/src/main/java/org/koitharu/kotatsu/core/logs/FileLogger.kt

@@ -0,0 +1,128 @@
+package org.koitharu.kotatsu.core.logs
+
+import android.content.Context
+import androidx.annotation.WorkerThread
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runInterruptible
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
+import org.koitharu.kotatsu.utils.ext.processLifecycleScope
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
+import org.koitharu.kotatsu.utils.ext.subdir
+import java.io.File
+import java.io.FileOutputStream
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.concurrent.ConcurrentLinkedQueue
+
+private const val DIR = "logs"
+private const val FLUSH_DELAY = 2_000L
+private const val MAX_SIZE_BYTES = 1024 * 1024 // 1 MB
+
+class FileLogger(
+	context: Context,
+	private val settings: AppSettings,
+	name: String,
+) {
+
+	val file by lazy {
+		val dir = context.getExternalFilesDir(DIR) ?: context.filesDir.subdir(DIR)
+		File(dir, "$name.log")
+	}
+	val isEnabled: Boolean
+		get() = settings.isLoggingEnabled
+	private val dateFormat = SimpleDateFormat.getDateTimeInstance(
+		SimpleDateFormat.SHORT,
+		SimpleDateFormat.SHORT,
+		Locale.ROOT,
+	)
+	private val buffer = ConcurrentLinkedQueue<String>()
+	private val mutex = Mutex()
+	private var flushJob: Job? = null
+
+	fun log(message: String, e: Throwable? = null) {
+		if (!isEnabled) {
+			return
+		}
+		val text = buildString {
+			append(dateFormat.format(Date()))
+			append(": ")
+			if (e != null) {
+				append("E!")
+			}
+			append(message)
+			if (e != null) {
+				append(' ')
+				append(e.stackTraceToString())
+				appendLine()
+			}
+		}
+		buffer.add(text)
+		postFlush()
+	}
+
+	suspend fun flush() {
+		if (!isEnabled) {
+			return
+		}
+		flushJob?.cancelAndJoin()
+		flushImpl()
+	}
+
+	private fun postFlush() {
+		if (flushJob?.isActive == true) {
+			return
+		}
+		flushJob = processLifecycleScope.launch(Dispatchers.Default) {
+			delay(FLUSH_DELAY)
+			runCatchingCancellable {
+				flushImpl()
+			}.onFailure {
+				it.printStackTraceDebug()
+			}
+		}
+	}
+
+	private suspend fun flushImpl() {
+		mutex.withLock {
+			if (buffer.isEmpty()) {
+				return
+			}
+			runInterruptible(Dispatchers.IO) {
+				if (file.length() > MAX_SIZE_BYTES) {
+					rotate()
+				}
+				FileOutputStream(file, true).use {
+					while (true) {
+						val message = buffer.poll() ?: break
+						it.write(message.toByteArray())
+						it.write('\n'.code)
+					}
+					it.flush()
+				}
+			}
+		}
+	}
+
+	@WorkerThread
+	private fun rotate() {
+		val length = file.length()
+		val bakFile = File(file.parentFile, file.name + ".bak")
+		file.renameTo(bakFile)
+		bakFile.inputStream().use { input ->
+			input.skip(length - MAX_SIZE_BYTES / 2)
+			file.outputStream().use { output ->
+				input.copyTo(output)
+				output.flush()
+			}
+		}
+		bakFile.delete()
+	}
+}

app/src/main/java/org/koitharu/kotatsu/core/logs/Loggers.kt

@@ -0,0 +1,7 @@
+package org.koitharu.kotatsu.core.logs
+
+import javax.inject.Qualifier
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class TrackerLogger

app/src/main/java/org/koitharu/kotatsu/core/logs/LoggersModule.kt

@@ -0,0 +1,31 @@
+package org.koitharu.kotatsu.core.logs
+
+import android.content.Context
+import androidx.collection.arraySetOf
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import dagger.multibindings.ElementsIntoSet
+import org.koitharu.kotatsu.core.prefs.AppSettings
+
+@Module
+@InstallIn(SingletonComponent::class)
+object LoggersModule {
+
+	@Provides
+	@TrackerLogger
+	fun provideTrackerLogger(
+		@ApplicationContext context: Context,
+		settings: AppSettings,
+	) = FileLogger(context, settings, "tracker")
+
+	@Provides
+	@ElementsIntoSet
+	fun provideAllLoggers(
+		@TrackerLogger trackerLogger: FileLogger,
+	): Set<@JvmSuppressWildcards FileLogger> = arraySetOf(
+		trackerLogger,
+	)
+}

app/src/main/java/org/koitharu/kotatsu/core/network/CommonHeaders.kt

@@ -7,9 +7,11 @@ object CommonHeaders {
 	const val REFERER = "Referer"
 	const val USER_AGENT = "User-Agent"
 	const val ACCEPT = "Accept"
+	const val CONTENT_TYPE = "Content-Type"
 	const val CONTENT_DISPOSITION = "Content-Disposition"
 	const val COOKIE = "Cookie"
 	const val CONTENT_ENCODING = "Content-Encoding"
+	const val ACCEPT_ENCODING = "Accept-Encoding"
 	const val AUTHORIZATION = "Authorization"
 
 	val CACHE_CONTROL_DISABLED: CacheControl

app/src/main/java/org/koitharu/kotatsu/core/parser/MangaRepository.kt

@@ -1,13 +1,19 @@
 package org.koitharu.kotatsu.core.parser
 
+import org.koitharu.kotatsu.core.cache.ContentCache
+import org.koitharu.kotatsu.local.domain.LocalMangaRepository
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.parsers.model.SortOrder
 import java.lang.ref.WeakReference
-import java.util.*
+import java.util.EnumMap
 import javax.inject.Inject
 import javax.inject.Singleton
 import kotlin.collections.set
-import org.koitharu.kotatsu.local.domain.LocalMangaRepository
-import org.koitharu.kotatsu.parsers.MangaLoaderContext
-import org.koitharu.kotatsu.parsers.model.*
 
 interface MangaRepository {
 
@@ -31,6 +37,7 @@ interface MangaRepository {
 	class Factory @Inject constructor(
 		private val localMangaRepository: LocalMangaRepository,
 		private val loaderContext: MangaLoaderContext,
+		private val contentCache: ContentCache,
 	) {
 
 		private val cache = EnumMap<MangaSource, WeakReference<RemoteMangaRepository>>(MangaSource::class.java)
@@ -42,7 +49,7 @@ interface MangaRepository {
 			cache[source]?.get()?.let { return it }
 			return synchronized(cache) {
 				cache[source]?.get()?.let { return it }
-				val repository = RemoteMangaRepository(MangaParser(source, loaderContext))
+				val repository = RemoteMangaRepository(MangaParser(source, loaderContext), contentCache)
 				cache[source] = WeakReference(repository)
 				repository
 			}

app/src/main/java/org/koitharu/kotatsu/core/parser/RemoteMangaRepository.kt

@@ -1,12 +1,31 @@
 package org.koitharu.kotatsu.core.parser
 
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.MainCoroutineDispatcher
+import kotlinx.coroutines.async
+import kotlinx.coroutines.currentCoroutineContext
+import org.koitharu.kotatsu.core.cache.ContentCache
+import org.koitharu.kotatsu.core.cache.SafeDeferred
 import org.koitharu.kotatsu.core.prefs.SourceSettings
 import org.koitharu.kotatsu.parsers.MangaParser
 import org.koitharu.kotatsu.parsers.MangaParserAuthProvider
 import org.koitharu.kotatsu.parsers.config.ConfigKey
-import org.koitharu.kotatsu.parsers.model.*
+import org.koitharu.kotatsu.parsers.model.Favicons
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.parsers.model.SortOrder
+import org.koitharu.kotatsu.utils.ext.processLifecycleScope
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
 
-class RemoteMangaRepository(private val parser: MangaParser) : MangaRepository {
+class RemoteMangaRepository(
+	private val parser: MangaParser,
+	private val cache: ContentCache,
+) : MangaRepository {
 
 	override val source: MangaSource
 		get() = parser.source
@@ -28,9 +47,23 @@ class RemoteMangaRepository(private val parser: MangaParser) : MangaRepository {
 		return parser.getList(offset, tags, sortOrder)
 	}
 
-	override suspend fun getDetails(manga: Manga): Manga = parser.getDetails(manga)
+	override suspend fun getDetails(manga: Manga): Manga {
+		cache.getDetails(source, manga.url)?.let { return it }
+		val details = asyncSafe {
+			parser.getDetails(manga)
+		}
+		cache.putDetails(source, manga.url, details)
+		return details.await()
+	}
 
-	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> = parser.getPages(chapter)
+	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
+		cache.getPages(source, chapter.url)?.let { return it }
+		val pages = asyncSafe {
+			parser.getPages(chapter)
+		}
+		cache.putPages(source, chapter.url, pages)
+		return pages.await()
+	}
 
 	override suspend fun getPageUrl(page: MangaPage): String = parser.getPageUrl(page)
 
@@ -45,4 +78,16 @@ class RemoteMangaRepository(private val parser: MangaParser) : MangaRepository {
 	}
 
 	private fun getConfig() = parser.config as SourceSettings
-}
+
+	private suspend fun <T> asyncSafe(block: suspend CoroutineScope.() -> T): SafeDeferred<T> {
+		var dispatcher = currentCoroutineContext()[CoroutineDispatcher.Key]
+		if (dispatcher == null || dispatcher is MainCoroutineDispatcher) {
+			dispatcher = Dispatchers.Default
+		}
+		return SafeDeferred(
+			processLifecycleScope.async(dispatcher) {
+				runCatchingCancellable { block() }
+			},
+		)
+	}
+}

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

@@ -2,12 +2,12 @@ package org.koitharu.kotatsu.core.prefs
 
 import android.content.Context
 import android.content.SharedPreferences
-import android.net.ConnectivityManager
 import android.net.Uri
 import android.provider.Settings
 import androidx.appcompat.app.AppCompatDelegate
 import androidx.collection.arraySetOf
 import androidx.core.content.edit
+import androidx.core.os.LocaleListCompat
 import androidx.preference.PreferenceManager
 import com.google.android.material.color.DynamicColors
 import dagger.hilt.android.qualifiers.ApplicationContext
@@ -17,6 +17,7 @@ import org.koitharu.kotatsu.core.network.DoHProvider
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.shelf.domain.ShelfSection
+import org.koitharu.kotatsu.utils.ext.connectivityManager
 import org.koitharu.kotatsu.utils.ext.getEnumValue
 import org.koitharu.kotatsu.utils.ext.observe
 import org.koitharu.kotatsu.utils.ext.putEnumValue
@@ -34,6 +35,7 @@ import javax.inject.Singleton
 class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 
 	private val prefs = PreferenceManager.getDefaultSharedPreferences(context)
+	private val connectivityManager = context.connectivityManager
 
 	private val remoteSources = EnumSet.allOf(MangaSource::class.java).apply {
 		remove(MangaSource.LOCAL)
@@ -78,6 +80,17 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		get() = prefs.getInt(KEY_GRID_SIZE, 100)
 		set(value) = prefs.edit { putInt(KEY_GRID_SIZE, value) }
 
+	var appLocales: LocaleListCompat
+		get() {
+			val raw = prefs.getString(KEY_APP_LOCALE, null)
+			return LocaleListCompat.forLanguageTags(raw)
+		}
+		set(value) {
+			prefs.edit {
+				putString(KEY_APP_LOCALE, value.toLanguageTags())
+			}
+		}
+
 	val readerPageSwitch: Set<String>
 		get() = prefs.getStringSet(KEY_READER_SWITCHERS, null) ?: setOf(PAGE_SWITCH_TAPS)
 
@@ -146,6 +159,9 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		get() = prefs.getString(KEY_APP_PASSWORD, null)
 		set(value) = prefs.edit { if (value != null) putString(KEY_APP_PASSWORD, value) else remove(KEY_APP_PASSWORD) }
 
+	val isLoggingEnabled: Boolean
+		get() = prefs.getBoolean(KEY_LOGGING_ENABLED, false)
+
 	var isBiometricProtectionEnabled: Boolean
 		get() = prefs.getBoolean(KEY_PROTECT_APP_BIOMETRIC, true)
 		set(value) = prefs.edit { putBoolean(KEY_PROTECT_APP_BIOMETRIC, value) }
@@ -156,6 +172,11 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isDynamicShortcutsEnabled: Boolean
 		get() = prefs.getBoolean(KEY_SHORTCUTS, true)
 
+	fun isContentPrefetchEnabled(): Boolean {
+		val policy = NetworkPolicy.from(prefs.getString(KEY_PREFETCH_CONTENT, null), NetworkPolicy.NEVER)
+		return policy.isNetworkAllowed(connectivityManager)
+	}
+
 	var sourcesOrder: List<String>
 		get() = prefs.getString(KEY_SOURCES_ORDER, null)
 			?.split('|')
@@ -234,12 +255,9 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isWebtoonZoomEnable: Boolean
 		get() = prefs.getBoolean(KEY_WEBTOON_ZOOM, true)
 
-	fun isPagesPreloadAllowed(cm: ConnectivityManager): Boolean {
+	fun isPagesPreloadEnabled(): Boolean {
-		return when (prefs.getString(KEY_PAGES_PRELOAD, null)?.toIntOrNull()) {
+		val policy = NetworkPolicy.from(prefs.getString(KEY_PAGES_PRELOAD, null), NetworkPolicy.NON_METERED)
-			NETWORK_ALWAYS -> true
+		return policy.isNetworkAllowed(connectivityManager)
-			NETWORK_NEVER -> false
-			else -> cm.isActiveNetworkMetered
-		}
 	}
 
 	fun getDateFormat(format: String = prefs.getString(KEY_DATE_FORMAT, "").orEmpty()): DateFormat =
@@ -293,7 +311,6 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val TRACK_FAVOURITES = "favourites"
 
 		const val KEY_LIST_MODE = "list_mode_2"
-		const val KEY_APP_SECTION = "app_section_2"
 		const val KEY_THEME = "theme"
 		const val KEY_DYNAMIC_THEME = "dynamic_theme"
 		const val KEY_THEME_AMOLED = "amoled_theme"
@@ -341,6 +358,7 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_SUGGESTIONS_EXCLUDE_NSFW = "suggestions_exclude_nsfw"
 		const val KEY_SUGGESTIONS_EXCLUDE_TAGS = "suggestions_exclude_tags"
 		const val KEY_SHIKIMORI = "shikimori"
+		const val KEY_ANILIST = "anilist"
 		const val KEY_MAL = "mal"
 		const val KEY_DOWNLOADS_PARALLELISM = "downloads_parallelism"
 		const val KEY_DOWNLOADS_SLOWDOWN = "downloads_slowdown"
@@ -356,13 +374,13 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_LOCAL_LIST_ORDER = "local_order"
 		const val KEY_WEBTOON_ZOOM = "webtoon_zoom"
 		const val KEY_SHELF_SECTIONS = "shelf_sections_2"
+		const val KEY_PREFETCH_CONTENT = "prefetch_content"
+		const val KEY_APP_LOCALE = "app_locale"
+		const val KEY_LOGGING_ENABLED = "logging"
+		const val KEY_LOGS_SHARE = "logs_share"
 
 		// About
 		const val KEY_APP_UPDATE = "app_update"
 		const val KEY_APP_TRANSLATION = "about_app_translation"
-
-		private const val NETWORK_NEVER = 0
-		private const val NETWORK_ALWAYS = 1
-		private const val NETWORK_NON_METERED = 2
 	}
 }

app/src/main/java/org/koitharu/kotatsu/core/prefs/NetworkPolicy.kt

@@ -0,0 +1,26 @@
+package org.koitharu.kotatsu.core.prefs
+
+import android.net.ConnectivityManager
+
+enum class NetworkPolicy(
+	private val key: Int,
+) {
+
+	NEVER(0),
+	ALWAYS(1),
+	NON_METERED(2);
+
+	fun isNetworkAllowed(cm: ConnectivityManager) = when (this) {
+		NEVER -> false
+		ALWAYS -> true
+		NON_METERED -> !cm.isActiveNetworkMetered
+	}
+
+	companion object {
+
+		fun from(key: String?, default: NetworkPolicy): NetworkPolicy {
+			val intKey = key?.toIntOrNull() ?: return default
+			return enumValues<NetworkPolicy>().find { it.key == intKey } ?: default
+		}
+	}
+}

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

@@ -24,6 +24,7 @@ class SourceSettings(context: Context, source: MangaSource) : MangaSourceConfig
 	override fun <T> get(key: ConfigKey<T>): T {
 		return when (key) {
 			is ConfigKey.Domain -> prefs.getString(key.key, key.defaultValue).ifNullOrEmpty { key.defaultValue }
+			is ConfigKey.ShowSuspiciousContent -> prefs.getBoolean(key.key, key.defaultValue)
 		} as T
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/details/service/MangaPrefetchService.kt

@@ -0,0 +1,116 @@
+package org.koitharu.kotatsu.details.service
+
+import android.content.Context
+import android.content.Intent
+import dagger.hilt.android.AndroidEntryPoint
+import dagger.hilt.android.EntryPointAccessors
+import org.koitharu.kotatsu.base.ui.CoroutineIntentService
+import org.koitharu.kotatsu.core.cache.ContentCache
+import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
+import org.koitharu.kotatsu.core.model.parcelable.ParcelableMangaChapters
+import org.koitharu.kotatsu.core.parser.MangaRepository
+import org.koitharu.kotatsu.history.domain.HistoryRepository
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.utils.ext.getParcelableExtraCompat
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class MangaPrefetchService : CoroutineIntentService() {
+
+	@Inject
+	lateinit var mangaRepositoryFactory: MangaRepository.Factory
+
+	@Inject
+	lateinit var cache: ContentCache
+
+	@Inject
+	lateinit var historyRepository: HistoryRepository
+
+	override suspend fun processIntent(startId: Int, intent: Intent) {
+		when (intent.action) {
+			ACTION_PREFETCH_DETAILS -> prefetchDetails(
+				manga = intent.getParcelableExtraCompat<ParcelableManga>(EXTRA_MANGA)?.manga ?: return,
+			)
+
+			ACTION_PREFETCH_PAGES -> prefetchPages(
+				chapter = intent.getParcelableExtraCompat<ParcelableMangaChapters>(EXTRA_CHAPTER)
+					?.chapters?.singleOrNull() ?: return,
+			)
+
+			ACTION_PREFETCH_LAST -> prefetchLast()
+		}
+	}
+
+	override fun onError(startId: Int, error: Throwable) = Unit
+
+	private suspend fun prefetchDetails(manga: Manga) {
+		val source = mangaRepositoryFactory.create(manga.source)
+		runCatchingCancellable { source.getDetails(manga) }
+	}
+
+	private suspend fun prefetchPages(chapter: MangaChapter) {
+		val source = mangaRepositoryFactory.create(chapter.source)
+		runCatchingCancellable { source.getPages(chapter) }
+	}
+
+	private suspend fun prefetchLast() {
+		val last = historyRepository.getLastOrNull() ?: return
+		if (last.source == MangaSource.LOCAL) return
+		val repo = mangaRepositoryFactory.create(last.source)
+		val details = runCatchingCancellable { repo.getDetails(last) }.getOrNull() ?: return
+		val chapters = details.chapters
+		if (chapters.isNullOrEmpty()) {
+			return
+		}
+		val history = historyRepository.getOne(last)
+		val chapter = if (history == null) {
+			chapters.firstOrNull()
+		} else {
+			chapters.find { x -> x.id == history.chapterId } ?: chapters.firstOrNull()
+		} ?: return
+		runCatchingCancellable { repo.getPages(chapter) }
+	}
+
+	companion object {
+
+		private const val EXTRA_MANGA = "manga"
+		private const val EXTRA_CHAPTER = "manga"
+		private const val ACTION_PREFETCH_DETAILS = "details"
+		private const val ACTION_PREFETCH_PAGES = "pages"
+		private const val ACTION_PREFETCH_LAST = "last"
+
+		fun prefetchDetails(context: Context, manga: Manga) {
+			if (!isPrefetchAvailable(context, manga.source)) return
+			val intent = Intent(context, MangaPrefetchService::class.java)
+			intent.action = ACTION_PREFETCH_DETAILS
+			intent.putExtra(EXTRA_MANGA, ParcelableManga(manga, withChapters = false))
+			context.startService(intent)
+		}
+
+		fun prefetchPages(context: Context, chapter: MangaChapter) {
+			if (!isPrefetchAvailable(context, chapter.source)) return
+			val intent = Intent(context, MangaPrefetchService::class.java)
+			intent.action = ACTION_PREFETCH_PAGES
+			intent.putExtra(EXTRA_CHAPTER, ParcelableMangaChapters(listOf(chapter)))
+			context.startService(intent)
+		}
+
+		fun prefetchLast(context: Context) {
+			if (!isPrefetchAvailable(context, null)) return
+			val intent = Intent(context, MangaPrefetchService::class.java)
+			intent.action = ACTION_PREFETCH_LAST
+			context.startService(intent)
+		}
+
+		private fun isPrefetchAvailable(context: Context, source: MangaSource?): Boolean {
+			if (source == MangaSource.LOCAL) {
+				return false
+			}
+			val entryPoint = EntryPointAccessors.fromApplication(context, PrefetchCompanionEntryPoint::class.java)
+			return entryPoint.contentCache.isCachingEnabled && entryPoint.settings.isContentPrefetchEnabled()
+		}
+	}
+}

app/src/main/java/org/koitharu/kotatsu/details/service/PrefetchCompanionEntryPoint.kt

@@ -0,0 +1,14 @@
+package org.koitharu.kotatsu.details.service
+
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import org.koitharu.kotatsu.core.cache.ContentCache
+import org.koitharu.kotatsu.core.prefs.AppSettings
+
+@EntryPoint
+@InstallIn(SingletonComponent::class)
+interface PrefetchCompanionEntryPoint {
+	val settings: AppSettings
+	val contentCache: ContentCache
+}

app/src/main/java/org/koitharu/kotatsu/details/ui/ChaptersFragment.kt

@@ -1,15 +1,16 @@
 package org.koitharu.kotatsu.details.ui
 
 import android.os.Bundle
-import android.view.*
+import android.view.LayoutInflater
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
 import androidx.appcompat.view.ActionMode
-import androidx.coordinatorlayout.widget.CoordinatorLayout
 import androidx.core.graphics.Insets
 import androidx.core.view.isVisible
 import androidx.fragment.app.activityViewModels
-import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.android.material.snackbar.Snackbar
-import kotlin.math.roundToInt
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseFragment
 import org.koitharu.kotatsu.base.ui.list.ListSelectionController
@@ -24,8 +25,8 @@ import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.reader.ui.ReaderActivity
 import org.koitharu.kotatsu.reader.ui.ReaderState
 import org.koitharu.kotatsu.utils.RecyclerViewScrollCallback
-import org.koitharu.kotatsu.utils.ext.parents
 import org.koitharu.kotatsu.utils.ext.scaleUpActivityOptionsOf
+import kotlin.math.roundToInt
 
 class ChaptersFragment :
 	BaseFragment<FragmentChaptersBinding>(),
@@ -102,6 +103,7 @@ class ChaptersFragment :
 				mode.finish()
 				true
 			}
+
 			R.id.action_delete -> {
 				val ids = selectionController?.peekCheckedIds()
 				val manga = viewModel.manga.value
@@ -120,6 +122,7 @@ class ChaptersFragment :
 				mode.finish()
 				true
 			}
+
 			R.id.action_select_range -> {
 				val items = chaptersAdapter?.items ?: return false
 				val ids = HashSet(controller.peekCheckedIds())
@@ -139,11 +142,20 @@ class ChaptersFragment :
 				controller.addAll(ids)
 				true
 			}
+
 			R.id.action_select_all -> {
 				val ids = chaptersAdapter?.items?.map { it.chapter.id } ?: return false
-				selectionController?.addAll(ids)
+				controller.addAll(ids)
 				true
 			}
+
+			R.id.action_mark_current -> {
+				val id = controller.peekCheckedIds().singleOrNull() ?: return false
+				viewModel.markChapterAsCurrent(id)
+				mode.finish()
+				true
+			}
+
 			else -> false
 		}
 	}
@@ -164,6 +176,7 @@ class ChaptersFragment :
 			x.chapter.source == MangaSource.LOCAL
 		}
 		menu.findItem(R.id.action_select_all).isVisible = items.size < allItems.size
+		menu.findItem(R.id.action_mark_current).isVisible = items.size == 1
 		mode.title = items.size.toString()
 		var hasGap = false
 		for (i in 0 until items.size - 1) {

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

@@ -18,6 +18,7 @@ import androidx.core.graphics.Insets
 import androidx.core.view.isGone
 import androidx.core.view.isVisible
 import androidx.core.view.updatePadding
+import androidx.lifecycle.Observer
 import androidx.lifecycle.lifecycleScope
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.snackbar.BaseTransientBottomBar
@@ -33,6 +34,8 @@ import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
 import org.koitharu.kotatsu.core.os.ShortcutsUpdater
 import org.koitharu.kotatsu.core.ui.MangaErrorDialog
 import org.koitharu.kotatsu.databinding.ActivityDetailsBinding
+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.download.ui.service.DownloadService
 import org.koitharu.kotatsu.main.ui.owners.NoModalBottomSheetOwner
@@ -120,6 +123,7 @@ class DetailsActivity :
 		viewModel.branches.observe(this) {
 			binding.buttonDropdown.isVisible = it.size > 1
 		}
+		viewModel.chapters.observe(this, PrefetchObserver(this))
 
 		registerReceiver(downloadReceiver, IntentFilter(DownloadService.ACTION_DOWNLOAD_COMPLETE))
 		addMenuProvider(
@@ -325,6 +329,24 @@ class DetailsActivity :
 		return sb
 	}
 
+	private class PrefetchObserver(
+		private val context: Context,
+	) : Observer<List<ChapterListItem>> {
+
+		private var isCalled = false
+
+		override fun onChanged(t: List<ChapterListItem>?) {
+			if (t.isNullOrEmpty()) {
+				return
+			}
+			if (!isCalled) {
+				isCalled = true
+				val item = t.find { it.hasFlag(ChapterListItem.FLAG_CURRENT) } ?: t.first()
+				MangaPrefetchService.prefetchPages(context, item.chapter)
+			}
+		}
+	}
+
 	companion object {
 
 		fun newIntent(context: Context, manga: Manga): Intent {

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

@@ -89,8 +89,14 @@ class DetailsViewModel @AssistedInject constructor(
 	private val favourite = favouritesRepository.observeCategoriesIds(delegate.mangaId).map { it.isNotEmpty() }
 		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, false)
 
-	private val newChapters = trackingRepository.observeNewChaptersCount(delegate.mangaId)
+	private val newChapters = settings.observeAsFlow(AppSettings.KEY_TRACKER_ENABLED) { isTrackerEnabled }
-		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, 0)
+		.flatMapLatest { isEnabled ->
+			if (isEnabled) {
+				trackingRepository.observeNewChaptersCount(delegate.mangaId)
+			} else {
+				flowOf(0)
+			}
+		}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, 0)
 
 	private val chaptersQuery = MutableStateFlow("")
 
@@ -105,7 +111,7 @@ class DetailsViewModel @AssistedInject constructor(
 	val historyInfo: LiveData<HistoryInfo> = combine(
 		delegate.manga,
 		history,
-		settings.observeAsFlow(AppSettings.KEY_INCOGNITO_MODE) { isIncognitoModeEnabled },
+		historyRepository.observeShouldSkip(delegate.manga),
 	) { m, h, im ->
 		HistoryInfo(m, h, im)
 	}.asFlowLiveData(
@@ -251,7 +257,8 @@ class DetailsViewModel @AssistedInject constructor(
 	}
 
 	fun updateScrobbling(rating: Float, status: ScrobblingStatus?) {
-		for (scrobbler in scrobblers) {
+		for (info in scrobblingInfo.value ?: return) {
+			val scrobbler = scrobblers.first { it.scrobblerService == info.scrobbler }
 			if (!scrobbler.isAvailable) continue
 			launchJob(Dispatchers.Default) {
 				scrobbler.updateScrobblingInfo(
@@ -275,6 +282,17 @@ class DetailsViewModel @AssistedInject constructor(
 		}
 	}
 
+	fun markChapterAsCurrent(chapterId: Long) {
+		launchJob(Dispatchers.Default) {
+			val manga = checkNotNull(delegate.manga.value)
+			val chapters = checkNotNull(manga.chapters)
+			val chapterIndex = chapters.indexOfFirst { it.id == chapterId }
+			check(chapterIndex in chapters.indices) { "Chapter not found" }
+			val percent = chapterIndex / chapters.size.toFloat()
+			historyRepository.addOrUpdate(manga = manga, chapterId = chapterId, page = 0, scroll = 0, percent = percent)
+		}
+	}
+
 	private fun doLoad() = launchLoadingJob(Dispatchers.Default) {
 		delegate.doLoad()
 	}

app/src/main/java/org/koitharu/kotatsu/favourites/data/FavouriteCategoriesDao.kt

@@ -21,9 +21,6 @@ abstract class FavouriteCategoriesDao {
 	@Insert(onConflict = OnConflictStrategy.ABORT)
 	abstract suspend fun insert(category: FavouriteCategoryEntity): Long
 
-	@Update
-	abstract suspend fun update(category: FavouriteCategoryEntity): Int
-
 	suspend fun delete(id: Long) = setDeletedAt(id, System.currentTimeMillis())
 
 	@Query("UPDATE favourite_categories SET title = :title, `order` = :order, `track` = :tracker  WHERE category_id = :id")
@@ -51,12 +48,8 @@ abstract class FavouriteCategoriesDao {
 		return (getMaxSortKey() ?: 0) + 1
 	}
 
-	@Transaction
+	@Upsert
-	open suspend fun upsert(entity: FavouriteCategoryEntity) {
+	abstract suspend fun upsert(entity: FavouriteCategoryEntity)
-		if (update(entity) == 0) {
-			insert(entity)
-		}
-	}
 
 	@Query("UPDATE favourite_categories SET deleted_at = :deletedAt WHERE category_id = :id")
 	protected abstract suspend fun setDeletedAt(id: Long, deletedAt: Long)

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

@@ -99,11 +99,6 @@ abstract class FavouritesDao {
 	@Insert(onConflict = OnConflictStrategy.REPLACE)
 	abstract suspend fun insert(favourite: FavouriteEntity)
 
-	/** UPDATE **/
-
-	@Update
-	abstract suspend fun update(favourite: FavouriteEntity): Int
-
 	/** DELETE **/
 
 	suspend fun delete(mangaId: Long) = setDeletedAt(
@@ -138,12 +133,8 @@ abstract class FavouritesDao {
 
 	/** TOOLS **/
 
-	@Transaction
+	@Upsert
-	open suspend fun upsert(entity: FavouriteEntity) {
+	abstract suspend fun upsert(entity: FavouriteEntity)
-		if (update(entity) == 0) {
-			insert(entity)
-		}
-	}
 
 	@Transaction
 	@RawQuery(observedEntities = [FavouriteEntity::class])
@@ -166,6 +157,7 @@ abstract class FavouritesDao {
 		SortOrder.NEWEST,
 		SortOrder.UPDATED,
 		-> "created_at DESC"
+
 		SortOrder.ALPHABETICAL -> "title ASC"
 		else -> throw IllegalArgumentException("Sort order $sortOrder is not supported")
 	}

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

@@ -9,6 +9,7 @@ import android.view.Menu
 import android.view.MenuItem
 import android.view.View
 import android.view.ViewGroup
+import androidx.activity.OnBackPressedCallback
 import androidx.activity.viewModels
 import androidx.core.graphics.Insets
 import androidx.core.view.isVisible
@@ -19,7 +20,6 @@ import androidx.recyclerview.widget.RecyclerView
 import coil.ImageLoader
 import com.google.android.material.snackbar.Snackbar
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseActivity
 import org.koitharu.kotatsu.base.ui.list.ListSelectionController
@@ -32,8 +32,8 @@ import org.koitharu.kotatsu.list.ui.adapter.ListStateHolderListener
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.utils.ext.getDisplayMessage
-import org.koitharu.kotatsu.utils.ext.measureHeight
 import org.koitharu.kotatsu.utils.ext.scaleUpActivityOptionsOf
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class FavouriteCategoriesActivity :
@@ -47,6 +47,7 @@ class FavouriteCategoriesActivity :
 
 	private val viewModel by viewModels<FavouritesCategoriesViewModel>()
 
+	private lateinit var exitReorderModeCallback: ExitReorderModeCallback
 	private lateinit var adapter: CategoriesAdapter
 	private lateinit var selectionController: ListSelectionController
 	private var reorderHelper: ItemTouchHelper? = null
@@ -55,6 +56,7 @@ class FavouriteCategoriesActivity :
 		super.onCreate(savedInstanceState)
 		setContentView(ActivityCategoriesBinding.inflate(layoutInflater))
 		supportActionBar?.setDisplayHomeAsUpEnabled(true)
+		exitReorderModeCallback = ExitReorderModeCallback(viewModel)
 		adapter = CategoriesAdapter(coil, this, this, this)
 		selectionController = ListSelectionController(
 			activity = this,
@@ -67,6 +69,7 @@ class FavouriteCategoriesActivity :
 		binding.recyclerView.setHasFixedSize(true)
 		binding.recyclerView.adapter = adapter
 		binding.fabAdd.setOnClickListener(this)
+		onBackPressedDispatcher.addCallback(exitReorderModeCallback)
 
 		viewModel.detalizedCategories.observe(this, ::onCategoriesChanged)
 		viewModel.onError.observe(this, ::onError)
@@ -90,15 +93,8 @@ class FavouriteCategoriesActivity :
 				viewModel.setReorderMode(true)
 				true
 			}
-			else -> super.onOptionsItemSelected(item)
-		}
-	}
 
-	override fun onBackPressed() {
+			else -> super.onOptionsItemSelected(item)
-		if (viewModel.isInReorderMode()) {
-			viewModel.setReorderMode(false)
-		} else {
-			super.onBackPressed()
 		}
 	}
 
@@ -138,7 +134,7 @@ class FavouriteCategoriesActivity :
 		}
 		binding.root.updatePadding(
 			left = insets.left,
-			right = insets.right
+			right = insets.right,
 		)
 		binding.recyclerView.updatePadding(
 			bottom = insets.bottom,
@@ -174,6 +170,7 @@ class FavouriteCategoriesActivity :
 		binding.recyclerView.isNestedScrollingEnabled = !isReorderMode
 		invalidateOptionsMenu()
 		binding.buttonDone.isVisible = isReorderMode
+		exitReorderModeCallback.isEnabled = isReorderMode
 	}
 
 	private inner class ReorderHelperCallback : ItemTouchHelper.SimpleCallback(
@@ -211,6 +208,15 @@ class FavouriteCategoriesActivity :
 		override fun isLongPressDragEnabled(): Boolean = false
 	}
 
+	private class ExitReorderModeCallback(
+		private val viewModel: FavouritesCategoriesViewModel,
+	) : OnBackPressedCallback(viewModel.isInReorderMode()) {
+
+		override fun handleOnBackPressed() {
+			viewModel.setReorderMode(false)
+		}
+	}
+
 	companion object {
 
 		val SORT_ORDERS = arrayOf(

app/src/main/java/org/koitharu/kotatsu/favourites/ui/list/FavouritesListFragment.kt

@@ -7,15 +7,16 @@ import android.view.View
 import androidx.appcompat.view.ActionMode
 import androidx.appcompat.widget.PopupMenu
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.list.ListSelectionController
 import org.koitharu.kotatsu.core.ui.titleRes
 import org.koitharu.kotatsu.favourites.ui.categories.FavouriteCategoriesActivity
 import org.koitharu.kotatsu.list.ui.MangaListFragment
 import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.utils.ext.addMenuProvider
 import org.koitharu.kotatsu.utils.ext.assistedViewModels
 import org.koitharu.kotatsu.utils.ext.withArgs
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class FavouritesListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickListener {
@@ -23,9 +24,7 @@ class FavouritesListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickLis
 	@Inject
 	lateinit var viewModelFactory: FavouritesListViewModel.Factory
 
-	override val viewModel by assistedViewModels<FavouritesListViewModel> {
+	override val viewModel by assistedViewModels { viewModelFactory.create(categoryId) }
-		viewModelFactory.create(categoryId)
-	}
 
 	private val categoryId: Long
 		get() = arguments?.getLong(ARG_CATEGORY_ID) ?: NO_ID
@@ -34,6 +33,9 @@ class FavouritesListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickLis
 
 	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
 		super.onViewCreated(view, savedInstanceState)
+		if (viewModel.categoryId != NO_ID) {
+			addMenuProvider(FavouritesListMenuProvider(view.context, viewModel))
+		}
 		viewModel.sortOrder.observe(viewLifecycleOwner) { activity?.invalidateOptionsMenu() }
 	}
 
@@ -73,6 +75,7 @@ class FavouritesListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickLis
 				mode.finish()
 				true
 			}
+
 			else -> super.onActionItemClicked(controller, mode, item)
 		}
 	}

app/src/main/java/org/koitharu/kotatsu/favourites/ui/list/FavouritesListMenuProvider.kt

@@ -0,0 +1,56 @@
+package org.koitharu.kotatsu.favourites.ui.list
+
+import android.content.Context
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
+import androidx.core.view.MenuProvider
+import androidx.core.view.forEach
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.ui.titleRes
+import org.koitharu.kotatsu.favourites.ui.categories.FavouriteCategoriesActivity
+import org.koitharu.kotatsu.favourites.ui.categories.edit.FavouritesCategoryEditActivity
+import org.koitharu.kotatsu.parsers.model.SortOrder
+
+class FavouritesListMenuProvider(
+	private val context: Context,
+	private val viewModel: FavouritesListViewModel,
+) : MenuProvider {
+
+	override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
+		menuInflater.inflate(R.menu.opt_favourites, menu)
+		val subMenu = menu.findItem(R.id.action_order)?.subMenu ?: return
+		for (order in FavouriteCategoriesActivity.SORT_ORDERS) {
+			subMenu.add(R.id.group_order, Menu.NONE, order.ordinal, order.titleRes)
+		}
+		subMenu.setGroupCheckable(R.id.group_order, true, true)
+	}
+
+	override fun onPrepareMenu(menu: Menu) {
+		super.onPrepareMenu(menu)
+		val order = viewModel.sortOrder.value ?: return
+		menu.findItem(R.id.action_order)?.subMenu?.forEach { item ->
+			if (item.order == order.ordinal) {
+				item.isChecked = true
+			}
+		}
+	}
+
+	override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
+		if (menuItem.groupId == R.id.group_order) {
+			val order = enumValues<SortOrder>()[menuItem.order]
+			viewModel.setSortOrder(order)
+			return true
+		}
+		return when (menuItem.itemId) {
+			R.id.action_edit -> {
+				context.startActivity(
+					FavouritesCategoryEditActivity.newIntent(context, viewModel.categoryId),
+				)
+				true
+			}
+
+			else -> false
+		}
+	}
+}

app/src/main/java/org/koitharu/kotatsu/favourites/ui/list/FavouritesListViewModel.kt

@@ -31,7 +31,7 @@ import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
 import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
 
 class FavouritesListViewModel @AssistedInject constructor(
-	@Assisted private val categoryId: Long,
+	@Assisted val categoryId: Long,
 	private val repository: FavouritesRepository,
 	private val trackingRepository: TrackingRepository,
 	private val historyRepository: HistoryRepository,
@@ -55,7 +55,7 @@ class FavouritesListViewModel @AssistedInject constructor(
 		} else {
 			repository.observeAll(categoryId)
 		},
-		createListModeFlow(),
+		listModeFlow,
 	) { list, mode ->
 		when {
 			list.isEmpty() -> listOf(
@@ -117,7 +117,11 @@ class FavouritesListViewModel @AssistedInject constructor(
 	}
 
 	override suspend fun getCounter(mangaId: Long): Int {
-		return trackingRepository.getNewChaptersCount(mangaId)
+		return if (settings.isTrackerEnabled) {
+			trackingRepository.getNewChaptersCount(mangaId)
+		} else {
+			0
+		}
 	}
 
 	override suspend fun getProgress(mangaId: Long): Float {

app/src/main/java/org/koitharu/kotatsu/history/domain/HistoryRepository.kt

@@ -1,15 +1,23 @@
 package org.koitharu.kotatsu.history.domain
 
 import androidx.room.withTransaction
-import javax.inject.Inject
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.distinctUntilChangedBy
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onStart
 import org.koitharu.kotatsu.base.domain.ReversibleHandle
 import org.koitharu.kotatsu.core.db.MangaDatabase
-import org.koitharu.kotatsu.core.db.entity.*
+import org.koitharu.kotatsu.core.db.entity.toEntities
+import org.koitharu.kotatsu.core.db.entity.toEntity
+import org.koitharu.kotatsu.core.db.entity.toManga
+import org.koitharu.kotatsu.core.db.entity.toMangaTag
+import org.koitharu.kotatsu.core.db.entity.toMangaTags
 import org.koitharu.kotatsu.core.model.MangaHistory
 import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.core.prefs.observeAsFlow
 import org.koitharu.kotatsu.history.data.HistoryEntity
 import org.koitharu.kotatsu.history.data.toMangaHistory
 import org.koitharu.kotatsu.parsers.model.Manga
@@ -18,6 +26,7 @@ import org.koitharu.kotatsu.scrobbling.domain.Scrobbler
 import org.koitharu.kotatsu.scrobbling.domain.tryScrobble
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import org.koitharu.kotatsu.utils.ext.mapItems
+import javax.inject.Inject
 
 const val PROGRESS_NONE = -1f
 
@@ -66,7 +75,7 @@ class HistoryRepository @Inject constructor(
 	}
 
 	suspend fun addOrUpdate(manga: Manga, chapterId: Long, page: Int, scroll: Int, percent: Float) {
-		if (manga.isNsfw && settings.isHistoryExcludeNsfw || settings.isIncognitoModeEnabled) {
+		if (shouldSkip(manga)) {
 			return
 		}
 		val tags = manga.tags.toEntities()
@@ -138,6 +147,30 @@ class HistoryRepository @Inject constructor(
 		return db.historyDao.findPopularTags(limit).map { x -> x.toMangaTag() }
 	}
 
+	fun shouldSkip(manga: Manga): Boolean {
+		return manga.isNsfw && settings.isHistoryExcludeNsfw || settings.isIncognitoModeEnabled
+	}
+
+	fun observeShouldSkip(manga: Manga): Flow<Boolean> {
+		return settings.observe()
+			.filter { key -> key == AppSettings.KEY_INCOGNITO_MODE || key == AppSettings.KEY_HISTORY_EXCLUDE_NSFW }
+			.onStart { emit("") }
+			.map { shouldSkip(manga) }
+			.distinctUntilChanged()
+	}
+
+	fun observeShouldSkip(mangaFlow: Flow<Manga?>): Flow<Boolean> {
+		return mangaFlow
+			.distinctUntilChangedBy { it?.isNsfw }
+			.flatMapLatest { m ->
+				if (m != null) {
+					observeShouldSkip(m)
+				} else {
+					settings.observeAsFlow(AppSettings.KEY_INCOGNITO_MODE) { isIncognitoModeEnabled }
+				}
+			}
+	}
+
 	private suspend fun recover(ids: Collection<Long>) {
 		db.withTransaction {
 			for (id in ids) {

app/src/main/java/org/koitharu/kotatsu/history/ui/HistoryListViewModel.kt

@@ -3,9 +3,6 @@ package org.koitharu.kotatsu.history.ui
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
-import java.util.*
-import java.util.concurrent.TimeUnit
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
@@ -21,11 +18,20 @@ import org.koitharu.kotatsu.history.domain.HistoryRepository
 import org.koitharu.kotatsu.history.domain.MangaWithHistory
 import org.koitharu.kotatsu.history.domain.PROGRESS_NONE
 import org.koitharu.kotatsu.list.ui.MangaListViewModel
-import org.koitharu.kotatsu.list.ui.model.*
+import org.koitharu.kotatsu.list.ui.model.EmptyState
+import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.list.ui.model.LoadingState
+import org.koitharu.kotatsu.list.ui.model.toErrorState
+import org.koitharu.kotatsu.list.ui.model.toGridModel
+import org.koitharu.kotatsu.list.ui.model.toListDetailedModel
+import org.koitharu.kotatsu.list.ui.model.toListModel
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import org.koitharu.kotatsu.utils.asFlowLiveData
 import org.koitharu.kotatsu.utils.ext.daysDiff
 import org.koitharu.kotatsu.utils.ext.onFirst
+import java.util.Date
+import java.util.concurrent.TimeUnit
+import javax.inject.Inject
 
 @HiltViewModel
 class HistoryListViewModel @Inject constructor(
@@ -42,7 +48,7 @@ class HistoryListViewModel @Inject constructor(
 	override val content = combine(
 		repository.observeAllWithHistory(),
 		historyGrouping,
-		createListModeFlow(),
+		listModeFlow,
 	) { list, grouped, mode ->
 		when {
 			list.isEmpty() -> listOf(
@@ -53,6 +59,7 @@ class HistoryListViewModel @Inject constructor(
 					actionStringRes = 0,
 				),
 			)
+
 			else -> mapList(list, grouped, mode)
 		}
 	}.onStart {
@@ -103,7 +110,11 @@ class HistoryListViewModel @Inject constructor(
 				}
 				prevDate = date
 			}
-			val counter = trackingRepository.getNewChaptersCount(manga.id)
+			val counter = if (settings.isTrackerEnabled) {
+				trackingRepository.getNewChaptersCount(manga.id)
+			} else {
+				0
+			}
 			val percent = if (showPercent) history.percent else PROGRESS_NONE
 			result += when (mode) {
 				ListMode.LIST -> manga.toListModel(counter, percent)

app/src/main/java/org/koitharu/kotatsu/list/ui/ListModeBottomSheet.kt

@@ -49,6 +49,9 @@ class ListModeBottomSheet :
 	}
 
 	override fun onButtonChecked(group: MaterialButtonToggleGroup?, checkedId: Int, isChecked: Boolean) {
+		if (!isChecked) {
+			return
+		}
 		val mode = when (checkedId) {
 			R.id.button_list -> ListMode.LIST
 			R.id.button_list_detailed -> ListMode.DETAILED_LIST

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

@@ -1,7 +1,11 @@
 package org.koitharu.kotatsu.list.ui
 
 import android.os.Bundle
-import android.view.*
+import android.view.LayoutInflater
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
 import android.view.ViewGroup.MarginLayoutParams
 import androidx.annotation.CallSuper
 import androidx.appcompat.view.ActionMode
@@ -15,7 +19,6 @@ import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
 import coil.ImageLoader
 import com.google.android.material.snackbar.Snackbar
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import kotlinx.coroutines.launch
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.domain.reverseAsync
@@ -42,13 +45,23 @@ import org.koitharu.kotatsu.list.ui.adapter.MangaListListener
 import org.koitharu.kotatsu.list.ui.model.ListHeader
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.list.ui.model.MangaItemModel
+import org.koitharu.kotatsu.main.ui.MainActivity
 import org.koitharu.kotatsu.main.ui.owners.AppBarOwner
 import org.koitharu.kotatsu.main.ui.owners.BottomNavOwner
-import org.koitharu.kotatsu.main.ui.MainActivity
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.reader.ui.ReaderActivity
+import org.koitharu.kotatsu.search.ui.MangaListActivity
 import org.koitharu.kotatsu.utils.ShareHelper
-import org.koitharu.kotatsu.utils.ext.*
+import org.koitharu.kotatsu.utils.ext.addMenuProvider
+import org.koitharu.kotatsu.utils.ext.clearItemDecorations
+import org.koitharu.kotatsu.utils.ext.getDisplayMessage
+import org.koitharu.kotatsu.utils.ext.getThemeColor
+import org.koitharu.kotatsu.utils.ext.measureHeight
+import org.koitharu.kotatsu.utils.ext.resolveDp
+import org.koitharu.kotatsu.utils.ext.scaleUpActivityOptionsOf
+import org.koitharu.kotatsu.utils.ext.viewLifecycleScope
+import javax.inject.Inject
 
 @AndroidEntryPoint
 abstract class MangaListFragment :
@@ -138,6 +151,20 @@ abstract class MangaListFragment :
 		return selectionController?.onItemLongClick(item.id) ?: false
 	}
 
+	override fun onReadClick(manga: Manga, view: View) {
+		if (selectionController?.onItemClick(manga.id) != true) {
+			val intent = ReaderActivity.newIntent(context ?: return, manga)
+			startActivity(intent, scaleUpActivityOptionsOf(view).toBundle())
+		}
+	}
+
+	override fun onTagClick(manga: Manga, tag: MangaTag, view: View) {
+		if (selectionController?.onItemClick(manga.id) != true) {
+			val intent = MangaListActivity.newIntent(context ?: return, setOf(tag))
+			startActivity(intent)
+		}
+	}
+
 	@CallSuper
 	override fun onRefresh() {
 		binding.swipeRefreshLayout.isRefreshing = true
@@ -251,12 +278,14 @@ abstract class MangaListFragment :
 					)
 					addItemDecoration(decoration)
 				}
+
 				ListMode.DETAILED_LIST -> {
 					layoutManager = FitHeightLinearLayoutManager(context)
 					val spacing = resources.getDimensionPixelOffset(R.dimen.list_spacing)
 					updatePadding(left = spacing, right = spacing)
 					addItemDecoration(SpacingItemDecoration(spacing))
 				}
+
 				ListMode.GRID -> {
 					layoutManager = FitHeightGridLayoutManager(context, checkNotNull(spanResolver).spanCount).also {
 						it.spanSizeLookup = spanSizeLookup
@@ -284,21 +313,25 @@ abstract class MangaListFragment :
 				selectionController?.addAll(ids)
 				true
 			}
+
 			R.id.action_share -> {
 				ShareHelper(requireContext()).shareMangaLinks(selectedItems)
 				mode.finish()
 				true
 			}
+
 			R.id.action_favourite -> {
 				FavouriteCategoriesBottomSheet.show(childFragmentManager, selectedItems)
 				mode.finish()
 				true
 			}
+
 			R.id.action_save -> {
 				DownloadService.confirmAndStart(requireContext(), selectedItems)
 				mode.finish()
 				true
 			}
+
 			else -> false
 		}
 	}

app/src/main/java/org/koitharu/kotatsu/list/ui/MangaListViewModel.kt

@@ -1,26 +1,29 @@
 package org.koitharu.kotatsu.list.ui
 
 import androidx.lifecycle.LiveData
-import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.plus
 import org.koitharu.kotatsu.base.ui.BaseViewModel
 import org.koitharu.kotatsu.base.ui.util.ReversibleAction
 import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.core.prefs.ListMode
 import org.koitharu.kotatsu.core.prefs.observeAsFlow
 import org.koitharu.kotatsu.core.prefs.observeAsLiveData
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.parsers.model.MangaTag
 import org.koitharu.kotatsu.utils.SingleLiveEvent
+import org.koitharu.kotatsu.utils.asFlowLiveData
 
 abstract class MangaListViewModel(
 	private val settings: AppSettings,
 ) : BaseViewModel() {
 
 	abstract val content: LiveData<List<ListModel>>
-	val listMode = MutableLiveData<ListMode>()
+	protected val listModeFlow = settings.observeAsFlow(AppSettings.KEY_LIST_MODE) { listMode }
+		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Lazily, settings.listMode)
+	val listMode = listModeFlow.asFlowLiveData(viewModelScope.coroutineContext)
 	val onActionDone = SingleLiveEvent<ReversibleAction>()
 	val gridScale = settings.observeAsLiveData(
 		context = viewModelScope.coroutineContext + Dispatchers.Default,
@@ -30,13 +33,6 @@ abstract class MangaListViewModel(
 
 	open fun onUpdateFilter(tags: Set<MangaTag>) = Unit
 
-	protected fun createListModeFlow() = settings.observeAsFlow(AppSettings.KEY_LIST_MODE) { listMode }
-		.onEach {
-			if (listMode.value != it) {
-				listMode.postValue(it)
-			}
-		}
-
 	abstract fun onRefresh()
 
 	abstract fun onRetry()

app/src/main/java/org/koitharu/kotatsu/list/ui/MangaSelectionDecoration.kt

@@ -22,11 +22,12 @@ open class MangaSelectionDecoration(context: Context) : AbstractSelectionItemDec
 
 	protected val paint = Paint(Paint.ANTI_ALIAS_FLAG)
 	protected val checkIcon = ContextCompat.getDrawable(context, materialR.drawable.ic_mtrl_checked_circle)
-	protected val iconOffset = context.resources.getDimensionPixelOffset(R.dimen.grid_spacing_outer)
+	protected val iconOffset = context.resources.getDimensionPixelOffset(R.dimen.card_indicator_offset)
+	protected val iconSize = context.resources.getDimensionPixelOffset(R.dimen.card_indicator_size)
 	protected val strokeColor = context.getThemeColor(materialR.attr.colorPrimary, Color.RED)
 	protected val fillColor = ColorUtils.setAlphaComponent(
 		ColorUtils.blendARGB(strokeColor, context.getThemeColor(materialR.attr.colorSurface), 0.8f),
-		0x74
+		0x74,
 	)
 	protected val defaultRadius = context.resources.getDimension(R.dimen.list_selector_corner)
 
@@ -65,11 +66,11 @@ open class MangaSelectionDecoration(context: Context) : AbstractSelectionItemDec
 				setBounds(
 					(bounds.left + iconOffset).toInt(),
 					(bounds.top + iconOffset).toInt(),
-					(bounds.left + iconOffset + intrinsicWidth).toInt(),
+					(bounds.left + iconOffset + iconSize).toInt(),
-					(bounds.top + iconOffset + intrinsicHeight).toInt(),
+					(bounds.top + iconOffset + iconSize).toInt(),
 				)
 				draw(canvas)
 			}
 		}
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/list/ui/adapter/MangaDetailsClickListener.kt

@@ -0,0 +1,13 @@
+package org.koitharu.kotatsu.list.ui.adapter
+
+import android.view.View
+import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaTag
+
+interface MangaDetailsClickListener : OnListItemClickListener<Manga> {
+
+	fun onReadClick(manga: Manga, view: View)
+
+	fun onTagClick(manga: Manga, tag: MangaTag, view: View)
+}

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

@@ -1,34 +1,52 @@
 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.base.ui.list.OnListItemClickListener
+import org.koitharu.kotatsu.base.ui.widgets.ChipsView
 import org.koitharu.kotatsu.databinding.ItemMangaListDetailsBinding
 import org.koitharu.kotatsu.history.domain.PROGRESS_NONE
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.list.ui.model.MangaListDetailedModel
-import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaTag
-import org.koitharu.kotatsu.utils.ext.*
+import org.koitharu.kotatsu.utils.ext.disposeImageRequest
+import org.koitharu.kotatsu.utils.ext.enqueueWith
+import org.koitharu.kotatsu.utils.ext.newImageRequest
+import org.koitharu.kotatsu.utils.ext.referer
+import org.koitharu.kotatsu.utils.ext.textAndVisible
 import org.koitharu.kotatsu.utils.image.CoverSizeResolver
 
 fun mangaListDetailedItemAD(
 	coil: ImageLoader,
 	lifecycleOwner: LifecycleOwner,
-	clickListener: OnListItemClickListener<Manga>,
+	clickListener: MangaDetailsClickListener,
 ) = adapterDelegateViewBinding<MangaListDetailedModel, ListModel, ItemMangaListDetailsBinding>(
 	{ inflater, parent -> ItemMangaListDetailsBinding.inflate(inflater, parent, false) },
 ) {
 	var badge: BadgeDrawable? = null
 
-	itemView.setOnClickListener {
+	val listenerAdapter = object : View.OnClickListener, View.OnLongClickListener, ChipsView.OnChipClickListener {
-		clickListener.onItemClick(item.manga, it)
+		override fun onClick(v: View) = when (v.id) {
-	}
+			R.id.button_read -> clickListener.onReadClick(item.manga, v)
-	itemView.setOnLongClickListener {
+			else -> clickListener.onItemClick(item.manga, v)
-		clickListener.onItemLongClick(item.manga, it)
+		}
+
+		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)
+	binding.buttonRead.setOnClickListener(listenerAdapter)
+	binding.chipsTags.onChipClickListener = listenerAdapter
 
 	bind { payloads ->
 		binding.textViewTitle.text = item.title
@@ -44,8 +62,9 @@ fun mangaListDetailedItemAD(
 			lifecycle(lifecycleOwner)
 			enqueueWith(coil)
 		}
-		binding.textViewRating.textAndVisible = item.rating
+		binding.chipsTags.setChips(item.tags)
-		binding.textViewTags.text = item.tags
+		binding.ratingBar.isVisible = item.manga.hasRating
+		binding.ratingBar.rating = binding.ratingBar.numStars * item.manga.rating
 		badge = itemView.bindBadge(badge, item.counter)
 	}
 

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

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

app/src/main/java/org/koitharu/kotatsu/list/ui/model/ListModelConversionExt.kt

@@ -1,8 +1,7 @@
 package org.koitharu.kotatsu.list.ui.model
 
-import java.net.SocketTimeoutException
-import java.net.UnknownHostException
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.base.ui.widgets.ChipsView
 import org.koitharu.kotatsu.core.exceptions.CloudFlareProtectedException
 import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
 import org.koitharu.kotatsu.core.prefs.ListMode
@@ -11,6 +10,8 @@ import org.koitharu.kotatsu.list.domain.ListExtraProvider
 import org.koitharu.kotatsu.parsers.exception.AuthRequiredException
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.utils.ext.ifZero
+import java.net.SocketTimeoutException
+import java.net.UnknownHostException
 
 fun Manga.toListModel(counter: Int, progress: Float) = MangaListModel(
 	id = id,
@@ -26,12 +27,11 @@ fun Manga.toListDetailedModel(counter: Int, progress: Float) = MangaListDetailed
 	id = id,
 	title = title,
 	subtitle = altTitle,
-	rating = if (hasRating) String.format("%.1f", rating * 5) else null,
-	tags = tags.joinToString(", ") { it.title },
 	coverUrl = coverUrl,
 	manga = this,
 	counter = counter,
 	progress = progress,
+	tags = tags.map { ChipsView.ChipModel(0, it.title, false, false, it) },
 )
 
 fun Manga.toGridModel(counter: Int, progress: Float) = MangaGridModel(
@@ -69,9 +69,11 @@ suspend fun <C : MutableCollection<in MangaItemModel>> List<Manga>.toUi(
 	ListMode.LIST -> mapTo(destination) {
 		it.toListModel(extraProvider.getCounter(it.id), extraProvider.getProgress(it.id))
 	}
+
 	ListMode.DETAILED_LIST -> mapTo(destination) {
 		it.toListDetailedModel(extraProvider.getCounter(it.id), extraProvider.getProgress(it.id))
 	}
+
 	ListMode.GRID -> mapTo(destination) {
 		it.toGridModel(extraProvider.getCounter(it.id), extraProvider.getProgress(it.id))
 	}
@@ -95,5 +97,6 @@ private fun getErrorIcon(error: Throwable) = when (error) {
 	is UnknownHostException,
 	is SocketTimeoutException,
 	-> R.drawable.ic_plug_large
+
 	else -> R.drawable.ic_error_large
 }

app/src/main/java/org/koitharu/kotatsu/list/ui/model/MangaListDetailedModel.kt

@@ -1,15 +1,15 @@
 package org.koitharu.kotatsu.list.ui.model
 
+import org.koitharu.kotatsu.base.ui.widgets.ChipsView
 import org.koitharu.kotatsu.parsers.model.Manga
 
 data class MangaListDetailedModel(
 	override val id: Long,
 	override val title: String,
 	val subtitle: String?,
-	val tags: String,
 	override val coverUrl: String,
-	val rating: String?,
 	override val manga: Manga,
 	override val counter: Int,
 	override val progress: Float,
-) : MangaItemModel
+	val tags: List<ChipsView.ChipModel>,
+) : MangaItemModel

app/src/main/java/org/koitharu/kotatsu/local/data/CbzFetcher.kt

@@ -23,10 +23,7 @@ class CbzFetcher(
 		val zip = ZipFile(uri.schemeSpecificPart)
 		val entry = zip.getEntry(uri.fragment)
 		val ext = MimeTypeMap.getFileExtensionFromUrl(entry.name)
-		val bufferedSource = ExtraCloseableBufferedSource(
+		val bufferedSource = zip.getInputStream(entry).source().withExtraCloseable(zip).buffer()
-			zip.getInputStream(entry).source().buffer(),
-			zip,
-		)
 		SourceResult(
 			source = ImageSource(
 				source = bufferedSource,
@@ -50,4 +47,4 @@ class CbzFetcher(
 	}
 
 	class CbzMetadata(val uri: Uri) : ImageSource.Metadata()
-}
+}

app/src/main/java/org/koitharu/kotatsu/local/data/ExtraCloseableBufferedSource.kt

@@ -1,18 +0,0 @@
-package org.koitharu.kotatsu.local.data
-
-import okhttp3.internal.closeQuietly
-import okio.BufferedSource
-import okio.Closeable
-
-class ExtraCloseableBufferedSource(
-	private val delegate: BufferedSource,
-	vararg closeable: Closeable,
-) : BufferedSource by delegate {
-
-	private val extraCloseable = closeable
-
-	override fun close() {
-		delegate.close()
-		extraCloseable.forEach { x -> x.closeQuietly() }
-	}
-}

app/src/main/java/org/koitharu/kotatsu/local/data/ExtraCloseableSource.kt

@@ -0,0 +1,21 @@
+package org.koitharu.kotatsu.local.data
+
+import okhttp3.internal.closeQuietly
+import okio.Closeable
+import okio.Source
+
+private class ExtraCloseableSource(
+	private val delegate: Source,
+	private val extraCloseable: Closeable,
+) : Source by delegate {
+
+	override fun close() {
+		try {
+			delegate.close()
+		} finally {
+			extraCloseable.closeQuietly()
+		}
+	}
+}
+
+fun Source.withExtraCloseable(closeable: Closeable): Source = ExtraCloseableSource(this, closeable)

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

@@ -21,7 +21,7 @@ class PagesCache @Inject constructor(@ApplicationContext context: Context) {
 
 	private val cacheDir = checkNotNull(findSuitableDir(context)) {
 		val dirs = (context.externalCacheDirs + context.cacheDir).joinToString(";") {
-			it.absolutePath
+			it?.absolutePath.toString()
 		}
 		"Cannot find any suitable directory for PagesCache: [$dirs]"
 	}
@@ -60,6 +60,6 @@ private fun createDiskLruCacheSafe(dir: File, size: Long): DiskLruCache {
 private fun findSuitableDir(context: Context): File? {
 	val dirs = context.externalCacheDirs + context.cacheDir
 	return dirs.firstNotNullOfOrNull {
-		it.subdir(CacheDir.PAGES.dir).takeIfWriteable()
+		it?.subdir(CacheDir.PAGES.dir)?.takeIfWriteable()
 	}
 }

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

@@ -4,14 +4,16 @@ import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.asFlow
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
-import java.io.IOException
+import kotlinx.coroutines.CancellationException
-import java.util.*
+import kotlinx.coroutines.Dispatchers
-import javax.inject.Inject
+import kotlinx.coroutines.Job
-import kotlinx.coroutines.*
+import kotlinx.coroutines.cancelAndJoin
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.widgets.ChipsView
 import org.koitharu.kotatsu.core.prefs.AppSettings
@@ -20,7 +22,11 @@ import org.koitharu.kotatsu.history.domain.HistoryRepository
 import org.koitharu.kotatsu.history.domain.PROGRESS_NONE
 import org.koitharu.kotatsu.list.domain.ListExtraProvider
 import org.koitharu.kotatsu.list.ui.MangaListViewModel
-import org.koitharu.kotatsu.list.ui.model.*
+import org.koitharu.kotatsu.list.ui.model.EmptyState
+import org.koitharu.kotatsu.list.ui.model.ListHeader2
+import org.koitharu.kotatsu.list.ui.model.LoadingState
+import org.koitharu.kotatsu.list.ui.model.toErrorState
+import org.koitharu.kotatsu.list.ui.model.toUi
 import org.koitharu.kotatsu.local.domain.LocalMangaRepository
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaTag
@@ -30,6 +36,9 @@ import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
+import java.io.IOException
+import java.util.LinkedList
+import javax.inject.Inject
 
 @HiltViewModel
 class LocalListViewModel @Inject constructor(
@@ -48,7 +57,7 @@ class LocalListViewModel @Inject constructor(
 
 	override val content = combine(
 		mangaList,
-		createListModeFlow(),
+		listModeFlow,
 		sortOrder.asFlow(),
 		selectedTags,
 		listError,
@@ -181,7 +190,11 @@ class LocalListViewModel @Inject constructor(
 	}
 
 	override suspend fun getCounter(mangaId: Long): Int {
-		return trackingRepository.getNewChaptersCount(mangaId)
+		return if (settings.isTrackerEnabled) {
+			trackingRepository.getNewChaptersCount(mangaId)
+		} else {
+			0
+		}
 	}
 
 	override suspend fun getProgress(mangaId: Long): Float {

app/src/main/java/org/koitharu/kotatsu/main/ui/MainActionButtonBehavior.kt

@@ -0,0 +1,39 @@
+package org.koitharu.kotatsu.main.ui
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.View
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+import androidx.core.view.ViewCompat
+import com.google.android.material.floatingactionbutton.ExtendedFloatingActionButton
+import org.koitharu.kotatsu.base.ui.util.ShrinkOnScrollBehavior
+import org.koitharu.kotatsu.base.ui.widgets.SlidingBottomNavigationView
+
+class MainActionButtonBehavior : ShrinkOnScrollBehavior {
+
+	constructor() : super()
+	constructor(context: Context?, attrs: AttributeSet?) : super(context, attrs)
+
+	override fun layoutDependsOn(
+		parent: CoordinatorLayout,
+		child: ExtendedFloatingActionButton,
+		dependency: View
+	): Boolean {
+		return dependency is SlidingBottomNavigationView || super.layoutDependsOn(parent, child, dependency)
+	}
+
+	override fun onDependentViewChanged(
+		parent: CoordinatorLayout,
+		child: ExtendedFloatingActionButton,
+		dependency: View
+	): Boolean {
+		val bottom = child.bottom
+		val bottomLine = parent.height
+		return if (bottom > bottomLine) {
+			ViewCompat.offsetTopAndBottom(child, bottomLine - bottom)
+			true
+		} else {
+			false
+		}
+	}
+}

app/src/main/java/org/koitharu/kotatsu/main/ui/MainActivity.kt

@@ -41,6 +41,7 @@ import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseActivity
 import org.koitharu.kotatsu.base.ui.widgets.SlidingBottomNavigationView
 import org.koitharu.kotatsu.databinding.ActivityMainBinding
+import org.koitharu.kotatsu.details.service.MangaPrefetchService
 import org.koitharu.kotatsu.details.ui.DetailsActivity
 import org.koitharu.kotatsu.main.ui.owners.AppBarOwner
 import org.koitharu.kotatsu.main.ui.owners.BottomNavOwner
@@ -116,11 +117,13 @@ class MainActivity :
 		binding.navRail?.headerView?.setOnClickListener(this)
 		binding.searchView.isVoiceSearchEnabled = voiceInputLauncher.resolve(this, null) != null
 
-		onBackPressedDispatcher.addCallback(ExitCallback(this, binding.container))
 		navigationDelegate = MainNavigationDelegate(checkNotNull(bottomNav ?: binding.navRail), supportFragmentManager)
 		navigationDelegate.addOnFragmentChangedListener(this)
 		navigationDelegate.onCreate(savedInstanceState)
 
+		onBackPressedDispatcher.addCallback(navigationDelegate)
+		onBackPressedDispatcher.addCallback(ExitCallback(this, binding.container))
+
 		if (savedInstanceState == null) {
 			onFirstStart()
 		}
@@ -334,6 +337,7 @@ class MainActivity :
 				TrackWorker.setup(applicationContext)
 				SuggestionsWorker.setup(applicationContext)
 			}
+			MangaPrefetchService.prefetchLast(this@MainActivity)
 			requestNotificationsPermission()
 		}
 	}

app/src/main/java/org/koitharu/kotatsu/main/ui/MainNavigationDelegate.kt

@@ -2,6 +2,7 @@ package org.koitharu.kotatsu.main.ui
 
 import android.os.Bundle
 import android.view.MenuItem
+import androidx.activity.OnBackPressedCallback
 import androidx.annotation.IdRes
 import androidx.core.view.iterator
 import androidx.fragment.app.Fragment
@@ -21,7 +22,7 @@ private const val TAG_PRIMARY = "primary"
 class MainNavigationDelegate(
 	private val navBar: NavigationBarView,
 	private val fragmentManager: FragmentManager,
-) : NavigationBarView.OnItemSelectedListener, NavigationBarView.OnItemReselectedListener {
+) : OnBackPressedCallback(false), NavigationBarView.OnItemSelectedListener, NavigationBarView.OnItemReselectedListener {
 
 	private val listeners = LinkedList<OnFragmentChangedListener>()
 
@@ -38,14 +39,25 @@ class MainNavigationDelegate(
 	}
 
 	override fun onNavigationItemReselected(item: MenuItem) {
-		val fragment = fragmentManager.findFragmentByTag(TAG_PRIMARY) as? RecyclerViewOwner ?: return
+		val fragment = fragmentManager.findFragmentByTag(TAG_PRIMARY)
+		if (fragment == null || fragment !is RecyclerViewOwner || fragment.view == null) {
+			return
+		}
 		val recyclerView = fragment.recyclerView
 		recyclerView.smoothScrollToPosition(0)
 	}
 
+	override fun handleOnBackPressed() {
+		navBar.selectedItemId = R.id.nav_shelf
+	}
+
 	fun onCreate(savedInstanceState: Bundle?) {
 		primaryFragment?.let {
 			onFragmentChanged(it, fromUser = false)
+			val itemId = getItemId(it)
+			if (navBar.selectedItemId != itemId) {
+				navBar.selectedItemId = itemId
+			}
 		} ?: onNavigationItemSelected(navBar.selectedItemId)
 	}
 
@@ -92,6 +104,14 @@ class MainNavigationDelegate(
 		return true
 	}
 
+	private fun getItemId(fragment: Fragment) = when (fragment) {
+		is ShelfFragment -> R.id.nav_shelf
+		is ExploreFragment -> R.id.nav_explore
+		is FeedFragment -> R.id.nav_feed
+		is ToolsFragment -> R.id.nav_tools
+		else -> 0
+	}
+
 	private fun setPrimaryFragment(fragment: Fragment) {
 		fragmentManager.beginTransaction()
 			.setReorderingAllowed(true)
@@ -102,6 +122,7 @@ class MainNavigationDelegate(
 	}
 
 	private fun onFragmentChanged(fragment: Fragment, fromUser: Boolean) {
+		isEnabled = fragment !is ShelfFragment
 		listeners.forEach { it.onFragmentChanged(fragment, fromUser) }
 	}
 

app/src/main/java/org/koitharu/kotatsu/reader/domain/PageLoader.kt

@@ -1,12 +1,10 @@
 package org.koitharu.kotatsu.reader.domain
 
-import android.content.Context
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
 import android.net.Uri
 import androidx.collection.LongSparseArray
 import androidx.collection.set
-import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
@@ -31,7 +29,6 @@ import org.koitharu.kotatsu.parsers.model.MangaPage
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.util.await
 import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
-import org.koitharu.kotatsu.utils.ext.connectivityManager
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 import org.koitharu.kotatsu.utils.ext.withProgress
 import org.koitharu.kotatsu.utils.progress.ProgressDeferred
@@ -50,13 +47,11 @@ class PageLoader @Inject constructor(
 	private val okHttp: OkHttpClient,
 	private val cache: PagesCache,
 	private val settings: AppSettings,
-	@ApplicationContext context: Context,
 	private val mangaRepositoryFactory: MangaRepository.Factory,
 ) : Closeable {
 
 	val loaderScope = CoroutineScope(SupervisorJob() + InternalErrorHandler() + Dispatchers.Default)
 
-	private val connectivityManager = context.connectivityManager
 	private val tasks = LongSparseArray<ProgressDeferred<File, Float>>()
 	private val convertLock = Mutex()
 	private var repository: MangaRepository? = null
@@ -73,7 +68,7 @@ class PageLoader @Inject constructor(
 	}
 
 	fun isPrefetchApplicable(): Boolean {
-		return repository is RemoteMangaRepository && settings.isPagesPreloadAllowed(connectivityManager)
+		return repository is RemoteMangaRepository && settings.isPagesPreloadEnabled()
 	}
 
 	fun prefetch(pages: List<ReaderPage>) {

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

@@ -63,7 +63,7 @@ class RemoteListViewModel @AssistedInject constructor(
 
 	override val content = combine(
 		mangaList,
-		createListModeFlow(),
+		listModeFlow,
 		createHeaderFlow(),
 		listError,
 		hasNextPage,

app/src/main/java/org/koitharu/kotatsu/scrobbling/ScrobblingModule.kt

@@ -1,24 +1,34 @@
 package org.koitharu.kotatsu.scrobbling
 
+import android.content.Context
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
 import dagger.multibindings.ElementsIntoSet
-import javax.inject.Singleton
 import okhttp3.OkHttpClient
+import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.core.db.MangaDatabase
+import org.koitharu.kotatsu.core.network.CurlLoggingInterceptor
+import org.koitharu.kotatsu.scrobbling.anilist.data.AniListAuthenticator
+import org.koitharu.kotatsu.scrobbling.anilist.data.AniListInterceptor
+import org.koitharu.kotatsu.scrobbling.anilist.data.AniListRepository
+import org.koitharu.kotatsu.scrobbling.anilist.domain.AniListScrobbler
+import org.koitharu.kotatsu.scrobbling.data.ScrobblerStorage
 import org.koitharu.kotatsu.scrobbling.domain.Scrobbler
 import org.koitharu.kotatsu.scrobbling.mal.data.MALAuthenticator
 import org.koitharu.kotatsu.scrobbling.mal.data.MALInterceptor
 import org.koitharu.kotatsu.scrobbling.mal.data.MALRepository
 import org.koitharu.kotatsu.scrobbling.mal.data.MALStorage
 import org.koitharu.kotatsu.scrobbling.mal.domain.MALScrobbler
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerType
 import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriAuthenticator
 import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriInterceptor
 import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriRepository
-import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriStorage
 import org.koitharu.kotatsu.scrobbling.shikimori.domain.ShikimoriScrobbler
+import javax.inject.Singleton
 
 @Module
 @InstallIn(SingletonComponent::class)
@@ -27,13 +37,16 @@ object ScrobblingModule {
 	@Provides
 	@Singleton
 	fun provideShikimoriRepository(
-		storage: ShikimoriStorage,
+		@ScrobblerType(ScrobblerService.SHIKIMORI) storage: ScrobblerStorage,
 		database: MangaDatabase,
 		authenticator: ShikimoriAuthenticator,
 	): ShikimoriRepository {
 		val okHttp = OkHttpClient.Builder().apply {
 			authenticator(authenticator)
 			addInterceptor(ShikimoriInterceptor(storage))
+			if (BuildConfig.DEBUG) {
+				addInterceptor(CurlLoggingInterceptor())
+			}
 		}.build()
 		return ShikimoriRepository(okHttp, storage, database)
 	}
@@ -52,10 +65,42 @@ object ScrobblingModule {
 		return MALRepository(okHttp, storage, database)
 	}
 
+	@Provides
+	@Singleton
+	fun provideAniListRepository(
+		@ScrobblerType(ScrobblerService.ANILIST) storage: ScrobblerStorage,
+		database: MangaDatabase,
+		authenticator: AniListAuthenticator,
+	): AniListRepository {
+		val okHttp = OkHttpClient.Builder().apply {
+			authenticator(authenticator)
+			addInterceptor(AniListInterceptor(storage))
+			if (BuildConfig.DEBUG) {
+				addInterceptor(CurlLoggingInterceptor())
+			}
+		}.build()
+		return AniListRepository(okHttp, storage, database)
+	}
+
+	@Provides
+	@Singleton
+	@ScrobblerType(ScrobblerService.ANILIST)
+	fun provideAniListStorage(
+		@ApplicationContext context: Context,
+	): ScrobblerStorage = ScrobblerStorage(context, ScrobblerService.ANILIST)
+
+	@Provides
+	@Singleton
+	@ScrobblerType(ScrobblerService.SHIKIMORI)
+	fun provideShikimoriStorage(
+		@ApplicationContext context: Context,
+	): ScrobblerStorage = ScrobblerStorage(context, ScrobblerService.SHIKIMORI)
+
 	@Provides
 	@ElementsIntoSet
 	fun provideScrobblers(
 		shikimoriScrobbler: ShikimoriScrobbler,
+		aniListScrobbler: AniListScrobbler,
 		malScrobbler: MALScrobbler,
-	): Set<@JvmSuppressWildcards Scrobbler> = setOf(shikimoriScrobbler, malScrobbler)
+	): Set<@JvmSuppressWildcards Scrobbler> = setOf(shikimoriScrobbler, aniListScrobbler, malScrobbler)
 }

app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListAuthenticator.kt

@@ -0,0 +1,56 @@
+package org.koitharu.kotatsu.scrobbling.anilist.data
+
+import kotlinx.coroutines.runBlocking
+import okhttp3.Authenticator
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.Route
+import org.koitharu.kotatsu.BuildConfig
+import org.koitharu.kotatsu.core.network.CommonHeaders
+import org.koitharu.kotatsu.scrobbling.data.ScrobblerStorage
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerType
+import javax.inject.Inject
+import javax.inject.Provider
+
+class AniListAuthenticator @Inject constructor(
+	@ScrobblerType(ScrobblerService.ANILIST) private val storage: ScrobblerStorage,
+	private val repositoryProvider: Provider<AniListRepository>,
+) : Authenticator {
+
+	override fun authenticate(route: Route?, response: Response): Request? {
+		val accessToken = storage.accessToken ?: return null
+		if (!isRequestWithAccessToken(response)) {
+			return null
+		}
+		synchronized(this) {
+			val newAccessToken = storage.accessToken ?: return null
+			if (accessToken != newAccessToken) {
+				return newRequestWithAccessToken(response.request, newAccessToken)
+			}
+			val updatedAccessToken = refreshAccessToken() ?: return null
+			return newRequestWithAccessToken(response.request, updatedAccessToken)
+		}
+	}
+
+	private fun isRequestWithAccessToken(response: Response): Boolean {
+		val header = response.request.header(CommonHeaders.AUTHORIZATION)
+		return header?.startsWith("Bearer") == true
+	}
+
+	private fun newRequestWithAccessToken(request: Request, accessToken: String): Request {
+		return request.newBuilder()
+			.header(CommonHeaders.AUTHORIZATION, "Bearer $accessToken")
+			.build()
+	}
+
+	private fun refreshAccessToken(): String? = runCatching {
+		val repository = repositoryProvider.get()
+		runBlocking { repository.authorize(null) }
+		return storage.accessToken
+	}.onFailure {
+		if (BuildConfig.DEBUG) {
+			it.printStackTrace()
+		}
+	}.getOrNull()
+}

app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListInterceptor.kt

@@ -0,0 +1,24 @@
+package org.koitharu.kotatsu.scrobbling.anilist.data
+
+import okhttp3.Interceptor
+import okhttp3.Response
+import org.koitharu.kotatsu.core.network.CommonHeaders
+import org.koitharu.kotatsu.scrobbling.data.ScrobblerStorage
+
+private const val JSON = "application/json"
+
+class AniListInterceptor(private val storage: ScrobblerStorage) : Interceptor {
+
+	override fun intercept(chain: Interceptor.Chain): Response {
+		val sourceRequest = chain.request()
+		val request = sourceRequest.newBuilder()
+		request.header(CommonHeaders.CONTENT_TYPE, JSON)
+		request.header(CommonHeaders.ACCEPT, JSON)
+		if (!sourceRequest.url.pathSegments.contains("oauth")) {
+			storage.accessToken?.let {
+				request.header(CommonHeaders.AUTHORIZATION, "Bearer $it")
+			}
+		}
+		return chain.proceed(request.build())
+	}
+}

app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/AniListRepository.kt

@@ -0,0 +1,263 @@
+package org.koitharu.kotatsu.scrobbling.anilist.data
+
+import okhttp3.FormBody
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import org.json.JSONObject
+import org.koitharu.kotatsu.BuildConfig
+import org.koitharu.kotatsu.core.db.MangaDatabase
+import org.koitharu.kotatsu.parsers.exception.GraphQLException
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.util.await
+import org.koitharu.kotatsu.parsers.util.json.getStringOrNull
+import org.koitharu.kotatsu.parsers.util.json.mapJSON
+import org.koitharu.kotatsu.parsers.util.parseJson
+import org.koitharu.kotatsu.parsers.util.toIntUp
+import org.koitharu.kotatsu.scrobbling.data.ScrobblerRepository
+import org.koitharu.kotatsu.scrobbling.data.ScrobblerStorage
+import org.koitharu.kotatsu.scrobbling.data.ScrobblingEntity
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerManga
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerMangaInfo
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser
+import kotlin.math.roundToInt
+
+private const val REDIRECT_URI = "kotatsu://anilist-auth"
+private const val BASE_URL = "https://anilist.co/api/v2/"
+private const val ENDPOINT = "https://graphql.anilist.co"
+private const val MANGA_PAGE_SIZE = 10
+private const val REQUEST_QUERY = "query"
+private const val REQUEST_MUTATION = "mutation"
+private const val KEY_SCORE_FORMAT = "score_format"
+
+class AniListRepository(
+	private val okHttp: OkHttpClient,
+	private val storage: ScrobblerStorage,
+	private val db: MangaDatabase,
+) : ScrobblerRepository {
+
+	override val oauthUrl: String
+		get() = "${BASE_URL}oauth/authorize?client_id=${BuildConfig.ANILIST_CLIENT_ID}&" +
+			"redirect_uri=${REDIRECT_URI}&response_type=code"
+
+	override val isAuthorized: Boolean
+		get() = storage.accessToken != null
+
+	private val shrinkRegex = Regex("\\t+")
+
+	override suspend fun authorize(code: String?) {
+		val body = FormBody.Builder()
+		body.add("client_id", BuildConfig.ANILIST_CLIENT_ID)
+		body.add("client_secret", BuildConfig.ANILIST_CLIENT_SECRET)
+		if (code != null) {
+			body.add("grant_type", "authorization_code")
+			body.add("redirect_uri", REDIRECT_URI)
+			body.add("code", code)
+		} else {
+			body.add("grant_type", "refresh_token")
+			body.add("refresh_token", checkNotNull(storage.refreshToken))
+		}
+		val request = Request.Builder()
+			.post(body.build())
+			.url("${BASE_URL}oauth/token")
+		val response = okHttp.newCall(request.build()).await().parseJson()
+		storage.accessToken = response.getString("access_token")
+		storage.refreshToken = response.getString("refresh_token")
+	}
+
+	override suspend fun loadUser(): ScrobblerUser {
+		val response = doRequest(
+			REQUEST_QUERY,
+			"""
+			AniChartUser {
+				user {
+					id
+					name
+					avatar {
+						medium
+					}
+					mediaListOptions {
+						scoreFormat
+					}
+				}
+			}
+		""",
+		)
+		val jo = response.getJSONObject("data").getJSONObject("AniChartUser").getJSONObject("user")
+		storage[KEY_SCORE_FORMAT] = jo.getJSONObject("mediaListOptions").getString("scoreFormat")
+		return AniListUser(jo).also { storage.user = it }
+	}
+
+	override val cachedUser: ScrobblerUser?
+		get() {
+			return storage.user
+		}
+
+	override suspend fun unregister(mangaId: Long) {
+		return db.scrobblingDao.delete(ScrobblerService.ANILIST.id, mangaId)
+	}
+
+	override fun logout() {
+		storage.clear()
+	}
+
+	override suspend fun findManga(query: String, offset: Int): List<ScrobblerManga> {
+		val page = (offset / MANGA_PAGE_SIZE.toFloat()).toIntUp() + 1
+		val response = doRequest(
+			REQUEST_QUERY,
+			"""
+			Page(page: $page, perPage: ${MANGA_PAGE_SIZE}) {
+				media(type: MANGA, sort: SEARCH_MATCH, search: ${JSONObject.quote(query)}) {
+					id
+					title {
+						userPreferred
+						native
+					}
+					coverImage {
+						medium
+					}
+					siteUrl
+				}
+			}
+		""",
+		)
+		val data = response.getJSONObject("data").getJSONObject("Page").getJSONArray("media")
+		return data.mapJSON { ScrobblerManga(it) }
+	}
+
+	override suspend fun createRate(mangaId: Long, scrobblerMangaId: Long) {
+		val response = doRequest(
+			REQUEST_MUTATION,
+			"""
+				SaveMediaListEntry(mediaId: $scrobblerMangaId) {
+					id
+					mediaId
+					status
+					notes
+					score
+					progress
+				}
+			""",
+		)
+		saveRate(response.getJSONObject("data").getJSONObject("SaveMediaListEntry"), mangaId)
+	}
+
+	override suspend fun updateRate(rateId: Int, mangaId: Long, chapter: MangaChapter) {
+		val response = doRequest(
+			REQUEST_MUTATION,
+			"""
+				SaveMediaListEntry(id: $rateId, progress: ${chapter.number}) {
+					id
+					mediaId
+					status
+					notes
+					score
+					progress
+				}
+			""",
+		)
+		saveRate(response.getJSONObject("data").getJSONObject("SaveMediaListEntry"), mangaId)
+	}
+
+	override suspend fun updateRate(rateId: Int, mangaId: Long, rating: Float, status: String?, comment: String?) {
+		val scoreRaw = (rating * 100f).roundToInt()
+		val statusString = status?.let { ", status: $it" }.orEmpty()
+		val notesString = comment?.let { ", notes: ${JSONObject.quote(it)}" }.orEmpty()
+		val response = doRequest(
+			REQUEST_MUTATION,
+			"""
+				SaveMediaListEntry(id: $rateId, scoreRaw: $scoreRaw$statusString$notesString) {
+					id
+					mediaId
+					status
+					notes
+					score
+					progress
+				}
+			""",
+		)
+		saveRate(response.getJSONObject("data").getJSONObject("SaveMediaListEntry"), mangaId)
+	}
+
+	override suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo {
+		val response = doRequest(
+			REQUEST_QUERY,
+			"""
+			Media(id: $id) {
+				id
+				title {
+					userPreferred
+				}
+				coverImage {
+					large
+				}
+				description
+				siteUrl
+			}
+			""",
+		)
+		return ScrobblerMangaInfo(response.getJSONObject("data").getJSONObject("Media"))
+	}
+
+	private suspend fun saveRate(json: JSONObject, mangaId: Long) {
+		val scoreFormat = ScoreFormat.of(storage[KEY_SCORE_FORMAT])
+		val entity = ScrobblingEntity(
+			scrobbler = ScrobblerService.ANILIST.id,
+			id = json.getInt("id"),
+			mangaId = mangaId,
+			targetId = json.getLong("mediaId"),
+			status = json.getString("status"),
+			chapter = json.getInt("progress"),
+			comment = json.getString("notes"),
+			rating = scoreFormat.normalize(json.getDouble("score").toFloat()),
+		)
+		db.scrobblingDao.upsert(entity)
+	}
+
+	private fun ScrobblerManga(json: JSONObject): ScrobblerManga {
+		val title = json.getJSONObject("title")
+		return ScrobblerManga(
+			id = json.getLong("id"),
+			name = title.getString("userPreferred"),
+			altName = title.getStringOrNull("native"),
+			cover = json.getJSONObject("coverImage").getString("medium"),
+			url = json.getString("siteUrl"),
+		)
+	}
+
+	private fun ScrobblerMangaInfo(json: JSONObject) = ScrobblerMangaInfo(
+		id = json.getLong("id"),
+		name = json.getJSONObject("title").getString("userPreferred"),
+		cover = json.getJSONObject("coverImage").getString("large"),
+		url = json.getString("siteUrl"),
+		descriptionHtml = json.getString("description"),
+	)
+
+	private fun AniListUser(json: JSONObject) = ScrobblerUser(
+		id = json.getLong("id"),
+		nickname = json.getString("name"),
+		avatar = json.getJSONObject("avatar").getString("medium"),
+		service = ScrobblerService.ANILIST,
+	)
+
+	private suspend fun doRequest(type: String, payload: String): JSONObject {
+		val body = JSONObject()
+		body.put("query", "$type { ${payload.shrink()} }")
+		val mediaType = "application/json; charset=utf-8".toMediaType()
+		val requestBody = body.toString().toRequestBody(mediaType)
+		val request = Request.Builder()
+			.post(requestBody)
+			.url(ENDPOINT)
+		val json = okHttp.newCall(request.build()).await().parseJson()
+		json.optJSONArray("errors")?.let {
+			if (it.length() != 0) {
+				throw GraphQLException(it)
+			}
+		}
+		return json
+	}
+
+	private fun String.shrink() = replace(shrinkRegex, " ")
+}

app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/data/ScoreFormat.kt

@@ -0,0 +1,27 @@
+package org.koitharu.kotatsu.scrobbling.anilist.data
+
+import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
+
+enum class ScoreFormat {
+
+	POINT_100, POINT_10_DECIMAL, POINT_10, POINT_5, POINT_3;
+
+	fun normalize(score: Float): Float = when (this) {
+		POINT_100 -> score / 100f
+		POINT_10_DECIMAL,
+		POINT_10 -> score / 10f
+
+		POINT_5 -> score / 5f
+		POINT_3 -> score / 3f
+	}
+
+	companion object {
+
+		fun of(rawValue: String?): ScoreFormat {
+			rawValue ?: return POINT_10_DECIMAL
+			return runCatching { valueOf(rawValue) }
+				.onFailure { it.printStackTraceDebug() }
+				.getOrDefault(POINT_10_DECIMAL)
+		}
+	}
+}

app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/domain/AniListScrobbler.kt

@@ -0,0 +1,42 @@
+package org.koitharu.kotatsu.scrobbling.anilist.domain
+
+import org.koitharu.kotatsu.core.db.MangaDatabase
+import org.koitharu.kotatsu.scrobbling.anilist.data.AniListRepository
+import org.koitharu.kotatsu.scrobbling.domain.Scrobbler
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblingStatus
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class AniListScrobbler @Inject constructor(
+	private val repository: AniListRepository,
+	db: MangaDatabase,
+) : Scrobbler(db, ScrobblerService.ANILIST, repository) {
+
+	init {
+		statuses[ScrobblingStatus.PLANNED] = "PLANNING"
+		statuses[ScrobblingStatus.READING] = "CURRENT"
+		statuses[ScrobblingStatus.RE_READING] = "REPEATING"
+		statuses[ScrobblingStatus.COMPLETED] = "COMPLETED"
+		statuses[ScrobblingStatus.ON_HOLD] = "PAUSED"
+		statuses[ScrobblingStatus.DROPPED] = "DROPPED"
+	}
+
+	override suspend fun updateScrobblingInfo(
+		mangaId: Long,
+		rating: Float,
+		status: ScrobblingStatus?,
+		comment: String?,
+	) {
+		val entity = db.scrobblingDao.find(scrobblerService.id, mangaId)
+		requireNotNull(entity) { "Scrobbling info for manga $mangaId not found" }
+		repository.updateRate(
+			rateId = entity.id,
+			mangaId = entity.mangaId,
+			rating = rating,
+			status = statuses[status],
+			comment = comment,
+		)
+	}
+}

app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsFragment.kt

@@ -0,0 +1,86 @@
+package org.koitharu.kotatsu.scrobbling.anilist.ui
+
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import android.view.View
+import androidx.preference.Preference
+import coil.ImageLoader
+import coil.request.ImageRequest
+import coil.transform.CircleCropTransformation
+import dagger.hilt.android.AndroidEntryPoint
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.base.ui.BasePreferenceFragment
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser
+import org.koitharu.kotatsu.utils.PreferenceIconTarget
+import org.koitharu.kotatsu.utils.ext.assistedViewModels
+import org.koitharu.kotatsu.utils.ext.enqueueWith
+import org.koitharu.kotatsu.utils.ext.withArgs
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class AniListSettingsFragment : BasePreferenceFragment(R.string.anilist) {
+
+	@Inject
+	lateinit var coil: ImageLoader
+
+	@Inject
+	lateinit var viewModelFactory: AniListSettingsViewModel.Factory
+
+	private val viewModel by assistedViewModels {
+		viewModelFactory.create(arguments?.getString(ARG_AUTH_CODE))
+	}
+
+	override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
+		addPreferencesFromResource(R.xml.pref_anilist)
+	}
+
+	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+		super.onViewCreated(view, savedInstanceState)
+		viewModel.user.observe(viewLifecycleOwner, this::onUserChanged)
+	}
+
+	override fun onPreferenceTreeClick(preference: Preference): Boolean {
+		return when (preference.key) {
+			KEY_USER -> openAuthorization()
+			KEY_LOGOUT -> {
+				viewModel.logout()
+				true
+			}
+
+			else -> super.onPreferenceTreeClick(preference)
+		}
+	}
+
+	private fun onUserChanged(user: ScrobblerUser?) {
+		val pref = findPreference<Preference>(KEY_USER) ?: return
+		pref.isSelectable = user == null
+		pref.title = user?.nickname ?: getString(R.string.sign_in)
+		ImageRequest.Builder(requireContext())
+			.data(user?.avatar)
+			.transformations(CircleCropTransformation())
+			.target(PreferenceIconTarget(pref))
+			.enqueueWith(coil)
+		findPreference<Preference>(KEY_LOGOUT)?.isVisible = user != null
+	}
+
+	private fun openAuthorization(): Boolean {
+		return runCatching {
+			val intent = Intent(Intent.ACTION_VIEW)
+			intent.data = Uri.parse(viewModel.authorizationUrl)
+			startActivity(intent)
+		}.isSuccess
+	}
+
+	companion object {
+
+		private const val KEY_USER = "al_user"
+		private const val KEY_LOGOUT = "al_logout"
+
+		private const val ARG_AUTH_CODE = "auth_code"
+
+		fun newInstance(authCode: String?) = AniListSettingsFragment().withArgs(1) {
+			putString(ARG_AUTH_CODE, authCode)
+		}
+	}
+}

app/src/main/java/org/koitharu/kotatsu/scrobbling/anilist/ui/AniListSettingsViewModel.kt

@@ -0,0 +1,57 @@
+package org.koitharu.kotatsu.scrobbling.anilist.ui
+
+import androidx.lifecycle.MutableLiveData
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import kotlinx.coroutines.Dispatchers
+import org.koitharu.kotatsu.base.ui.BaseViewModel
+import org.koitharu.kotatsu.scrobbling.anilist.data.AniListRepository
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser
+
+class AniListSettingsViewModel @AssistedInject constructor(
+	private val repository: AniListRepository,
+	@Assisted authCode: String?,
+) : BaseViewModel() {
+
+	val authorizationUrl: String
+		get() = repository.oauthUrl
+
+	val user = MutableLiveData<ScrobblerUser?>()
+
+	init {
+		if (authCode != null) {
+			authorize(authCode)
+		} else {
+			loadUser()
+		}
+	}
+
+	fun logout() {
+		launchJob(Dispatchers.Default) {
+			repository.logout()
+			user.postValue(null)
+		}
+	}
+
+	private fun loadUser() = launchJob(Dispatchers.Default) {
+		val userModel = if (repository.isAuthorized) {
+			repository.cachedUser?.let(user::postValue)
+			repository.loadUser()
+		} else {
+			null
+		}
+		user.postValue(userModel)
+	}
+
+	private fun authorize(code: String) = launchJob(Dispatchers.Default) {
+		repository.authorize(code)
+		user.postValue(repository.loadUser())
+	}
+
+	@AssistedFactory
+	interface Factory {
+
+		fun create(authCode: String?): AniListSettingsViewModel
+	}
+}

app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblerRepository.kt

@@ -0,0 +1,33 @@
+package org.koitharu.kotatsu.scrobbling.data
+
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerManga
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerMangaInfo
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser
+
+interface ScrobblerRepository {
+
+	val oauthUrl: String
+
+	val isAuthorized: Boolean
+
+	val cachedUser: ScrobblerUser?
+
+	suspend fun authorize(code: String?)
+
+	suspend fun loadUser(): ScrobblerUser
+
+	fun logout()
+
+	suspend fun unregister(mangaId: Long)
+
+	suspend fun findManga(query: String, offset: Int): List<ScrobblerManga>
+
+	suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo
+
+	suspend fun createRate(mangaId: Long, scrobblerMangaId: Long)
+
+	suspend fun updateRate(rateId: Int, mangaId: Long, chapter: MangaChapter)
+
+	suspend fun updateRate(rateId: Int, mangaId: Long, rating: Float, status: String?, comment: String?)
+}

app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblerStorage.kt

@@ -0,0 +1,58 @@
+package org.koitharu.kotatsu.scrobbling.data
+
+import android.content.Context
+import androidx.core.content.edit
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser
+
+private const val KEY_ACCESS_TOKEN = "access_token"
+private const val KEY_REFRESH_TOKEN = "refresh_token"
+private const val KEY_USER = "user"
+
+class ScrobblerStorage(context: Context, service: ScrobblerService) {
+
+	private val prefs = context.getSharedPreferences(service.name, Context.MODE_PRIVATE)
+
+	var accessToken: String?
+		get() = prefs.getString(KEY_ACCESS_TOKEN, null)
+		set(value) = prefs.edit { putString(KEY_ACCESS_TOKEN, value) }
+
+	var refreshToken: String?
+		get() = prefs.getString(KEY_REFRESH_TOKEN, null)
+		set(value) = prefs.edit { putString(KEY_REFRESH_TOKEN, value) }
+
+	var user: ScrobblerUser?
+		get() = prefs.getString(KEY_USER, null)?.let {
+			val lines = it.lines()
+			if (lines.size != 4) {
+				return@let null
+			}
+			ScrobblerUser(
+				id = lines[0].toLong(),
+				nickname = lines[1],
+				avatar = lines[2],
+				service = ScrobblerService.valueOf(lines[3]),
+			)
+		}
+		set(value) = prefs.edit {
+			if (value == null) {
+				remove(KEY_USER)
+				return@edit
+			}
+			val str = buildString {
+				appendLine(value.id)
+				appendLine(value.nickname)
+				appendLine(value.avatar)
+				appendLine(value.service.name)
+			}
+			putString(KEY_USER, str)
+		}
+
+	operator fun get(key: String): String? = prefs.getString(key, null)
+
+	operator fun set(key: String, value: String?) = prefs.edit { putString(key, value) }
+
+	fun clear() = prefs.edit {
+		clear()
+	}
+}

app/src/main/java/org/koitharu/kotatsu/scrobbling/data/ScrobblingDao.kt

@@ -12,12 +12,9 @@ abstract class ScrobblingDao {
 	@Query("SELECT * FROM scrobblings WHERE scrobbler = :scrobbler AND manga_id = :mangaId")
 	abstract fun observe(scrobbler: Int, mangaId: Long): Flow<ScrobblingEntity?>
 
-	@Insert(onConflict = OnConflictStrategy.REPLACE)
+	@Upsert
-	abstract suspend fun insert(entity: ScrobblingEntity)
+	abstract suspend fun upsert(entity: ScrobblingEntity)
-
-	@Update
-	abstract suspend fun update(entity: ScrobblingEntity)
 
 	@Query("DELETE FROM scrobblings WHERE scrobbler = :scrobbler AND manga_id = :mangaId")
 	abstract suspend fun delete(scrobbler: Int, mangaId: Long)
-}
+}

app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/Scrobbler.kt

@@ -7,6 +7,7 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 import org.koitharu.kotatsu.core.db.MangaDatabase
 import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.scrobbling.data.ScrobblerRepository
 import org.koitharu.kotatsu.scrobbling.data.ScrobblingEntity
 import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerManga
 import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerMangaInfo
@@ -21,18 +22,27 @@ import java.util.EnumMap
 abstract class Scrobbler(
 	protected val db: MangaDatabase,
 	val scrobblerService: ScrobblerService,
+	private val repository: ScrobblerRepository,
 ) {
 
 	private val infoCache = LongSparseArray<ScrobblerMangaInfo>()
 	protected val statuses = EnumMap<ScrobblingStatus, String>(ScrobblingStatus::class.java)
 
-	abstract val isAvailable: Boolean
+	val isAvailable: Boolean
+		get() = repository.isAuthorized
 
-	abstract suspend fun findManga(query: String, offset: Int): List<ScrobblerManga>
+	suspend fun findManga(query: String, offset: Int): List<ScrobblerManga> {
+		return repository.findManga(query, offset)
+	}
 
-	abstract suspend fun linkManga(mangaId: Long, targetId: Long)
+	suspend fun linkManga(mangaId: Long, targetId: Long) {
+		repository.createRate(mangaId, targetId)
+	}
 
-	abstract suspend fun scrobble(mangaId: Long, chapter: MangaChapter)
+	suspend fun scrobble(mangaId: Long, chapter: MangaChapter) {
+		val entity = db.scrobblingDao.find(scrobblerService.id, mangaId) ?: return
+		repository.updateRate(entity.id, entity.mangaId, chapter)
+	}
 
 	suspend fun getScrobblingInfoOrNull(mangaId: Long): ScrobblingInfo? {
 		val entity = db.scrobblingDao.find(scrobblerService.id, mangaId) ?: return null
@@ -46,9 +56,13 @@ abstract class Scrobbler(
 			.map { it?.toScrobblingInfo(mangaId) }
 	}
 
-	abstract suspend fun unregisterScrobbling(mangaId: Long)
+	suspend fun unregisterScrobbling(mangaId: Long) {
+		repository.unregister(mangaId)
+	}
 
-	protected abstract suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo
+	protected suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo {
+		return repository.getMangaInfo(id)
+	}
 
 	private suspend fun ScrobblingEntity.toScrobblingInfo(mangaId: Long): ScrobblingInfo? {
 		val mangaInfo = infoCache.getOrElse(targetId) {

app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/model/ScrobblerService.kt

@@ -11,5 +11,6 @@ enum class ScrobblerService(
 ) {
 
 	SHIKIMORI(1, R.string.shikimori, R.drawable.ic_shikimori),
-	MAL(2, R.string.mal, R.drawable.ic_mal)
+	ANILIST(2, R.string.anilist, R.drawable.ic_anilist),
+	MAL(3, R.string.mal, R.drawable.ic_mal)
 }

app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/model/ScrobblerType.kt

@@ -0,0 +1,8 @@
+package org.koitharu.kotatsu.scrobbling.domain.model
+
+import javax.inject.Qualifier
+
+@Qualifier
+annotation class ScrobblerType(
+	val service: ScrobblerService
+)

app/src/main/java/org/koitharu/kotatsu/scrobbling/domain/model/ScrobblerUser.kt

@@ -1,34 +1,22 @@
-package org.koitharu.kotatsu.scrobbling.shikimori.data.model
+package org.koitharu.kotatsu.scrobbling.domain.model
 
-import org.json.JSONObject
+class ScrobblerUser(
-
-class ShikimoriUser(
 	val id: Long,
 	val nickname: String,
 	val avatar: String,
+	val service: ScrobblerService,
 ) {
 
-	constructor(json: JSONObject) : this(
-		id = json.getLong("id"),
-		nickname = json.getString("nickname"),
-		avatar = json.getString("avatar"),
-	)
-
-	fun toJson() = JSONObject().apply {
-		put("id", id)
-		put("nickname", nickname)
-		put("avatar", avatar)
-	}
-
 	override fun equals(other: Any?): Boolean {
 		if (this === other) return true
 		if (javaClass != other?.javaClass) return false
 
-		other as ShikimoriUser
+		other as ScrobblerUser
 
 		if (id != other.id) return false
 		if (nickname != other.nickname) return false
 		if (avatar != other.avatar) return false
+		if (service != other.service) return false
 
 		return true
 	}
@@ -37,6 +25,7 @@ class ShikimoriUser(
 		var result = id.hashCode()
 		result = 31 * result + nickname.hashCode()
 		result = 31 * result + avatar.hashCode()
+		result = 31 * result + service.hashCode()
 		return result
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriAuthenticator.kt

@@ -1,7 +1,5 @@
 package org.koitharu.kotatsu.scrobbling.shikimori.data
 
-import javax.inject.Inject
-import javax.inject.Provider
 import kotlinx.coroutines.runBlocking
 import okhttp3.Authenticator
 import okhttp3.Request
@@ -9,9 +7,14 @@ import okhttp3.Response
 import okhttp3.Route
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.core.network.CommonHeaders
+import org.koitharu.kotatsu.scrobbling.data.ScrobblerStorage
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerType
+import javax.inject.Inject
+import javax.inject.Provider
 
 class ShikimoriAuthenticator @Inject constructor(
-	private val storage: ShikimoriStorage,
+	@ScrobblerType(ScrobblerService.SHIKIMORI) private val storage: ScrobblerStorage,
 	private val repositoryProvider: Provider<ShikimoriRepository>,
 ) : Authenticator {
 

app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriInterceptor.kt

@@ -4,10 +4,11 @@ import okhttp3.Interceptor
 import okhttp3.Response
 import okio.IOException
 import org.koitharu.kotatsu.core.network.CommonHeaders
+import org.koitharu.kotatsu.scrobbling.data.ScrobblerStorage
 
 private const val USER_AGENT_SHIKIMORI = "Kotatsu"
 
-class ShikimoriInterceptor(private val storage: ShikimoriStorage) : Interceptor {
+class ShikimoriInterceptor(private val storage: ScrobblerStorage) : Interceptor {
 
 	override fun intercept(chain: Interceptor.Chain): Response {
 		val sourceRequest = chain.request()

app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriRepository.kt

@@ -14,11 +14,13 @@ import org.koitharu.kotatsu.parsers.util.json.mapJSON
 import org.koitharu.kotatsu.parsers.util.parseJson
 import org.koitharu.kotatsu.parsers.util.parseJsonArray
 import org.koitharu.kotatsu.parsers.util.toAbsoluteUrl
+import org.koitharu.kotatsu.scrobbling.data.ScrobblerRepository
+import org.koitharu.kotatsu.scrobbling.data.ScrobblerStorage
 import org.koitharu.kotatsu.scrobbling.data.ScrobblingEntity
 import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerManga
 import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerMangaInfo
 import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService
-import org.koitharu.kotatsu.scrobbling.shikimori.data.model.ShikimoriUser
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser
 import org.koitharu.kotatsu.utils.ext.toRequestBody
 
 private const val REDIRECT_URI = "kotatsu://shikimori-auth"
@@ -27,18 +29,18 @@ private const val MANGA_PAGE_SIZE = 10
 
 class ShikimoriRepository(
 	private val okHttp: OkHttpClient,
-	private val storage: ShikimoriStorage,
+	private val storage: ScrobblerStorage,
 	private val db: MangaDatabase,
-) {
+) : ScrobblerRepository {
 
-	val oauthUrl: String
+	override val oauthUrl: String
 		get() = "${BASE_URL}oauth/authorize?client_id=${BuildConfig.SHIKIMORI_CLIENT_ID}&" +
 			"redirect_uri=$REDIRECT_URI&response_type=code&scope="
 
-	val isAuthorized: Boolean
+	override val isAuthorized: Boolean
 		get() = storage.accessToken != null
 
-	suspend fun authorize(code: String?) {
+	override suspend fun authorize(code: String?) {
 		val body = FormBody.Builder()
 		body.add("client_id", BuildConfig.SHIKIMORI_CLIENT_ID)
 		body.add("client_secret", BuildConfig.SHIKIMORI_CLIENT_SECRET)
@@ -58,7 +60,7 @@ class ShikimoriRepository(
 		storage.refreshToken = response.getString("refresh_token")
 	}
 
-	suspend fun loadUser(): ShikimoriUser {
+	override suspend fun loadUser(): ScrobblerUser {
 		val request = Request.Builder()
 			.get()
 			.url("${BASE_URL}api/users/whoami")
@@ -66,19 +68,20 @@ class ShikimoriRepository(
 		return ShikimoriUser(response).also { storage.user = it }
 	}
 
-	fun getCachedUser(): ShikimoriUser? {
+	override val cachedUser: ScrobblerUser?
-		return storage.user
+		get() {
-	}
+			return storage.user
+		}
 
-	suspend fun unregister(mangaId: Long) {
+	override suspend fun unregister(mangaId: Long) {
 		return db.scrobblingDao.delete(ScrobblerService.SHIKIMORI.id, mangaId)
 	}
 
-	fun logout() {
+	override fun logout() {
 		storage.clear()
 	}
 
-	suspend fun findManga(query: String, offset: Int): List<ScrobblerManga> {
+	override suspend fun findManga(query: String, offset: Int): List<ScrobblerManga> {
 		val page = offset / MANGA_PAGE_SIZE
 		val pageOffset = offset % MANGA_PAGE_SIZE
 		val url = BASE_URL.toHttpUrl().newBuilder()
@@ -95,8 +98,8 @@ class ShikimoriRepository(
 		return if (pageOffset != 0) list.drop(pageOffset) else list
 	}
 
-	suspend fun createRate(mangaId: Long, shikiMangaId: Long) {
+	override suspend fun createRate(mangaId: Long, shikiMangaId: Long) {
-		val user = getCachedUser() ?: loadUser()
+		val user = cachedUser ?: loadUser()
 		val payload = JSONObject()
 		payload.put(
 			"user_rate",
@@ -116,7 +119,7 @@ class ShikimoriRepository(
 		saveRate(response, mangaId)
 	}
 
-	suspend fun updateRate(rateId: Int, mangaId: Long, chapter: MangaChapter) {
+	override suspend fun updateRate(rateId: Int, mangaId: Long, chapter: MangaChapter) {
 		val payload = JSONObject()
 		payload.put(
 			"user_rate",
@@ -135,7 +138,7 @@ class ShikimoriRepository(
 		saveRate(response, mangaId)
 	}
 
-	suspend fun updateRate(rateId: Int, mangaId: Long, rating: Float, status: String?, comment: String?) {
+	override suspend fun updateRate(rateId: Int, mangaId: Long, rating: Float, status: String?, comment: String?) {
 		val payload = JSONObject()
 		payload.put(
 			"user_rate",
@@ -160,7 +163,7 @@ class ShikimoriRepository(
 		saveRate(response, mangaId)
 	}
 
-	suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo {
+	override suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo {
 		val request = Request.Builder()
 			.get()
 			.url("${BASE_URL}api/mangas/$id")
@@ -179,7 +182,7 @@ class ShikimoriRepository(
 			comment = json.getString("text"),
 			rating = json.getDouble("score").toFloat() / 10f,
 		)
-		db.scrobblingDao.insert(entity)
+		db.scrobblingDao.upsert(entity)
 	}
 
 	private fun ScrobblerManga(json: JSONObject) = ScrobblerManga(
@@ -197,4 +200,11 @@ class ShikimoriRepository(
 		url = json.getString("url").toAbsoluteUrl("shikimori.one"),
 		descriptionHtml = json.getString("description_html"),
 	)
+
+	private fun ShikimoriUser(json: JSONObject) = ScrobblerUser(
+		id = json.getLong("id"),
+		nickname = json.getString("nickname"),
+		avatar = json.getString("avatar"),
+		service = ScrobblerService.SHIKIMORI,
+	)
 }

app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/data/ShikimoriStorage.kt

@@ -1,40 +0,0 @@
-package org.koitharu.kotatsu.scrobbling.shikimori.data
-
-import android.content.Context
-import androidx.core.content.edit
-import dagger.hilt.android.qualifiers.ApplicationContext
-import org.json.JSONObject
-import org.koitharu.kotatsu.scrobbling.shikimori.data.model.ShikimoriUser
-import javax.inject.Inject
-import javax.inject.Singleton
-
-private const val PREF_NAME = "shikimori"
-private const val KEY_ACCESS_TOKEN = "access_token"
-private const val KEY_REFRESH_TOKEN = "refresh_token"
-private const val KEY_USER = "user"
-
-@Singleton
-class ShikimoriStorage @Inject constructor(@ApplicationContext context: Context) {
-
-	private val prefs = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE)
-
-	var accessToken: String?
-		get() = prefs.getString(KEY_ACCESS_TOKEN, null)
-		set(value) = prefs.edit { putString(KEY_ACCESS_TOKEN, value) }
-
-	var refreshToken: String?
-		get() = prefs.getString(KEY_REFRESH_TOKEN, null)
-		set(value) = prefs.edit { putString(KEY_REFRESH_TOKEN, value) }
-
-	var user: ShikimoriUser?
-		get() = prefs.getString(KEY_USER, null)?.let {
-			ShikimoriUser(JSONObject(it))
-		}
-		set(value) = prefs.edit {
-			putString(KEY_USER, value?.toJson()?.toString())
-		}
-
-	fun clear() = prefs.edit {
-		clear()
-	}
-}

app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/domain/ShikimoriScrobbler.kt

@@ -1,15 +1,12 @@
 package org.koitharu.kotatsu.scrobbling.shikimori.domain
 
-import javax.inject.Inject
-import javax.inject.Singleton
 import org.koitharu.kotatsu.core.db.MangaDatabase
-import org.koitharu.kotatsu.parsers.model.MangaChapter
 import org.koitharu.kotatsu.scrobbling.domain.Scrobbler
-import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerManga
-import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerMangaInfo
 import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerService
 import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblingStatus
 import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriRepository
+import javax.inject.Inject
+import javax.inject.Singleton
 
 private const val RATING_MAX = 10f
 
@@ -17,7 +14,7 @@ private const val RATING_MAX = 10f
 class ShikimoriScrobbler @Inject constructor(
 	private val repository: ShikimoriRepository,
 	db: MangaDatabase,
-) : Scrobbler(db, ScrobblerService.SHIKIMORI) {
+) : Scrobbler(db, ScrobblerService.SHIKIMORI, repository) {
 
 	init {
 		statuses[ScrobblingStatus.PLANNED] = "planned"
@@ -28,22 +25,6 @@ class ShikimoriScrobbler @Inject constructor(
 		statuses[ScrobblingStatus.DROPPED] = "dropped"
 	}
 
-	override val isAvailable: Boolean
-		get() = repository.isAuthorized
-
-	override suspend fun findManga(query: String, offset: Int): List<ScrobblerManga> {
-		return repository.findManga(query, offset)
-	}
-
-	override suspend fun linkManga(mangaId: Long, targetId: Long) {
-		repository.createRate(mangaId, targetId)
-	}
-
-	override suspend fun scrobble(mangaId: Long, chapter: MangaChapter) {
-		val entity = db.scrobblingDao.find(scrobblerService.id, mangaId) ?: return
-		repository.updateRate(entity.id, entity.mangaId, chapter)
-	}
-
 	override suspend fun updateScrobblingInfo(
 		mangaId: Long,
 		rating: Float,
@@ -60,12 +41,4 @@ class ShikimoriScrobbler @Inject constructor(
 			comment = comment,
 		)
 	}
-
-	override suspend fun unregisterScrobbling(mangaId: Long) {
-		repository.unregister(mangaId)
-	}
-
-	override suspend fun getMangaInfo(id: Long): ScrobblerMangaInfo {
-		return repository.getMangaInfo(id)
-	}
 }

app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/ui/ShikimoriSettingsFragment.kt

@@ -9,14 +9,14 @@ import coil.ImageLoader
 import coil.request.ImageRequest
 import coil.transform.CircleCropTransformation
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BasePreferenceFragment
-import org.koitharu.kotatsu.scrobbling.shikimori.data.model.ShikimoriUser
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser
 import org.koitharu.kotatsu.utils.PreferenceIconTarget
 import org.koitharu.kotatsu.utils.ext.assistedViewModels
 import org.koitharu.kotatsu.utils.ext.enqueueWith
 import org.koitharu.kotatsu.utils.ext.withArgs
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class ShikimoriSettingsFragment : BasePreferenceFragment(R.string.shikimori) {
@@ -47,11 +47,12 @@ class ShikimoriSettingsFragment : BasePreferenceFragment(R.string.shikimori) {
 				viewModel.logout()
 				true
 			}
+
 			else -> super.onPreferenceTreeClick(preference)
 		}
 	}
 
-	private fun onUserChanged(user: ShikimoriUser?) {
+	private fun onUserChanged(user: ScrobblerUser?) {
 		val pref = findPreference<Preference>(KEY_USER) ?: return
 		pref.isSelectable = user == null
 		pref.title = user?.nickname ?: getString(R.string.sign_in)

app/src/main/java/org/koitharu/kotatsu/scrobbling/shikimori/ui/ShikimoriSettingsViewModel.kt

@@ -6,8 +6,8 @@ import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import kotlinx.coroutines.Dispatchers
 import org.koitharu.kotatsu.base.ui.BaseViewModel
+import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerUser
 import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriRepository
-import org.koitharu.kotatsu.scrobbling.shikimori.data.model.ShikimoriUser
 
 class ShikimoriSettingsViewModel @AssistedInject constructor(
 	private val repository: ShikimoriRepository,
@@ -17,7 +17,7 @@ class ShikimoriSettingsViewModel @AssistedInject constructor(
 	val authorizationUrl: String
 		get() = repository.oauthUrl
 
-	val user = MutableLiveData<ShikimoriUser?>()
+	val user = MutableLiveData<ScrobblerUser?>()
 
 	init {
 		if (authCode != null) {
@@ -36,7 +36,7 @@ class ShikimoriSettingsViewModel @AssistedInject constructor(
 
 	private fun loadUser() = launchJob(Dispatchers.Default) {
 		val userModel = if (repository.isAuthorized) {
-			repository.getCachedUser()?.let(user::postValue)
+			repository.cachedUser?.let(user::postValue)
 			repository.loadUser()
 		} else {
 			null

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

@@ -39,7 +39,7 @@ class SearchViewModel @AssistedInject constructor(
 
 	override val content = combine(
 		mangaList,
-		createListModeFlow(),
+		listModeFlow,
 		listError,
 		hasNextPage,
 	) { list, mode, error, hasNext ->

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

@@ -12,7 +12,6 @@ import androidx.core.graphics.Insets
 import androidx.core.view.updatePadding
 import coil.ImageLoader
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseActivity
 import org.koitharu.kotatsu.base.ui.list.ListSelectionController
@@ -27,11 +26,15 @@ import org.koitharu.kotatsu.list.ui.adapter.MangaListListener
 import org.koitharu.kotatsu.list.ui.model.ListHeader
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.reader.ui.ReaderActivity
+import org.koitharu.kotatsu.search.ui.MangaListActivity
 import org.koitharu.kotatsu.search.ui.SearchActivity
 import org.koitharu.kotatsu.search.ui.multi.adapter.MultiSearchAdapter
 import org.koitharu.kotatsu.utils.ShareHelper
 import org.koitharu.kotatsu.utils.ext.assistedViewModels
 import org.koitharu.kotatsu.utils.ext.invalidateNestedItemDecorations
+import org.koitharu.kotatsu.utils.ext.scaleUpActivityOptionsOf
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class MultiSearchActivity :
@@ -110,6 +113,20 @@ class MultiSearchActivity :
 		return selectionController.onItemLongClick(item.id)
 	}
 
+	override fun onReadClick(manga: Manga, view: View) {
+		if (!selectionController.onItemClick(manga.id)) {
+			val intent = ReaderActivity.newIntent(this, manga)
+			startActivity(intent, scaleUpActivityOptionsOf(view).toBundle())
+		}
+	}
+
+	override fun onTagClick(manga: Manga, tag: MangaTag, view: View) {
+		if (!selectionController.onItemClick(manga.id)) {
+			val intent = MangaListActivity.newIntent(this, setOf(tag))
+			startActivity(intent)
+		}
+	}
+
 	override fun onRetryClick(error: Throwable) {
 		viewModel.doSearch(viewModel.query.value.orEmpty())
 	}
@@ -139,16 +156,19 @@ class MultiSearchActivity :
 				mode.finish()
 				true
 			}
+
 			R.id.action_favourite -> {
 				FavouriteCategoriesBottomSheet.show(supportFragmentManager, collectSelectedItems())
 				mode.finish()
 				true
 			}
+
 			R.id.action_save -> {
 				DownloadService.confirmAndStart(this, collectSelectedItems())
 				mode.finish()
 				true
 			}
+
 			else -> false
 		}
 	}

app/src/main/java/org/koitharu/kotatsu/settings/AppearanceSettingsFragment.kt

@@ -1,27 +1,38 @@
 package org.koitharu.kotatsu.settings
 
+import android.content.Context
 import android.content.Intent
 import android.content.SharedPreferences
+import android.net.Uri
+import android.os.Build
 import android.os.Bundle
+import android.provider.Settings
 import android.view.View
 import androidx.appcompat.app.AppCompatDelegate
+import androidx.core.app.LocaleManagerCompat
 import androidx.core.view.postDelayed
 import androidx.preference.ListPreference
 import androidx.preference.Preference
 import androidx.preference.TwoStatePreference
 import com.google.android.material.color.DynamicColors
 import dagger.hilt.android.AndroidEntryPoint
-import java.util.*
-import javax.inject.Inject
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BasePreferenceFragment
 import org.koitharu.kotatsu.base.ui.util.ActivityRecreationHandle
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.prefs.ListMode
 import org.koitharu.kotatsu.parsers.util.names
+import org.koitharu.kotatsu.parsers.util.toTitleCase
 import org.koitharu.kotatsu.settings.protect.ProtectSetupActivity
+import org.koitharu.kotatsu.settings.utils.ActivityListPreference
 import org.koitharu.kotatsu.settings.utils.SliderPreference
+import org.koitharu.kotatsu.utils.ext.getLocalesConfig
+import org.koitharu.kotatsu.utils.ext.map
 import org.koitharu.kotatsu.utils.ext.setDefaultValueCompat
+import org.koitharu.kotatsu.utils.ext.toList
+import java.util.Date
+import java.util.Locale
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class AppearanceSettingsFragment :
@@ -52,7 +63,7 @@ class AppearanceSettingsFragment :
 			entries = entryValues.map { value ->
 				val formattedDate = settings.getDateFormat(value.toString()).format(now)
 				if (value == "") {
-					"${context.getString(R.string.system_default)} ($formattedDate)"
+					getString(R.string.default_s, formattedDate)
 				} else {
 					formattedDate
 				}
@@ -62,6 +73,20 @@ class AppearanceSettingsFragment :
 		}
 		findPreference<TwoStatePreference>(AppSettings.KEY_PROTECT_APP)
 			?.isChecked = !settings.appPassword.isNullOrEmpty()
+		findPreference<ActivityListPreference>(AppSettings.KEY_APP_LOCALE)?.run {
+			initLocalePicker(this)
+			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+				activityIntent = Intent(
+					Settings.ACTION_APP_LOCALE_SETTINGS,
+					Uri.fromParts("package", context.packageName, null),
+				)
+			}
+			summaryProvider = Preference.SummaryProvider<ActivityListPreference> {
+				val locale = AppCompatDelegate.getApplicationLocales().get(0)
+				locale?.getDisplayName(locale)?.toTitleCase(locale) ?: getString(R.string.automatic)
+			}
+			setDefaultValueCompat("")
+		}
 	}
 
 	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
@@ -79,16 +104,23 @@ class AppearanceSettingsFragment :
 			AppSettings.KEY_THEME -> {
 				AppCompatDelegate.setDefaultNightMode(settings.theme)
 			}
+
 			AppSettings.KEY_DYNAMIC_THEME -> {
 				postRestart()
 			}
+
 			AppSettings.KEY_THEME_AMOLED -> {
 				postRestart()
 			}
+
 			AppSettings.KEY_APP_PASSWORD -> {
 				findPreference<TwoStatePreference>(AppSettings.KEY_PROTECT_APP)
 					?.isChecked = !settings.appPassword.isNullOrEmpty()
 			}
+
+			AppSettings.KEY_APP_LOCALE -> {
+				AppCompatDelegate.setApplicationLocales(settings.appLocales)
+			}
 		}
 	}
 
@@ -104,6 +136,7 @@ class AppearanceSettingsFragment :
 				}
 				true
 			}
+
 			else -> super.onPreferenceTreeClick(preference)
 		}
 	}
@@ -113,4 +146,45 @@ class AppearanceSettingsFragment :
 			activityRecreationHandle.recreateAll()
 		}
 	}
+
+	private fun initLocalePicker(preference: ListPreference) {
+		val locales = resources.getLocalesConfig()
+			.toList()
+			.sortedWith(LocaleComparator(preference.context))
+		preference.entries = Array(locales.size + 1) { i ->
+			if (i == 0) {
+				getString(R.string.automatic)
+			} else {
+				val lc = locales[i - 1]
+				lc.getDisplayName(lc).toTitleCase(lc)
+			}
+		}
+		preference.entryValues = Array(locales.size + 1) { i ->
+			if (i == 0) {
+				""
+			} else {
+				locales[i - 1].toLanguageTag()
+			}
+		}
+	}
+
+	private class LocaleComparator(context: Context) : Comparator<Locale> {
+
+		private val deviceLocales = LocaleManagerCompat.getSystemLocales(context)
+			.map { it.language }
+
+		override fun compare(a: Locale, b: Locale): Int {
+			return if (a === b) {
+				0
+			} else {
+				val indexA = deviceLocales.indexOf(a.language)
+				val indexB = deviceLocales.indexOf(b.language)
+				if (indexA == -1 && indexB == -1) {
+					compareValues(a.language, b.language)
+				} else {
+					-2 - (indexA - indexB)
+				}
+			}
+		}
+	}
 }

app/src/main/java/org/koitharu/kotatsu/settings/ContentSettingsFragment.kt

@@ -9,14 +9,13 @@ import androidx.preference.ListPreference
 import androidx.preference.Preference
 import com.google.android.material.snackbar.Snackbar
 import dagger.hilt.android.AndroidEntryPoint
-import java.io.File
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BasePreferenceFragment
 import org.koitharu.kotatsu.base.ui.dialog.StorageSelectDialog
+import org.koitharu.kotatsu.core.cache.ContentCache
 import org.koitharu.kotatsu.core.network.DoHProvider
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.local.data.LocalStorageManager
@@ -26,6 +25,8 @@ import org.koitharu.kotatsu.sync.ui.SyncSettingsIntent
 import org.koitharu.kotatsu.utils.ext.getStorageName
 import org.koitharu.kotatsu.utils.ext.setDefaultValueCompat
 import org.koitharu.kotatsu.utils.ext.viewLifecycleScope
+import java.io.File
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class ContentSettingsFragment :
@@ -36,9 +37,12 @@ class ContentSettingsFragment :
 	@Inject
 	lateinit var storageManager: LocalStorageManager
 
+	@Inject
+	lateinit var contentCache: ContentCache
+
 	override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
 		addPreferencesFromResource(R.xml.pref_content)
-
+		findPreference<Preference>(AppSettings.KEY_PREFETCH_CONTENT)?.isVisible = contentCache.isCachingEnabled
 		findPreference<SliderPreference>(AppSettings.KEY_DOWNLOADS_PARALLELISM)?.run {
 			summary = value.toString()
 			setOnPreferenceChangeListener { preference, newValue ->
@@ -82,11 +86,13 @@ class ContentSettingsFragment :
 			AppSettings.KEY_LOCAL_STORAGE -> {
 				findPreference<Preference>(key)?.bindStorageName()
 			}
+
 			AppSettings.KEY_SUGGESTIONS -> {
 				findPreference<Preference>(AppSettings.KEY_SUGGESTIONS)?.setSummary(
 					if (settings.isSuggestionsEnabled) R.string.enabled else R.string.disabled,
 				)
 			}
+
 			AppSettings.KEY_SOURCES_HIDDEN -> {
 				bindRemoteSourcesSummary()
 			}
@@ -104,6 +110,7 @@ class ContentSettingsFragment :
 					.show()
 				true
 			}
+
 			AppSettings.KEY_SYNC -> {
 				val am = AccountManager.get(requireContext())
 				val accountType = getString(R.string.account_type_sync)
@@ -119,6 +126,7 @@ class ContentSettingsFragment :
 				}
 				true
 			}
+
 			else -> super.onPreferenceTreeClick(preference)
 		}
 	}

app/src/main/java/org/koitharu/kotatsu/settings/HistorySettingsFragment.kt

@@ -17,6 +17,7 @@ import org.koitharu.kotatsu.core.os.ShortcutsUpdater
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.local.data.CacheDir
 import org.koitharu.kotatsu.local.data.LocalStorageManager
+import org.koitharu.kotatsu.scrobbling.anilist.data.AniListRepository
 import org.koitharu.kotatsu.scrobbling.mal.data.MALRepository
 import org.koitharu.kotatsu.scrobbling.shikimori.data.ShikimoriRepository
 import org.koitharu.kotatsu.search.domain.MangaSearchRepository
@@ -41,6 +42,9 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach
 	@Inject
 	lateinit var shikimoriRepository: ShikimoriRepository
 
+	@Inject
+	lateinit var aniListRepository: AniListRepository
+
 	@Inject
 	lateinit var malRepository: MALRepository
 
@@ -80,6 +84,7 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach
 		super.onResume()
 		bindShikimoriSummary()
 		bindMALSummary()
+		bindAniListSummary()
 	}
 
 	override fun onPreferenceTreeClick(preference: Preference): Boolean {
@@ -136,6 +141,15 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach
 				}
 			}
 
+			AppSettings.KEY_ANILIST -> {
+				if (!aniListRepository.isAuthorized) {
+					launchAniListAuth()
+					true
+				} else {
+					super.onPreferenceTreeClick(preference)
+				}
+			}
+
 			else -> super.onPreferenceTreeClick(preference)
 		}
 	}
@@ -201,7 +215,15 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach
 
 	private fun bindShikimoriSummary() {
 		findPreference<Preference>(AppSettings.KEY_SHIKIMORI)?.summary = if (shikimoriRepository.isAuthorized) {
-			getString(R.string.logged_in_as, shikimoriRepository.getCachedUser()?.nickname)
+			getString(R.string.logged_in_as, shikimoriRepository.cachedUser?.nickname)
+		} else {
+			getString(R.string.disabled)
+		}
+	}
+
+	private fun bindAniListSummary() {
+		findPreference<Preference>(AppSettings.KEY_ANILIST)?.summary = if (aniListRepository.isAuthorized) {
+			getString(R.string.logged_in_as, aniListRepository.cachedUser?.nickname)
 		} else {
 			getString(R.string.disabled)
 		}
@@ -234,4 +256,14 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach
 			Snackbar.make(listView, it.getDisplayMessage(resources), Snackbar.LENGTH_LONG).show()
 		}
 	}
+
+	private fun launchAniListAuth() {
+		runCatching {
+			val intent = Intent(Intent.ACTION_VIEW)
+			intent.data = Uri.parse(aniListRepository.oauthUrl)
+			startActivity(intent)
+		}.onFailure {
+			Snackbar.make(listView, it.getDisplayMessage(resources), Snackbar.LENGTH_LONG).show()
+		}
+	}
 }

app/src/main/java/org/koitharu/kotatsu/settings/SettingsActivity.kt

@@ -24,6 +24,7 @@ import org.koitharu.kotatsu.base.ui.util.RecyclerViewOwner
 import org.koitharu.kotatsu.databinding.ActivitySettingsBinding
 import org.koitharu.kotatsu.main.ui.owners.AppBarOwner
 import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.scrobbling.anilist.ui.AniListSettingsFragment
 import org.koitharu.kotatsu.scrobbling.shikimori.ui.ShikimoriSettingsFragment
 import org.koitharu.kotatsu.settings.sources.SourcesSettingsFragment
 import org.koitharu.kotatsu.settings.tracker.TrackerSettingsFragment
@@ -78,6 +79,7 @@ class SettingsActivity :
 			startActivity(intent)
 			true
 		}
+
 		else -> super.onOptionsItemSelected(item)
 	}
 
@@ -132,6 +134,7 @@ class SettingsActivity :
 			ACTION_SOURCE -> SourceSettingsFragment.newInstance(
 				intent.getSerializableExtra(EXTRA_SOURCE) as? MangaSource ?: MangaSource.LOCAL,
 			)
+
 			ACTION_MANAGE_SOURCES -> SourcesSettingsFragment()
 			else -> SettingsHeadersFragment()
 		}
@@ -145,6 +148,9 @@ class SettingsActivity :
 		when (uri?.host) {
 			HOST_SHIKIMORI_AUTH ->
 				return ShikimoriSettingsFragment.newInstance(authCode = uri.getQueryParameter("code"))
+
+			HOST_ANILIST_AUTH ->
+				return AniListSettingsFragment.newInstance(authCode = uri.getQueryParameter("code"))
 		}
 		finishAfterTransition()
 		return null
@@ -162,6 +168,7 @@ class SettingsActivity :
 		private const val EXTRA_SOURCE = "source"
 
 		private const val HOST_SHIKIMORI_AUTH = "shikimori-auth"
+		private const val HOST_ANILIST_AUTH = "anilist-auth"
 
 		fun newIntent(context: Context) = Intent(context, SettingsActivity::class.java)
 

app/src/main/java/org/koitharu/kotatsu/settings/SourceSettingsExt.kt

@@ -4,6 +4,7 @@ import android.view.inputmethod.EditorInfo
 import androidx.preference.EditTextPreference
 import androidx.preference.Preference
 import androidx.preference.PreferenceFragmentCompat
+import androidx.preference.SwitchPreferenceCompat
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.parser.RemoteMangaRepository
 import org.koitharu.kotatsu.parsers.config.ConfigKey
@@ -29,15 +30,22 @@ fun PreferenceFragmentCompat.addPreferencesFromRepository(repository: RemoteMang
 							inputType = EditorInfo.TYPE_CLASS_TEXT or EditorInfo.TYPE_TEXT_VARIATION_URI,
 							hint = key.defaultValue,
 							validator = DomainValidator(),
-						)
+						),
 					)
 					setTitle(R.string.domain)
 					setDialogTitle(R.string.domain)
 				}
 			}
+
+			is ConfigKey.ShowSuspiciousContent -> {
+				SwitchPreferenceCompat(requireContext()).apply {
+					setDefaultValue(key.defaultValue)
+					setTitle(R.string.show_suspicious_content)
+				}
+			}
 		}
 		preference.isIconSpaceReserved = false
 		preference.key = key.key
 		screen.addPreference(preference)
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/settings/about/AboutSettingsFragment.kt

@@ -7,16 +7,24 @@ import androidx.core.net.toUri
 import androidx.fragment.app.viewModels
 import androidx.preference.Preference
 import com.google.android.material.snackbar.Snackbar
+import dagger.hilt.android.AndroidEntryPoint
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BasePreferenceFragment
 import org.koitharu.kotatsu.core.github.AppVersion
+import org.koitharu.kotatsu.core.logs.FileLogger
 import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.utils.ShareHelper
+import javax.inject.Inject
 
+@AndroidEntryPoint
 class AboutSettingsFragment : BasePreferenceFragment(R.string.about) {
 
 	private val viewModel by viewModels<AboutSettingsViewModel>()
 
+	@Inject
+	lateinit var loggers: Set<@JvmSuppressWildcards FileLogger>
+
 	override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
 		addPreferencesFromResource(R.xml.pref_about)
 		findPreference<Preference>(AppSettings.KEY_APP_VERSION)?.run {
@@ -39,10 +47,17 @@ class AboutSettingsFragment : BasePreferenceFragment(R.string.about) {
 				viewModel.checkForUpdates()
 				true
 			}
+
 			AppSettings.KEY_APP_TRANSLATION -> {
 				openLink(getString(R.string.url_weblate), preference.title)
 				true
 			}
+
+			AppSettings.KEY_LOGS_SHARE -> {
+				ShareHelper(preference.context).shareLogs(loggers)
+				true
+			}
+
 			else -> super.onPreferenceTreeClick(preference)
 		}
 	}

app/src/main/java/org/koitharu/kotatsu/settings/about/AppUpdateDialog.kt

@@ -3,22 +3,24 @@ package org.koitharu.kotatsu.settings.about
 import android.content.Context
 import android.content.Intent
 import androidx.core.net.toUri
-import com.google.android.material.R as materialR
+import androidx.core.text.buildSpannedString
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import io.noties.markwon.Markwon
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.github.AppVersion
 import org.koitharu.kotatsu.utils.FileSize
+import com.google.android.material.R as materialR
 
 class AppUpdateDialog(private val context: Context) {
 
 	fun show(version: AppVersion) {
-		val message = buildString {
+		val message = buildSpannedString {
 			append(context.getString(R.string.new_version_s, version.name))
 			appendLine()
 			append(context.getString(R.string.size_s, FileSize.BYTES.format(context, version.apkSize)))
 			appendLine()
 			appendLine()
-			append(version.description)
+			append(Markwon.create(context).toMarkdown(version.description))
 		}
 		MaterialAlertDialogBuilder(
 			context,

app/src/main/java/org/koitharu/kotatsu/settings/backup/BackupObserver.kt

@@ -4,11 +4,11 @@ import android.app.backup.BackupManager
 import android.content.Context
 import androidx.room.InvalidationTracker
 import dagger.hilt.android.qualifiers.ApplicationContext
-import javax.inject.Inject
-import javax.inject.Singleton
 import org.koitharu.kotatsu.core.db.TABLE_FAVOURITES
 import org.koitharu.kotatsu.core.db.TABLE_FAVOURITE_CATEGORIES
 import org.koitharu.kotatsu.core.db.TABLE_HISTORY
+import javax.inject.Inject
+import javax.inject.Singleton
 
 @Singleton
 class BackupObserver @Inject constructor(
@@ -17,7 +17,7 @@ class BackupObserver @Inject constructor(
 
 	private val backupManager = BackupManager(context)
 
-	override fun onInvalidated(tables: MutableSet<String>) {
+	override fun onInvalidated(tables: Set<String>) {
 		backupManager.dataChanged()
 	}
 }

app/src/main/java/org/koitharu/kotatsu/settings/tools/ToolsFragment.kt

@@ -16,7 +16,6 @@ import androidx.core.view.isVisible
 import androidx.core.view.updatePadding
 import androidx.core.widget.TextViewCompat
 import androidx.fragment.app.viewModels
-import com.google.android.material.R as materialR
 import com.google.android.material.color.MaterialColors
 import dagger.hilt.android.AndroidEntryPoint
 import org.koitharu.kotatsu.R
@@ -30,6 +29,7 @@ import org.koitharu.kotatsu.settings.about.AppUpdateDialog
 import org.koitharu.kotatsu.settings.tools.model.StorageUsage
 import org.koitharu.kotatsu.utils.FileSize
 import org.koitharu.kotatsu.utils.ext.getThemeColor
+import com.google.android.material.R as materialR
 
 @AndroidEntryPoint
 class ToolsFragment :
@@ -47,7 +47,7 @@ class ToolsFragment :
 		super.onViewCreated(view, savedInstanceState)
 		binding.buttonSettings.setOnClickListener(this)
 		binding.buttonDownloads.setOnClickListener(this)
-		binding.cardUpdate.root.setOnClickListener(this)
+		binding.cardUpdate.buttonChangelog.setOnClickListener(this)
 		binding.cardUpdate.buttonDownload.setOnClickListener(this)
 		binding.switchIncognito.setOnCheckedChangeListener(this)
 
@@ -69,7 +69,8 @@ class ToolsFragment :
 				intent.data = url.toUri()
 				startActivity(Intent.createChooser(intent, getString(R.string.open_in_browser)))
 			}
-			R.id.card_update -> {
+
+			R.id.button_changelog -> {
 				val version = viewModel.appUpdate.value ?: return
 				AppUpdateDialog(v.context).show(version)
 			}
@@ -92,7 +93,6 @@ class ToolsFragment :
 			return
 		}
 		binding.cardUpdate.textSecondary.text = getString(R.string.new_version_s, version.name)
-		binding.cardUpdate.textChangelog.text = version.description
 		binding.cardUpdate.root.isVisible = true
 	}
 

app/src/main/java/org/koitharu/kotatsu/settings/tracker/TrackerSettingsViewModel.kt

@@ -3,7 +3,6 @@ package org.koitharu.kotatsu.settings.tracker
 import androidx.lifecycle.MutableLiveData
 import androidx.room.InvalidationTracker
 import dagger.hilt.android.lifecycle.HiltViewModel
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import okio.Closeable
 import org.koitharu.kotatsu.base.ui.BaseViewModel
@@ -11,6 +10,7 @@ import org.koitharu.kotatsu.core.db.MangaDatabase
 import org.koitharu.kotatsu.core.db.TABLE_FAVOURITE_CATEGORIES
 import org.koitharu.kotatsu.core.db.removeObserverAsync
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
+import javax.inject.Inject
 
 @HiltViewModel
 class TrackerSettingsViewModel @Inject constructor(
@@ -39,7 +39,7 @@ class TrackerSettingsViewModel @Inject constructor(
 		InvalidationTracker.Observer(arrayOf(TABLE_FAVOURITE_CATEGORIES)),
 		Closeable {
 
-		override fun onInvalidated(tables: MutableSet<String>) {
+		override fun onInvalidated(tables: Set<String>) {
 			vm?.updateCategoriesCount()
 		}
 

app/src/main/java/org/koitharu/kotatsu/settings/utils/ActivityListPreference.kt

@@ -0,0 +1,38 @@
+package org.koitharu.kotatsu.settings.utils
+
+import android.content.ActivityNotFoundException
+import android.content.Context
+import android.content.Intent
+import android.util.AttributeSet
+import androidx.preference.ListPreference
+import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
+
+class ActivityListPreference : ListPreference {
+
+	var activityIntent: Intent? = null
+
+	constructor(
+		context: Context,
+		attrs: AttributeSet?,
+		defStyleAttr: Int,
+		defStyleRes: Int
+	) : super(context, attrs, defStyleAttr, defStyleRes)
+
+	constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : super(context, attrs, defStyleAttr)
+	constructor(context: Context, attrs: AttributeSet?) : super(context, attrs)
+	constructor(context: Context) : super(context)
+
+	override fun onClick() {
+		val intent = activityIntent
+		if (intent == null) {
+			super.onClick()
+			return
+		}
+		try {
+			context.startActivity(intent)
+		} catch (e: ActivityNotFoundException) {
+			e.printStackTraceDebug()
+			super.onClick()
+		}
+	}
+}

app/src/main/java/org/koitharu/kotatsu/shelf/ui/ShelfViewModel.kt

@@ -53,17 +53,22 @@ class ShelfViewModel @Inject constructor(
 
 	val content: LiveData<List<ListModel>> = combine(
 		settings.observeAsFlow(AppSettings.KEY_SHELF_SECTIONS) { shelfSections },
+		settings.observeAsFlow(AppSettings.KEY_TRACKER_ENABLED) { isTrackerEnabled },
 		networkState,
 		repository.observeShelfContent(),
-	) { sections, isConnected, content ->
+	) { sections, isTrackerEnabled, isConnected, content ->
-		mapList(content, sections, isConnected)
+		mapList(content, isTrackerEnabled, sections, isConnected)
 	}.debounce(500)
 		.catch { e ->
 			emit(listOf(e.toErrorState(canRetry = false)))
 		}.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, listOf(LoadingState))
 
 	override suspend fun getCounter(mangaId: Long): Int {
-		return trackingRepository.getNewChaptersCount(mangaId)
+		return if (settings.isTrackerEnabled) {
+			trackingRepository.getNewChaptersCount(mangaId)
+		} else {
+			0
+		}
 	}
 
 	override suspend fun getProgress(mangaId: Long): Float {
@@ -135,6 +140,7 @@ class ShelfViewModel @Inject constructor(
 
 	private suspend fun mapList(
 		content: ShelfContent,
+		isTrackerEnabled: Boolean,
 		sections: List<ShelfSection>,
 		isNetworkAvailable: Boolean,
 	): List<ListModel> {
@@ -144,7 +150,10 @@ class ShelfViewModel @Inject constructor(
 				when (section) {
 					ShelfSection.HISTORY -> mapHistory(result, content.history)
 					ShelfSection.LOCAL -> mapLocal(result, content.local)
-					ShelfSection.UPDATED -> mapUpdated(result, content.updated)
+					ShelfSection.UPDATED -> if (isTrackerEnabled) {
+						mapUpdated(result, content.updated)
+					}
+
 					ShelfSection.FAVORITES -> mapFavourites(result, content.favourites)
 				}
 			}
@@ -194,7 +203,7 @@ class ShelfViewModel @Inject constructor(
 		val showPercent = settings.isReadingIndicatorsEnabled
 		destination += ShelfSectionModel.History(
 			items = list.map { (manga, history) ->
-				val counter = trackingRepository.getNewChaptersCount(manga.id)
+				val counter = getCounter(manga.id)
 				val percent = if (showPercent) history.percent else PROGRESS_NONE
 				manga.toGridModel(counter, percent)
 			},

app/src/main/java/org/koitharu/kotatsu/shelf/ui/adapter/ScrollKeepObserver.kt

@@ -12,13 +12,13 @@ class ScrollKeepObserver(
 
 	override fun onItemRangeMoved(fromPosition: Int, toPosition: Int, itemCount: Int) {
 		val position = minOf(toPosition, fromPosition) // if items are swapping positions may be swapped too
-		if (position < layoutManager.findFirstVisibleItemPosition()) {
+		if (position == 0 || position < layoutManager.findFirstVisibleItemPosition()) {
 			postScroll(position)
 		}
 	}
 
 	override fun onItemRangeInserted(positionStart: Int, itemCount: Int) {
-		if (positionStart < layoutManager.findFirstVisibleItemPosition()) {
+		if (positionStart == 0 || positionStart < layoutManager.findFirstVisibleItemPosition()) {
 			postScroll(positionStart)
 		}
 	}

app/src/main/java/org/koitharu/kotatsu/shelf/ui/config/ShelfSettingsViewModel.kt

@@ -23,9 +23,10 @@ class ShelfSettingsViewModel @Inject constructor(
 
 	val content = combine(
 		settings.observeAsFlow(AppSettings.KEY_SHELF_SECTIONS) { shelfSections },
+		settings.observeAsFlow(AppSettings.KEY_TRACKER_ENABLED) { isTrackerEnabled },
 		favouritesRepository.observeCategories(),
-	) { sections, categories ->
+	) { sections, isTrackerEnabled, categories ->
-		buildList(sections, categories)
+		buildList(sections, isTrackerEnabled, categories)
 	}.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, emptyList())
 
 	private var updateJob: Job? = null
@@ -64,13 +65,18 @@ class ShelfSettingsViewModel @Inject constructor(
 
 	private fun buildList(
 		sections: List<ShelfSection>,
+		isTrackerEnabled: Boolean,
 		categories: List<FavouriteCategory>
 	): List<ShelfSettingsItemModel> {
 		val result = ArrayList<ShelfSettingsItemModel>()
 		val sectionsList = ShelfSection.values().toMutableList()
+		if (!isTrackerEnabled) {
+			sectionsList.remove(ShelfSection.UPDATED)
+		}
 		for (section in sections) {
-			sectionsList.remove(section)
+			if (sectionsList.remove(section)) {
-			result.addSection(section, true, categories)
+				result.addSection(section, true, categories)
+			}
 		}
 		for (section in sectionsList) {
 			result.addSection(section, false, categories)

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

@@ -2,7 +2,6 @@ package org.koitharu.kotatsu.suggestions.ui
 
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
@@ -17,6 +16,7 @@ import org.koitharu.kotatsu.list.ui.model.toUi
 import org.koitharu.kotatsu.suggestions.domain.SuggestionRepository
 import org.koitharu.kotatsu.utils.asFlowLiveData
 import org.koitharu.kotatsu.utils.ext.onFirst
+import javax.inject.Inject
 
 @HiltViewModel
 class SuggestionsViewModel @Inject constructor(
@@ -26,7 +26,7 @@ class SuggestionsViewModel @Inject constructor(
 
 	override val content = combine(
 		repository.observeAll(),
-		createListModeFlow(),
+		listModeFlow,
 	) { list, mode ->
 		when {
 			list.isEmpty() -> listOf(
@@ -37,6 +37,7 @@ class SuggestionsViewModel @Inject constructor(
 					actionStringRes = 0,
 				),
 			)
+
 			else -> list.toUi(mode)
 		}
 	}.onStart {

app/src/main/java/org/koitharu/kotatsu/sync/domain/SyncController.kt

@@ -44,7 +44,7 @@ class SyncController @Inject constructor(
 	private val defaultGcPeriod: Long // gc period if sync disabled
 		get() = TimeUnit.HOURS.toMillis(2)
 
-	override fun onInvalidated(tables: MutableSet<String>) {
+	override fun onInvalidated(tables: Set<String>) {
 		requestSync(
 			favourites = TABLE_FAVOURITES in tables || TABLE_FAVOURITE_CATEGORIES in tables,
 			history = TABLE_HISTORY in tables,

app/src/main/java/org/koitharu/kotatsu/sync/ui/SyncProvider.kt

@@ -11,11 +11,10 @@ import androidx.sqlite.db.SupportSQLiteDatabase
 import androidx.sqlite.db.SupportSQLiteQueryBuilder
 import dagger.hilt.EntryPoint
 import dagger.hilt.InstallIn
-import dagger.hilt.android.AndroidEntryPoint
 import dagger.hilt.android.EntryPointAccessors
 import dagger.hilt.components.SingletonComponent
-import java.util.concurrent.Callable
 import org.koitharu.kotatsu.core.db.*
+import java.util.concurrent.Callable
 
 abstract class SyncProvider : ContentProvider() {
 
@@ -44,15 +43,14 @@ abstract class SyncProvider : ContentProvider() {
 		selection: String?,
 		selectionArgs: Array<out String>?,
 		sortOrder: String?,
-	): Cursor? = if (getTableName(uri) != null) {
+	): Cursor? {
-		val sqlQuery = SupportSQLiteQueryBuilder.builder(uri.lastPathSegment)
+		val tableName = getTableName(uri) ?: return null
+		val sqlQuery = SupportSQLiteQueryBuilder.builder(tableName)
 			.columns(projection)
 			.selection(selection, selectionArgs)
 			.orderBy(sortOrder)
 			.create()
-		database.openHelper.readableDatabase.query(sqlQuery)
+		return database.openHelper.readableDatabase.query(sqlQuery)
-	} else {
-		null
 	}
 
 	override fun getType(uri: Uri): String? {