Fix VersionId parsing for nightly builds

app/build.gradle

@@ -82,11 +82,11 @@ android {
 	}
 	compileOptions {
 		coreLibraryDesugaringEnabled true
-		sourceCompatibility JavaVersion.VERSION_11
-		targetCompatibility JavaVersion.VERSION_11
+		sourceCompatibility JavaVersion.VERSION_17
+		targetCompatibility JavaVersion.VERSION_17
 	}
 	kotlinOptions {
-		jvmTarget = JavaVersion.VERSION_11.toString()
+		jvmTarget = JavaVersion.VERSION_17.toString()
 		freeCompilerArgs += [
 			'-opt-in=kotlin.ExperimentalStdlibApi',
 			'-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi',

app/src/main/AndroidManifest.xml

@@ -445,6 +445,9 @@
 				<action android:name="${applicationId}.action.REPORT_ERROR" />
 			</intent-filter>
 		</receiver>
+		<receiver
+			android:name="org.koitharu.kotatsu.core.github.AppUpdateDismissReceiver"
+			android:exported="false" />
 
 		<meta-data
 			android:name="android.webkit.WebView.EnableSafeBrowsing"

app/src/main/kotlin/org/koitharu/kotatsu/core/BaseApp.kt

@@ -12,7 +12,7 @@ import dagger.hilt.android.HiltAndroidApp
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.launch
-import okhttp3.internal.platform.PlatformRegistry
+import okhttp3.OkHttp
 import org.acra.ACRA
 import org.acra.ReportField
 import org.acra.config.dialog
@@ -26,6 +26,7 @@ import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.db.MangaDatabase
 import org.koitharu.kotatsu.core.os.AppValidator
 import org.koitharu.kotatsu.core.os.RomCompat
+import org.koitharu.kotatsu.core.network.DnsPrefetchManager
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.util.ext.processLifecycleScope
 import org.koitharu.kotatsu.local.data.LocalStorageChanges
@@ -61,6 +62,9 @@ open class BaseApp : Application(), Configuration.Provider {
 	@Inject
 	lateinit var workScheduleManager: WorkScheduleManager
 
+	@Inject
+	lateinit var dnsPrefetchManager: DnsPrefetchManager
+
 	@Inject
 	lateinit var localMangaIndexProvider: Provider<LocalMangaIndex>
 
@@ -75,7 +79,7 @@ open class BaseApp : Application(), Configuration.Provider {
 
 	override fun onCreate() {
 		super.onCreate()
-		PlatformRegistry.applicationContext = this // TODO replace with OkHttp.initialize
+		OkHttp.initialize(this)
 		if (ACRA.isACRASenderServiceProcess()) {
 			return
 		}
@@ -94,6 +98,7 @@ open class BaseApp : Application(), Configuration.Provider {
 			localStorageChanges.collect(localMangaIndexProvider.get())
 		}
 		workScheduleManager.init()
+		dnsPrefetchManager.initialize()
 	}
 
 	override fun attachBaseContext(base: Context) {

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

@@ -3,6 +3,7 @@ package org.koitharu.kotatsu.core.cache
 import android.app.Application
 import android.content.ComponentCallbacks2
 import android.content.res.Configuration
+import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.util.ext.isLowRamDevice
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaPage
@@ -11,16 +12,41 @@ import java.util.concurrent.TimeUnit
 import javax.inject.Inject
 import javax.inject.Singleton
 
+/**
+ * In-memory cache for manga content with configurable TTL.
+ *
+ * Cache TTL settings can be configured in AppSettings:
+ * - Details cache: default 5 minutes (configurable 1-60 min)
+ * - Pages cache: default 10 minutes (configurable 1-120 min)
+ * - Related manga cache: default 10 minutes (configurable 1-120 min)
+ *
+ * Note: Changes to TTL settings require app restart to take effect.
+ */
 @Singleton
-class MemoryContentCache @Inject constructor(application: Application) : ComponentCallbacks2 {
+class MemoryContentCache @Inject constructor(
+	application: Application,
+	settings: AppSettings,
+) : ComponentCallbacks2 {
 
 	private val isLowRam = application.isLowRamDevice()
 
-	private val detailsCache = ExpiringLruCache<SafeDeferred<Manga>>(if (isLowRam) 1 else 4, 5, TimeUnit.MINUTES)
-	private val pagesCache =
-		ExpiringLruCache<SafeDeferred<List<MangaPage>>>(if (isLowRam) 1 else 4, 10, TimeUnit.MINUTES)
-	private val relatedMangaCache =
-		ExpiringLruCache<SafeDeferred<List<Manga>>>(if (isLowRam) 1 else 3, 10, TimeUnit.MINUTES)
+	private val detailsCache = ExpiringLruCache<SafeDeferred<Manga>>(
+		maxSize = if (isLowRam) 1 else 4,
+		lifetime = settings.cacheDetailsTtlMinutes.toLong(),
+		timeUnit = TimeUnit.MINUTES,
+	)
+
+	private val pagesCache = ExpiringLruCache<SafeDeferred<List<MangaPage>>>(
+		maxSize = if (isLowRam) 1 else 4,
+		lifetime = settings.cachePagesTtlMinutes.toLong(),
+		timeUnit = TimeUnit.MINUTES,
+	)
+
+	private val relatedMangaCache = ExpiringLruCache<SafeDeferred<List<Manga>>>(
+		maxSize = if (isLowRam) 1 else 3,
+		lifetime = settings.cacheRelatedTtlMinutes.toLong(),
+		timeUnit = TimeUnit.MINUTES,
+	)
 
 	init {
 		application.registerComponentCallbacks(this)

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

@@ -0,0 +1,236 @@
+package org.koitharu.kotatsu.core.db
+
+import android.content.Context
+import android.util.Log
+import androidx.room.RoomDatabase
+import androidx.sqlite.db.SupportSQLiteDatabase
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.koitharu.kotatsu.BuildConfig
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Database query optimizer that provides runtime optimizations and diagnostics.
+ *
+ * Features:
+ * - Periodic ANALYZE to update query planner statistics
+ * - VACUUM for database compaction (when database is idle)
+ * - Query plan analysis for debugging slow queries
+ * - Index usage statistics
+ */
+@Singleton
+class DatabaseOptimizer @Inject constructor(
+	@ApplicationContext private val context: Context,
+	private val database: MangaDatabase,
+) {
+
+	/**
+	 * Run ANALYZE to update SQLite's query planner statistics.
+	 * Should be called periodically (e.g., once per app session or daily).
+	 */
+	suspend fun analyzeDatabase() = withContext(Dispatchers.IO) {
+		try {
+			database.openHelper.writableDatabase.execSQL("ANALYZE")
+			logDebug { "Database ANALYZE completed successfully" }
+		} catch (e: Exception) {
+			Log.e(TAG, "Failed to analyze database", e)
+		}
+	}
+
+	/**
+	 * Run VACUUM to compact the database and reclaim unused space.
+	 * Should be called infrequently (e.g., weekly or when database size is large).
+	 * Note: This operation can be slow and locks the database.
+	 */
+	suspend fun vacuumDatabase() = withContext(Dispatchers.IO) {
+		try {
+			database.openHelper.writableDatabase.execSQL("VACUUM")
+			logDebug { "Database VACUUM completed successfully" }
+		} catch (e: Exception) {
+			Log.e(TAG, "Failed to vacuum database", e)
+		}
+	}
+
+	/**
+	 * Get the current database file size in bytes.
+	 */
+	fun getDatabaseSize(): Long {
+		return try {
+			context.getDatabasePath("kotatsu-db").length()
+		} catch (e: Exception) {
+			-1L
+		}
+	}
+
+	/**
+	 * Get database statistics including page count, free pages, etc.
+	 */
+	suspend fun getDatabaseStats(): DatabaseStats = withContext(Dispatchers.IO) {
+		try {
+			val db = database.openHelper.readableDatabase
+
+			val pageCount = queryPragmaInt(db, "page_count")
+			val pageSize = queryPragmaInt(db, "page_size")
+			val freeListCount = queryPragmaInt(db, "freelist_count")
+
+			DatabaseStats(
+				sizeBytes = getDatabaseSize(),
+				pageCount = pageCount,
+				pageSize = pageSize,
+				freePages = freeListCount,
+				usedPages = pageCount - freeListCount,
+				fragmentationPercent = if (pageCount > 0) {
+					(freeListCount.toFloat() / pageCount * 100).coerceIn(0f, 100f)
+				} else 0f,
+			)
+		} catch (e: Exception) {
+			Log.e(TAG, "Failed to get database stats", e)
+			DatabaseStats()
+		}
+	}
+
+	/**
+	 * Explain a query plan for debugging purposes.
+	 * Only available in debug builds.
+	 */
+	suspend fun explainQueryPlan(query: String): List<String> = withContext(Dispatchers.IO) {
+		if (!BuildConfig.DEBUG) {
+			return@withContext emptyList()
+		}
+
+		try {
+			val db = database.openHelper.readableDatabase
+			val results = mutableListOf<String>()
+
+			db.query("EXPLAIN QUERY PLAN $query").use { cursor ->
+				while (cursor.moveToNext()) {
+					val detail = cursor.getString(cursor.getColumnIndexOrThrow("detail"))
+					results.add(detail)
+				}
+			}
+
+			results
+		} catch (e: Exception) {
+			Log.e(TAG, "Failed to explain query plan", e)
+			emptyList()
+		}
+	}
+
+	/**
+	 * Get a list of all indexes in the database.
+	 */
+	suspend fun getIndexList(): List<IndexInfo> = withContext(Dispatchers.IO) {
+		try {
+			val db = database.openHelper.readableDatabase
+			val indexes = mutableListOf<IndexInfo>()
+
+			// Get all tables
+			db.query("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE 'room_%'").use { tablesCursor ->
+				while (tablesCursor.moveToNext()) {
+					val tableName = tablesCursor.getString(0)
+
+					// Get indexes for each table
+					db.query("PRAGMA index_list('$tableName')").use { indexCursor ->
+						while (indexCursor.moveToNext()) {
+							val indexName = indexCursor.getString(indexCursor.getColumnIndexOrThrow("name"))
+							val isUnique = indexCursor.getInt(indexCursor.getColumnIndexOrThrow("unique")) == 1
+
+							// Get columns in the index
+							val columns = mutableListOf<String>()
+							db.query("PRAGMA index_info('$indexName')").use { colCursor ->
+								while (colCursor.moveToNext()) {
+									columns.add(colCursor.getString(colCursor.getColumnIndexOrThrow("name")))
+								}
+							}
+
+							indexes.add(IndexInfo(
+								name = indexName,
+								tableName = tableName,
+								columns = columns,
+								isUnique = isUnique,
+							))
+						}
+					}
+				}
+			}
+
+			indexes
+		} catch (e: Exception) {
+			Log.e(TAG, "Failed to get index list", e)
+			emptyList()
+		}
+	}
+
+	/**
+	 * Check database integrity.
+	 */
+	suspend fun checkIntegrity(): Boolean = withContext(Dispatchers.IO) {
+		try {
+			val db = database.openHelper.readableDatabase
+			db.query("PRAGMA integrity_check").use { cursor ->
+				if (cursor.moveToFirst()) {
+					val result = cursor.getString(0)
+					return@withContext result == "ok"
+				}
+			}
+			false
+		} catch (e: Exception) {
+			Log.e(TAG, "Failed to check database integrity", e)
+			false
+		}
+	}
+
+	/**
+	 * Optimize database for better performance.
+	 * Combines ANALYZE and optional VACUUM based on fragmentation.
+	 */
+	suspend fun optimize(forceVacuum: Boolean = false) = withContext(Dispatchers.IO) {
+		// Always run ANALYZE
+		analyzeDatabase()
+
+		// Only VACUUM if fragmentation is high or forced
+		val stats = getDatabaseStats()
+		if (forceVacuum || stats.fragmentationPercent > VACUUM_THRESHOLD_PERCENT) {
+			logDebug { "Running VACUUM due to ${stats.fragmentationPercent}% fragmentation" }
+			vacuumDatabase()
+		}
+	}
+
+	private fun queryPragmaInt(db: SupportSQLiteDatabase, pragma: String): Int {
+		return db.query("PRAGMA $pragma").use { cursor ->
+			if (cursor.moveToFirst()) cursor.getInt(0) else 0
+		}
+	}
+
+	private inline fun logDebug(message: () -> String) {
+		if (BuildConfig.DEBUG) {
+			Log.d(TAG, message())
+		}
+	}
+
+	data class DatabaseStats(
+		val sizeBytes: Long = 0,
+		val pageCount: Int = 0,
+		val pageSize: Int = 0,
+		val freePages: Int = 0,
+		val usedPages: Int = 0,
+		val fragmentationPercent: Float = 0f,
+	) {
+		val sizeMb: Float
+			get() = sizeBytes / (1024f * 1024f)
+	}
+
+	data class IndexInfo(
+		val name: String,
+		val tableName: String,
+		val columns: List<String>,
+		val isUnique: Boolean,
+	)
+
+	companion object {
+		private const val TAG = "DatabaseOptimizer"
+		private const val VACUUM_THRESHOLD_PERCENT = 20f
+	}
+}