Update parsers

app/build.gradle

@@ -15,8 +15,8 @@ android {
 		applicationId 'org.koitharu.kotatsu'
 		minSdkVersion 21
 		targetSdkVersion 33
-		versionCode 545
-		versionName '5.1.1'
+		versionCode 546
+		versionName '5.1.2'
 		generatedDensities = []
 		testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 
@@ -78,7 +78,7 @@ afterEvaluate {
 }
 dependencies {
 	//noinspection GradleDependency
-	implementation('com.github.KotatsuApp:kotatsu-parsers:cae7073f87') {
+	implementation('com.github.KotatsuApp:kotatsu-parsers:ebcc6391d6') {
 		exclude group: 'org.json', module: 'json'
 	}
 

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

@@ -23,6 +23,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
+import okhttp3.Cache
 import okhttp3.CookieJar
 import okhttp3.OkHttpClient
 import org.koitharu.kotatsu.BuildConfig
@@ -88,14 +89,19 @@ interface AppModule {
 
 		@Provides
 		@Singleton
-		fun provideOkHttpClient(
+		fun provideHttpCache(
 			localStorageManager: LocalStorageManager,
+		): Cache = localStorageManager.createHttpCache()
+
+		@Provides
+		@Singleton
+		fun provideOkHttpClient(
+			cache: Cache,
 			commonHeadersInterceptor: CommonHeadersInterceptor,
 			mirrorSwitchInterceptor: MirrorSwitchInterceptor,
 			cookieJar: CookieJar,
 			settings: AppSettings,
 		): OkHttpClient {
-			val cache = localStorageManager.createHttpCache()
 			return OkHttpClient.Builder().apply {
 				connectTimeout(20, TimeUnit.SECONDS)
 				readTimeout(60, TimeUnit.SECONDS)
@@ -106,6 +112,7 @@ interface AppModule {
 					bypassSSLErrors()
 				}
 				cache(cache)
+				addNetworkInterceptor(CacheLimitInterceptor())
 				addInterceptor(GZipInterceptor())
 				addInterceptor(commonHeadersInterceptor)
 				addInterceptor(CloudFlareInterceptor())

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

@@ -1,5 +0,0 @@
-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/ExpiringLruCache.kt

@@ -0,0 +1,33 @@
+package org.koitharu.kotatsu.core.cache
+
+import androidx.collection.LruCache
+import java.util.concurrent.TimeUnit
+
+class ExpiringLruCache<T>(
+	val maxSize: Int,
+	private val lifetime: Long,
+	private val timeUnit: TimeUnit,
+) {
+
+	private val cache = LruCache<ContentCache.Key, ExpiringValue<T>>(maxSize)
+
+	operator fun get(key: ContentCache.Key): T? {
+		val value = cache.get(key) ?: return null
+		if (value.isExpired) {
+			cache.remove(key)
+		}
+		return value.get()
+	}
+
+	operator fun set(key: ContentCache.Key, value: T) {
+		cache.put(key, ExpiringValue(value, lifetime, timeUnit))
+	}
+
+	fun clear() {
+		cache.evictAll()
+	}
+
+	fun trimToSize(size: Int) {
+		cache.trimToSize(size)
+	}
+}

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

@@ -0,0 +1,34 @@
+package org.koitharu.kotatsu.core.cache
+
+import android.os.SystemClock
+import java.util.concurrent.TimeUnit
+
+class ExpiringValue<T>(
+	private val value: T,
+	lifetime: Long,
+	timeUnit: TimeUnit,
+) {
+
+	private val expiresAt = SystemClock.elapsedRealtime() + timeUnit.toMillis(lifetime)
+
+	val isExpired: Boolean
+		get() = SystemClock.elapsedRealtime() >= expiresAt
+
+	fun get(): T? = if (isExpired) null else value
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as ExpiringValue<*>
+
+		if (value != other.value) return false
+		return expiresAt == other.expiresAt
+	}
+
+	override fun hashCode(): Int {
+		var result = value?.hashCode() ?: 0
+		result = 31 * result + expiresAt.hashCode()
+		return result
+	}
+}

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

@@ -6,6 +6,7 @@ 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
+import java.util.concurrent.TimeUnit
 
 class MemoryContentCache(application: Application) : ContentCache, ComponentCallbacks2 {
 
@@ -13,8 +14,8 @@ class MemoryContentCache(application: Application) : ContentCache, ComponentCall
 		application.registerComponentCallbacks(this)
 	}
 
-	private val detailsCache = DeferredLruCache<Manga>(4)
-	private val pagesCache = DeferredLruCache<List<MangaPage>>(4)
+	private val detailsCache = ExpiringLruCache<SafeDeferred<Manga>>(4, 5, TimeUnit.MINUTES)
+	private val pagesCache = ExpiringLruCache<SafeDeferred<List<MangaPage>>>(4, 10, TimeUnit.MINUTES)
 
 	override val isCachingEnabled: Boolean = true
 
@@ -23,7 +24,7 @@ class MemoryContentCache(application: Application) : ContentCache, ComponentCall
 	}
 
 	override fun putDetails(source: MangaSource, url: String, details: SafeDeferred<Manga>) {
-		detailsCache.put(ContentCache.Key(source, url), details)
+		detailsCache[ContentCache.Key(source, url)] = details
 	}
 
 	override suspend fun getPages(source: MangaSource, url: String): List<MangaPage>? {
@@ -31,7 +32,7 @@ class MemoryContentCache(application: Application) : ContentCache, ComponentCall
 	}
 
 	override fun putPages(source: MangaSource, url: String, pages: SafeDeferred<List<MangaPage>>) {
-		pagesCache.put(ContentCache.Key(source, url), pages)
+		pagesCache[ContentCache.Key(source, url)] = pages
 	}
 
 	override fun onConfigurationChanged(newConfig: Configuration) = Unit
@@ -43,17 +44,17 @@ class MemoryContentCache(application: Application) : ContentCache, ComponentCall
 		trimCache(pagesCache, level)
 	}
 
-	private fun trimCache(cache: DeferredLruCache<*>, level: Int) {
+	private fun trimCache(cache: ExpiringLruCache<*>, level: Int) {
 		when (level) {
 			ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL,
 			ComponentCallbacks2.TRIM_MEMORY_COMPLETE,
-			ComponentCallbacks2.TRIM_MEMORY_MODERATE -> cache.evictAll()
+			ComponentCallbacks2.TRIM_MEMORY_MODERATE -> cache.clear()
 
 			ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN,
 			ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW,
 			ComponentCallbacks2.TRIM_MEMORY_BACKGROUND -> cache.trimToSize(1)
 
-			else -> cache.trimToSize(cache.maxSize() / 2)
+			else -> cache.trimToSize(cache.maxSize / 2)
 		}
 	}
 }

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

@@ -0,0 +1,26 @@
+package org.koitharu.kotatsu.core.network
+
+import okhttp3.CacheControl
+import okhttp3.Interceptor
+import okhttp3.Response
+import java.util.concurrent.TimeUnit
+
+class CacheLimitInterceptor : Interceptor {
+
+	private val defaultMaxAge = TimeUnit.HOURS.toSeconds(1)
+	private val defaultCacheControl = CacheControl.Builder()
+		.maxAge(defaultMaxAge.toInt(), TimeUnit.SECONDS)
+		.build()
+		.toString()
+
+	override fun intercept(chain: Interceptor.Chain): Response {
+		val response = chain.proceed(chain.request())
+		val responseCacheControl = CacheControl.parse(response.headers)
+		if (responseCacheControl.noStore || responseCacheControl.maxAgeSeconds <= defaultMaxAge) {
+			return response
+		}
+		return response.newBuilder()
+			.header(CommonHeaders.CACHE_CONTROL, defaultCacheControl)
+			.build()
+	}
+}

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

@@ -13,6 +13,7 @@ object CommonHeaders {
 	const val CONTENT_ENCODING = "Content-Encoding"
 	const val ACCEPT_ENCODING = "Accept-Encoding"
 	const val AUTHORIZATION = "Authorization"
+	const val CACHE_CONTROL = "Cache-Control"
 
 	val CACHE_CONTROL_NO_STORE: CacheControl
 		get() = CacheControl.Builder().noStore().build()

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

@@ -345,6 +345,7 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_SOURCES_HIDDEN = "sources_hidden"
 		const val KEY_TRAFFIC_WARNING = "traffic_warning"
 		const val KEY_PAGES_CACHE_CLEAR = "pages_cache_clear"
+		const val KEY_HTTP_CACHE_CLEAR = "http_cache_clear"
 		const val KEY_COOKIES_CLEAR = "cookies_clear"
 		const val KEY_THUMBS_CACHE_CLEAR = "thumbs_cache_clear"
 		const val KEY_SEARCH_HISTORY_CLEAR = "search_history_clear"

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

@@ -0,0 +1,27 @@
+package org.koitharu.kotatsu.settings
+
+import okhttp3.Headers
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.network.CommonHeaders
+import org.koitharu.kotatsu.utils.EditTextValidator
+
+class HeaderValidator : EditTextValidator() {
+
+	private val headers = Headers.Builder()
+
+	override fun validate(text: String): ValidationResult {
+		val trimmed = text.trim()
+		if (trimmed.isEmpty()) {
+			return ValidationResult.Success
+		}
+		return if (!validateImpl(trimmed)) {
+			ValidationResult.Failed(context.getString(R.string.invalid_value_message))
+		} else {
+			ValidationResult.Success
+		}
+	}
+
+	private fun validateImpl(value: String): Boolean = runCatching {
+		headers[CommonHeaders.USER_AGENT] = value
+	}.isSuccess
+}

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

@@ -8,7 +8,10 @@ import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.snackbar.Snackbar
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.runInterruptible
+import okhttp3.Cache
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BasePreferenceFragment
 import org.koitharu.kotatsu.core.network.cookies.MutableCookieJar
@@ -39,6 +42,9 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach
 	@Inject
 	lateinit var cookieJar: MutableCookieJar
 
+	@Inject
+	lateinit var cache: Cache
+
 	@Inject
 	lateinit var shortcutsUpdater: ShortcutsUpdater
 
@@ -52,6 +58,7 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach
 		super.onViewCreated(view, savedInstanceState)
 		findPreference<Preference>(AppSettings.KEY_PAGES_CACHE_CLEAR)?.bindSummaryToCacheSize(CacheDir.PAGES)
 		findPreference<Preference>(AppSettings.KEY_THUMBS_CACHE_CLEAR)?.bindSummaryToCacheSize(CacheDir.THUMBS)
+		findPreference<Preference>(AppSettings.KEY_HTTP_CACHE_CLEAR)?.bindSummaryToHttpCacheSize()
 		findPreference<Preference>(AppSettings.KEY_SEARCH_HISTORY_CLEAR)?.let { pref ->
 			viewLifecycleScope.launch {
 				lifecycle.awaitStateAtLeast(Lifecycle.State.RESUMED)
@@ -90,6 +97,11 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach
 				true
 			}
 
+			AppSettings.KEY_HTTP_CACHE_CLEAR -> {
+				clearHttpCache()
+				true
+			}
+
 			AppSettings.KEY_UPDATES_FEED_CLEAR -> {
 				viewLifecycleScope.launch {
 					trackerRepo.clearLogs()
@@ -131,6 +143,32 @@ class HistorySettingsFragment : BasePreferenceFragment(R.string.history_and_cach
 		summary = FileSize.BYTES.format(context, size)
 	}
 
+	private fun Preference.bindSummaryToHttpCacheSize() = viewLifecycleScope.launch {
+		val size = runInterruptible(Dispatchers.IO) { cache.size() }
+		summary = FileSize.BYTES.format(context, size)
+	}
+
+	private fun clearHttpCache() {
+		val preference = findPreference<Preference>(AppSettings.KEY_HTTP_CACHE_CLEAR) ?: return
+		val ctx = preference.context.applicationContext
+		viewLifecycleScope.launch {
+			try {
+				preference.isEnabled = false
+				val size = runInterruptible(Dispatchers.IO) {
+					cache.evictAll()
+					cache.size()
+				}
+				preference.summary = FileSize.BYTES.format(ctx, size)
+			} catch (e: CancellationException) {
+				throw e
+			} catch (e: Exception) {
+				preference.summary = e.getDisplayMessage(ctx.resources)
+			} finally {
+				preference.isEnabled = true
+			}
+		}
+	}
+
 	private fun clearSearchHistory(preference: Preference) {
 		MaterialAlertDialogBuilder(context ?: return)
 			.setTitle(R.string.clear_search_history)

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

@@ -44,7 +44,7 @@ fun PreferenceFragmentCompat.addPreferencesFromRepository(repository: RemoteMang
 						EditTextBindListener(
 							inputType = EditorInfo.TYPE_CLASS_TEXT,
 							hint = key.defaultValue,
-							validator = null,
+							validator = HeaderValidator(),
 						),
 					)
 					setTitle(R.string.user_agent)

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

@@ -84,12 +84,14 @@ class SyncAuthActivity : BaseActivity<ActivitySyncAuthBinding>(), View.OnClickLi
 				binding.groupLogin.isVisible = false
 				binding.groupPassword.isVisible = true
 				pageBackCallback.update()
+				binding.editPassword.requestFocus()
 			}
 
 			R.id.button_back -> {
 				binding.groupPassword.isVisible = false
 				binding.groupLogin.isVisible = true
 				pageBackCallback.update()
+				binding.editEmail.requestFocus()
 			}
 
 			R.id.button_done -> {
@@ -200,6 +202,7 @@ class SyncAuthActivity : BaseActivity<ActivitySyncAuthBinding>(), View.OnClickLi
 		override fun handleOnBackPressed() {
 			binding.groupLogin.isVisible = true
 			binding.groupPassword.isVisible = false
+			binding.editEmail.requestFocus()
 			update()
 		}
 

app/src/main/res/values/strings.xml

@@ -416,4 +416,6 @@
 	<string name="suggestions_enable_prompt">Do you want to receive personalized manga suggestions?</string>
 	<string name="translations">Translations</string>
 	<string name="web_view_unavailable">WebView not available: check if WebView provider is installed</string>
+	<string name="invalid_value_message">Invalid value</string>
+	<string name="clear_network_cache">Clear network cache</string>
 </resources>

app/src/main/res/xml/pref_history.xml

@@ -39,6 +39,12 @@
 			android:summary="@string/computing_"
 			android:title="@string/clear_pages_cache" />
 
+		<Preference
+			android:key="http_cache_clear"
+			android:persistent="false"
+			android:summary="@string/loading_"
+			android:title="@string/clear_network_cache" />
+
 		<Preference
 			android:key="cookies_clear"
 			android:persistent="false"