diff --git a/app/build.gradle b/app/build.gradle
index 4d56eae21c..a1eb38d8cc 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -219,6 +219,7 @@ dependencies {
implementation libs.coil.gif
implementation libs.coil.svg
implementation libs.avif.decoder
+ implementation libs.jxl.coder
implementation libs.ssiv
implementation libs.disk.lru.cache
implementation libs.markwon
diff --git a/app/src/androidTest/kotlin/io/github/landwarderer/futon/reader/ProgressUpdateRaceTest.kt b/app/src/androidTest/kotlin/io/github/landwarderer/futon/reader/ProgressUpdateRaceTest.kt
index b0af2dfa56..a4a173e88b 100644
--- a/app/src/androidTest/kotlin/io/github/landwarderer/futon/reader/ProgressUpdateRaceTest.kt
+++ b/app/src/androidTest/kotlin/io/github/landwarderer/futon/reader/ProgressUpdateRaceTest.kt
@@ -74,6 +74,19 @@ class ProgressUpdateRaceTest {
assertEquals(result, saved.percent)
}
+ @Test
+ fun recalculationKeepsChaptersCountForSmartResume() = runBlocking {
+ val fixture = fixture()
+ val dao = database.getHistoryDao()
+ // read while the source had 29 chapters; chapter 30 has been released since
+ dao.update(dao.find(fixture.manga.id)!!.copy(chaptersCount = 29))
+ val job = async(Dispatchers.IO) { recalculate(fixture.manga) }
+ withTimeout(30_000) { fixture.started.await() }
+ fixture.release()
+ withTimeout(30_000) { job.await() }
+ assertEquals(29, dao.find(fixture.manga.id)!!.chaptersCount)
+ }
+
@Test
fun historyRemovedDuringRecalculationStaysRemoved() = runBlocking {
val fixture = fixture()
diff --git a/app/src/androidTest/kotlin/io/github/landwarderer/futon/settings/backup/AppBackupAgentTest.kt b/app/src/androidTest/kotlin/io/github/landwarderer/futon/settings/backup/AppBackupAgentTest.kt
index 797728abd9..31369ea141 100644
--- a/app/src/androidTest/kotlin/io/github/landwarderer/futon/settings/backup/AppBackupAgentTest.kt
+++ b/app/src/androidTest/kotlin/io/github/landwarderer/futon/settings/backup/AppBackupAgentTest.kt
@@ -90,6 +90,29 @@ class AppBackupAgentTest {
assertTrue(SampleData.tag in allTags)
}
+ @Test
+ fun restoreReplacesEnabledSources() = runTest {
+ val dao = database.getSourcesDao()
+ dao.setEnabled("MANGADEX", true)
+ dao.setEnabled("MANGAPARK", true)
+
+ val agent = AppBackupAgent()
+ val backup = agent.createBackupFile(
+ context = InstrumentationRegistry.getInstrumentation().targetContext,
+ repository = backupRepository,
+ )
+
+ // as after a fresh install, where other sources are enabled by default
+ dao.setEnabled("MANGADEX", false)
+ dao.setEnabled("NHENTAI", true)
+
+ backup.inputStream().use {
+ agent.restoreBackupFile(it.fd, backup.length(), backupRepository)
+ }
+
+ assertEquals(setOf("MANGADEX", "MANGAPARK"), dao.findAllEnabledNames().toSet())
+ }
+
@Test
fun restoreOldBackup() {
val agent = AppBackupAgent()
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 57e1aa03b2..24b8dfae13 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -230,6 +230,13 @@
android:autoRemoveFromRecents="true"
android:configChanges="orientation|screenSize|screenLayout|keyboardHidden"
android:windowSoftInputMode="adjustResize" />
+
+
+
+
+
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/AlternativesSearchOptions.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/AlternativesSearchOptions.kt
new file mode 100644
index 0000000000..e4dafba8a6
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/AlternativesSearchOptions.kt
@@ -0,0 +1,71 @@
+package io.github.landwarderer.futon.alternatives.domain
+
+import org.koitharu.kotatsu.parsers.model.Manga
+
+data class AlternativesSearchOptions(
+ val query: String,
+ val sourceScope: AlternativeSourceScope = AlternativeSourceScope.Enabled,
+ val sameLanguageOnly: Boolean = false,
+ val sameContentTypeOnly: Boolean = false,
+ val hideNoChapters: Boolean = false,
+ val sortOrder: AlternativeSortOrder = AlternativeSortOrder.BEST_MATCH,
+) {
+
+ fun isDefaultFor(title: String, defaultScope: AlternativeSourceScope): Boolean =
+ this == AlternativesSearchOptions(query = title, sourceScope = defaultScope)
+}
+
+/** Which sources an alternatives search or a source replacement runs across. */
+sealed interface AlternativeSourceScope {
+
+ data object Enabled : AlternativeSourceScope
+
+ /** The sources the user has not enabled - where an alternative is most often hiding. */
+ data object Disabled : AlternativeSourceScope
+
+ /** Any saved preset, not only the active one. */
+ data class Preset(val id: Long) : AlternativeSourceScope
+}
+
+enum class AlternativeSortOrder {
+ BEST_MATCH,
+ MOST_CHAPTERS,
+ CLOSEST_CHAPTER_COUNT,
+ SOURCE_PRIORITY,
+}
+
+sealed interface AlternativeSearchEvent {
+
+ data class Result(val manga: Manga) : AlternativeSearchEvent
+
+ data class Progress(
+ val completedSources: Int,
+ val totalSources: Int,
+ ) : AlternativeSearchEvent
+}
+
+data class AlternativeSearchStatus(
+ val completedSources: Int = 0,
+ val totalSources: Int = 0,
+ val resultsCount: Int = 0,
+ val isRunning: Boolean = false,
+)
+
+data class AlternativeSourceScopeOptions(
+ val defaultScope: AlternativeSourceScope,
+ /** Presets that have at least one candidate source, in the user's preset order. */
+ val presets: List = emptyList(),
+ /** False when every candidate is already enabled, or every source is enabled. */
+ val hasDisabledSources: Boolean = false,
+) {
+
+ data class PresetChoice(val id: Long, val title: String)
+
+ fun isAvailable(scope: AlternativeSourceScope): Boolean = when (scope) {
+ AlternativeSourceScope.Enabled -> true
+ AlternativeSourceScope.Disabled -> hasDisabledSources
+ is AlternativeSourceScope.Preset -> presets.any { it.id == scope.id }
+ }
+
+ fun presetTitle(id: Long): String? = presets.firstOrNull { it.id == id }?.title
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/AlternativesUseCase.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/AlternativesUseCase.kt
index 464b96d351..32b0aa528b 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/AlternativesUseCase.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/AlternativesUseCase.kt
@@ -1,5 +1,17 @@
package io.github.landwarderer.futon.alternatives.domain
+import io.github.landwarderer.futon.core.model.contentTypeCompat
+import io.github.landwarderer.futon.core.model.isNsfw
+import io.github.landwarderer.futon.core.model.primaryLanguage
+import io.github.landwarderer.futon.core.parser.MangaRepository
+import io.github.landwarderer.futon.core.parser.ParserMangaRepository
+import io.github.landwarderer.futon.core.prefs.AppSettings
+import io.github.landwarderer.futon.explore.data.MangaSourcesRepository
+import io.github.landwarderer.futon.explore.data.SourcePreset
+import io.github.landwarderer.futon.explore.data.SourcePresetsRepository
+import io.github.landwarderer.futon.search.domain.SearchKind
+import io.github.landwarderer.futon.search.domain.SearchV2Helper
+import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.channelFlow
import kotlinx.coroutines.flow.emptyFlow
@@ -7,48 +19,218 @@ import kotlinx.coroutines.launch
import kotlinx.coroutines.sync.Semaphore
import kotlinx.coroutines.sync.withPermit
import io.github.landwarderer.futon.core.model.isNovelSource
-import io.github.landwarderer.futon.core.parser.MangaRepository
import io.github.landwarderer.futon.core.util.ext.toLocale
-import io.github.landwarderer.futon.explore.data.MangaSourcesRepository
+import org.koitharu.kotatsu.parsers.config.ConfigKey
import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.parsers.model.MangaParserSource
import org.koitharu.kotatsu.parsers.model.MangaSource
import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
-import io.github.landwarderer.futon.search.domain.SearchKind
-import io.github.landwarderer.futon.search.domain.SearchV2Helper
import java.util.Locale
+import java.util.concurrent.atomic.AtomicInteger
import javax.inject.Inject
-private const val MAX_PARALLELISM = 4
+private const val MAX_PARALLELISM = 8
+private const val MAX_PER_SOURCE_PARALLELISM = 2
class AlternativesUseCase @Inject constructor(
private val sourcesRepository: MangaSourcesRepository,
private val searchHelperFactory: SearchV2Helper.Factory,
private val mangaRepositoryFactory: MangaRepository.Factory,
+ private val settings: AppSettings,
+ private val presetsRepository: SourcePresetsRepository,
) {
+ private val requestSemaphore = Semaphore(MAX_PARALLELISM)
+ private val webViewSemaphore = Semaphore(1)
+ private val sourceSemaphores = HashMap()
+ private val webViewSources = HashMap()
+
+ /** Searches the enabled or the disabled sources, in any language. */
suspend operator fun invoke(manga: Manga, throughDisabledSources: Boolean): Flow {
- val sources = getSources(manga.source, throughDisabledSources)
+ val sources = getCandidateSources(
+ ref = manga.source,
+ sourceScope = if (throughDisabledSources) AlternativeSourceScope.Disabled else AlternativeSourceScope.Enabled,
+ sameLanguageOnly = false,
+ )
+ return search(manga, sources, manga.title, loadDetails = true)
+ }
+
+ suspend operator fun invoke(
+ manga: Manga,
+ sourceScope: AlternativeSourceScope,
+ query: String = manga.title,
+ loadDetails: Boolean = true,
+ ): Flow {
+ val sources = getCandidateSources(
+ ref = manga.source,
+ sourceScope = sourceScope,
+ sameLanguageOnly = true,
+ )
+ return search(manga, sources, query, loadDetails)
+ }
+
+ /**
+ * @param loadDetails fetch each candidate's details page. Needed for chapter counts, but a caller
+ * that only wants what the search already returned - a cover, say - should pass `false`: it is one
+ * extra network round trip per result.
+ */
+ suspend operator fun invoke(
+ manga: Manga,
+ options: AlternativesSearchOptions,
+ loadDetails: Boolean = true,
+ ): Flow {
+ val query = options.query.trim()
+ if (query.isEmpty()) return emptyFlow()
+ val sources = getCandidateSources(
+ ref = manga.source,
+ sourceScope = options.sourceScope,
+ sameLanguageOnly = options.sameLanguageOnly,
+ sameContentTypeOnly = options.sameContentTypeOnly,
+ )
+ if (sources.isEmpty()) return emptyFlow()
+ return channelFlow {
+ val completedSources = AtomicInteger()
+ send(AlternativeSearchEvent.Progress(0, sources.size))
+ val workerCount = minOf(MAX_PARALLELISM, sources.size)
+ repeat(workerCount) { workerIndex ->
+ launch {
+ for (sourceIndex in workerIndex until sources.size step workerCount) {
+ val source = sources[sourceIndex]
+ try {
+ // Finish this source's candidate details before this worker starts another
+ // source, so chapter requests are not starved behind every source search.
+ coroutineScope {
+ search(
+ manga = manga,
+ sources = listOf(source),
+ query = query,
+ loadDetails = false,
+ ).collect { candidate ->
+ launch {
+ send(
+ AlternativeSearchEvent.Result(
+ if (loadDetails) loadDetails(candidate) else candidate,
+ ),
+ )
+ }
+ }
+ }
+ } finally {
+ send(
+ AlternativeSearchEvent.Progress(
+ completedSources = completedSources.incrementAndGet(),
+ totalSources = sources.size,
+ ),
+ )
+ }
+ }
+ }
+ }
+ }
+ }
+
+ suspend fun getCandidateSources(
+ ref: MangaSource,
+ sourceScope: AlternativeSourceScope,
+ sameLanguageOnly: Boolean = true,
+ sameContentTypeOnly: Boolean = false,
+ ): List {
+ val sources = when (sourceScope) {
+ is AlternativeSourceScope.Preset -> presetsRepository.getById(sourceScope.id)
+ ?.let { getPresetSources(it) }
+ .orEmpty()
+
+ AlternativeSourceScope.Enabled -> sourcesRepository.getEnabledSources()
+ AlternativeSourceScope.Disabled -> sourcesRepository.getDisabledSources().toList()
+ }
+ val skipNsfw = settings.isNsfwContentDisabled
+ return sources.asSequence()
+ .distinctBy(MangaSource::name)
+ .filter { it.name != ref.name }
+ .filter { it.isNovelSource == ref.isNovelSource }
+ .filterNot { skipNsfw && it.isNsfw() }
+ .filter { !sameLanguageOnly || it.hasSameLanguageAs(ref) }
+ .filter { !sameContentTypeOnly || it.hasSameContentTypeAs(ref) }
+ .sortedWith(compareByDescending { it.priority(ref) }.thenBy(MangaSource::name))
+ .toList()
+ }
+
+ suspend fun getSourceScopeOptions(
+ ref: MangaSource,
+ sameLanguageOnly: Boolean = false,
+ ): AlternativeSourceScopeOptions {
+ val skipNsfw = settings.isNsfwContentDisabled
+ fun MangaSource.isCandidate() = name != ref.name &&
+ isNovelSource == ref.isNovelSource &&
+ (!skipNsfw || !isNsfw()) &&
+ (!sameLanguageOnly || hasSameLanguageAs(ref))
+
+ // A preset with nothing searchable for this manga would only ever produce an empty screen.
+ val presets = presetsRepository.getAll()
+ .filter { preset -> getPresetSources(preset).any { it.isCandidate() } }
+ .map { AlternativeSourceScopeOptions.PresetChoice(it.id, it.title) }
+ val activePresetId = settings.activeSourcePresetId
+ return AlternativeSourceScopeOptions(
+ // The active preset when it has candidates, otherwise the enabled sources.
+ defaultScope = if (presets.any { it.id == activePresetId }) {
+ AlternativeSourceScope.Preset(activePresetId)
+ } else {
+ AlternativeSourceScope.Enabled
+ },
+ presets = presets,
+ hasDisabledSources = sourcesRepository.getDisabledSources().any { it.isCandidate() },
+ )
+ }
+
+ suspend fun searchSource(
+ manga: Manga,
+ source: MangaSource,
+ query: String = manga.title,
+ loadDetails: Boolean = true,
+ onFailure: (() -> Unit)? = null,
+ ): Flow = if (source.name == manga.source.name) {
+ emptyFlow()
+ } else {
+ search(
+ manga = manga,
+ sources = listOf(source),
+ query = query,
+ loadDetails = loadDetails,
+ onSourceFailure = { onFailure?.invoke() },
+ )
+ }
+
+ fun isWebViewSource(source: MangaSource): Boolean = source.usesWebView()
+
+ private fun search(
+ manga: Manga,
+ sources: List,
+ query: String,
+ loadDetails: Boolean,
+ onSourceFailure: (MangaSource) -> Unit = {},
+ ): Flow {
if (sources.isEmpty()) {
return emptyFlow()
}
- val semaphore = Semaphore(MAX_PARALLELISM)
return channelFlow {
for (source in sources) {
launch {
val searchHelper = searchHelperFactory.create(source)
- val list = runCatchingCancellable {
- semaphore.withPermit {
- searchHelper(manga.title, SearchKind.TITLE)?.manga
+ val searchResult = runCatchingCancellable {
+ withSourcePermit(source) {
+ searchHelper(query, SearchKind.TITLE)?.manga
}
- }.getOrNull()
- list?.forEach { m ->
+ }
+ if (searchResult.isFailure) {
+ onSourceFailure(source)
+ }
+ searchResult.getOrNull()?.forEach { m ->
if (m.id != manga.id) {
- launch {
- val details = runCatchingCancellable {
- mangaRepositoryFactory.create(m.source).getDetails(m)
- }.getOrDefault(m)
- send(details)
+ if (loadDetails) {
+ launch {
+ send(loadDetails(m))
+ }
+ } else {
+ send(m)
}
}
}
@@ -57,24 +239,70 @@ class AlternativesUseCase @Inject constructor(
}
}
- private suspend fun getSources(ref: MangaSource, disabled: Boolean): List = if (disabled) {
- sourcesRepository.getDisabledSources()
- } else {
- sourcesRepository.getEnabledSources()
- }.filter { it.isNovelSource == ref.isNovelSource }
- .sortedByDescending { it.priority(ref) }
+ private suspend fun loadDetails(manga: Manga): Manga = runCatchingCancellable {
+ withSourcePermit(manga.source) {
+ mangaRepositoryFactory.create(manga.source).getDetails(manga)
+ }
+ }.getOrDefault(manga)
+
+ private suspend fun withSourcePermit(source: MangaSource, block: suspend () -> T): T {
+ return source.requestSemaphore().withPermit {
+ if (source.usesWebView()) {
+ webViewSemaphore.withPermit {
+ requestSemaphore.withPermit { block() }
+ }
+ } else {
+ requestSemaphore.withPermit { block() }
+ }
+ }
+ }
+
+ private fun MangaSource.requestSemaphore(): Semaphore = synchronized(sourceSemaphores) {
+ sourceSemaphores.getOrPut(name) {
+ Semaphore(if (usesWebView()) 1 else MAX_PER_SOURCE_PARALLELISM)
+ }
+ }
+
+ /** Sources that load through a WebView cannot run in parallel without starving each other. */
+ private fun MangaSource.usesWebView(): Boolean = synchronized(webViewSources) {
+ webViewSources.getOrPut(name) {
+ val repository = mangaRepositoryFactory.create(this)
+ (repository as? ParserMangaRepository)
+ ?.getConfigKeys()
+ ?.filterIsInstance()
+ ?.any { it.defaultValue } == true
+ }
+ }
+
+ private suspend fun getPresetSources(preset: SourcePreset): List {
+ return sourcesRepository.getPresetSources(preset)
+ }
+
+ private fun MangaSource.hasSameLanguageAs(ref: MangaSource): Boolean {
+ val refLanguage = ref.primaryLanguage ?: return true
+ // Multilingual sources (and Mihon "all" extensions) may well carry the title in that language.
+ val language = primaryLanguage ?: return true
+ return language == refLanguage
+ }
+
+ private fun MangaSource.hasSameContentTypeAs(ref: MangaSource): Boolean {
+ val type = contentTypeCompat ?: return false
+ return type == ref.contentTypeCompat
+ }
private fun MangaSource.priority(ref: MangaSource): Int {
var res = 0
- if (this is MangaParserSource && ref is MangaParserSource) {
- if (locale == ref.locale) {
+ val language = primaryLanguage
+ if (language != null) {
+ if (language == ref.primaryLanguage) {
res += 4
- } else if (locale.toLocale() == Locale.getDefault()) {
+ } else if (language == Locale.getDefault().language) {
res += 2
}
- if (contentType == ref.contentType) {
- res++
- }
+ }
+ val type = contentTypeCompat
+ if (type != null && type == ref.contentTypeCompat) {
+ res++
}
return res
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/AutoFixUseCase.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/AutoFixUseCase.kt
index cc053f11e7..7ac1a74284 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/AutoFixUseCase.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/AutoFixUseCase.kt
@@ -15,7 +15,6 @@ import io.github.landwarderer.futon.core.model.chaptersCount
import io.github.landwarderer.futon.core.model.parcelable.ParcelableManga
import io.github.landwarderer.futon.core.parser.MangaDataRepository
import io.github.landwarderer.futon.core.parser.MangaRepository
-import io.github.landwarderer.futon.core.util.ext.concat
import org.koitharu.kotatsu.parsers.model.Manga
import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
import java.util.concurrent.TimeUnit
@@ -36,8 +35,11 @@ class AutoFixUseCase @Inject constructor(
if (seed.isHealthy()) {
return seed to null // no fix required
}
- val replacement = alternativesUseCase(seed, throughDisabledSources = false)
- .concat(alternativesUseCase(seed, throughDisabledSources = true))
+ val sourceScope = alternativesUseCase.getSourceScopeOptions(
+ ref = seed.source,
+ sameLanguageOnly = true,
+ ).defaultScope
+ val replacement = alternativesUseCase(seed, sourceScope = sourceScope)
.filter { it.isHealthy() }
.runningFold(null) { best, candidate ->
if (best == null || best < candidate) {
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/SourceReplacementMatching.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/SourceReplacementMatching.kt
new file mode 100644
index 0000000000..b118e29791
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/SourceReplacementMatching.kt
@@ -0,0 +1,58 @@
+package io.github.landwarderer.futon.alternatives.domain
+
+import io.github.landwarderer.futon.core.model.chaptersCount
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.util.levenshteinDistance
+import java.util.Locale
+import kotlin.math.roundToInt
+
+/** The pure scoring rules behind [SourceReplacementPlannerUseCase]. */
+internal object SourceReplacementMatching {
+
+ /** Best similarity, 0..1, between any title (main or alternative) of [candidate] and of [reference]. */
+ fun titleSimilarity(candidate: Manga, reference: Manga): Float {
+ val candidateTitles = (listOf(candidate.title) + candidate.altTitles).filter(String::isNotBlank)
+ val referenceTitles = (listOf(reference.title) + reference.altTitles).filter(String::isNotBlank)
+ return candidateTitles.maxOfOrNull { title ->
+ referenceTitles.maxOfOrNull { ref -> normalizedSimilarity(title, ref) } ?: 0f
+ } ?: 0f
+ }
+
+ fun normalizedSimilarity(first: String, second: String): Float {
+ val a = first.trim().lowercase(Locale.ROOT)
+ val b = second.trim().lowercase(Locale.ROOT)
+ val maxLength = maxOf(a.length, b.length)
+ return if (maxLength == 0) 1f else 1f - a.levenshteinDistance(b).toFloat() / maxLength
+ }
+
+ /** True when a candidate with [similarity]/[chapters] beats the current best one. */
+ fun isBetter(similarity: Float, chapters: Int, bestSimilarity: Float, bestChapters: Int): Boolean {
+ return similarity > bestSimilarity || (similarity == bestSimilarity && chapters > bestChapters)
+ }
+
+ fun isBetter(candidate: Manga, candidateSimilarity: Float, best: Manga, bestSimilarity: Float): Boolean =
+ isBetter(candidateSimilarity, candidate.chaptersCount(), bestSimilarity, best.chaptersCount())
+
+ /**
+ * Up to [limit] titles spread evenly across the alphabet, so a large library is compared on a sample
+ * that is not biased towards whatever was read last.
+ */
+ fun representativeSample(manga: List, limit: Int): List {
+ if (manga.size <= limit) {
+ return manga
+ }
+ if (limit <= 1) {
+ return manga.take(limit)
+ }
+ val sorted = manga.sortedBy { it.title.lowercase(Locale.ROOT) }
+ return List(limit) { index ->
+ val position = index.toDouble() * sorted.lastIndex / (limit - 1)
+ sorted[position.roundToInt()]
+ }.distinctBy(Manga::id)
+ }
+
+ /** Sources with the most matches first, then the closest titles. */
+ val planComparator: Comparator =
+ compareByDescending { it.matchedCount }
+ .thenByDescending(SourceReplacementPlan::averageTitleSimilarity)
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/SourceReplacementPlannerUseCase.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/SourceReplacementPlannerUseCase.kt
new file mode 100644
index 0000000000..96d5c41e3d
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/domain/SourceReplacementPlannerUseCase.kt
@@ -0,0 +1,244 @@
+package io.github.landwarderer.futon.alternatives.domain
+
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.withTimeoutOrNull
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+import javax.inject.Inject
+
+private const val MAX_COMPARISON_SAMPLE = 25
+private const val MAX_COMPARISON_PARALLELISM_PER_SOURCE = 2
+private const val MAX_COMPARISON_TIMEOUTS_PER_SOURCE = 2
+private const val COMPARISON_REQUEST_TIMEOUT_MS = 15_000L
+private const val WEBVIEW_COMPARISON_REQUEST_TIMEOUT_MS = 30_000L
+
+/**
+ * Works out which sources can take over a set of titles: it searches a representative sample of the
+ * titles on every candidate source and ranks the sources by how many of them they have.
+ */
+class SourceReplacementPlannerUseCase @Inject constructor(
+ private val alternativesUseCase: AlternativesUseCase,
+) {
+
+ suspend operator fun invoke(
+ manga: List,
+ sourceScope: AlternativeSourceScope,
+ excludedSourceNames: Set = emptySet(),
+ onProgress: (SourceComparisonProgress) -> Unit = {},
+ onSourceFailed: (MangaSource) -> Unit = {},
+ ): List = coroutineScope {
+ val seeds = SourceReplacementMatching.representativeSample(manga.distinctBy(Manga::id), MAX_COMPARISON_SAMPLE)
+ if (seeds.isEmpty()) {
+ return@coroutineScope emptyList()
+ }
+ val sources = alternativesUseCase.getCandidateSources(
+ ref = seeds.first().source,
+ sourceScope = sourceScope,
+ sameLanguageOnly = true,
+ ).filter { it.name !in excludedSourceNames }
+ val totalChecks = sources.size * seeds.size
+ val progressLock = Any()
+ var completedChecks = 0
+ var completedSources = 0
+ fun reportProgress(titleCompleted: Boolean = false, sourceCompleted: Boolean = false) {
+ synchronized(progressLock) {
+ if (titleCompleted) completedChecks++
+ if (sourceCompleted) completedSources++
+ onProgress(
+ SourceComparisonProgress(
+ completedChecks = completedChecks,
+ totalChecks = totalChecks,
+ remainingSources = sources.size - completedSources,
+ totalSources = sources.size,
+ sampleSize = seeds.size,
+ ),
+ )
+ }
+ }
+ reportProgress()
+ val plans = sources.map { source ->
+ async {
+ val comparison = compareSource(source, seeds) {
+ reportProgress(titleCompleted = true)
+ }
+ if (comparison.failed) {
+ // The very first request already failed: the source is down, blocked or needs a captcha.
+ synchronized(progressLock) {
+ onSourceFailed(source)
+ }
+ null
+ } else {
+ SourceReplacementPlan(
+ source = source,
+ matches = comparison.matches.mapValues { it.value.manga },
+ total = seeds.size,
+ averageTitleSimilarity = comparison.matches.values
+ .map(ScoredMatch::titleSimilarity)
+ .takeIf(List::isNotEmpty)
+ ?.average()
+ ?.toFloat()
+ ?: 0f,
+ )
+ }.also { reportProgress(sourceCompleted = true) }
+ }
+ }.awaitAll().filterNotNull()
+ plans.filter { it.matchedCount > 0 }.sortedWith(SourceReplacementMatching.planComparator)
+ }
+
+ /** Finds the best match for each of [manga] on [source], skipping the ones in [knownMatches]. */
+ suspend fun resolve(
+ manga: List,
+ source: MangaSource,
+ knownMatches: Map = emptyMap(),
+ onProgress: (completed: Int, total: Int) -> Unit = { _, _ -> },
+ ): Map = coroutineScope {
+ val seeds = manga.distinctBy(Manga::id)
+ val seedIds = seeds.mapTo(HashSet(), Manga::id)
+ val result = knownMatches.filterKeys(seedIds::contains).toMutableMap()
+ val completed = AtomicInteger(result.size)
+ onProgress(completed.get(), seeds.size)
+ val resolved = seeds.filterNot { it.id in result }.map { seed ->
+ async {
+ findMatch(seed, source).also {
+ onProgress(completed.incrementAndGet(), seeds.size)
+ }
+ }
+ }.awaitAll()
+ resolved.filterNotNull().forEach { match -> result[match.seedId] = match.manga }
+ result
+ }
+
+ private suspend fun compareSource(
+ source: MangaSource,
+ seeds: List,
+ onTitleChecked: () -> Unit,
+ ): SourceComparisonResult {
+ val isWebView = alternativesUseCase.isWebViewSource(source)
+ val parallelism = if (isWebView) 1 else MAX_COMPARISON_PARALLELISM_PER_SOURCE
+ val timeout = if (isWebView) WEBVIEW_COMPARISON_REQUEST_TIMEOUT_MS else COMPARISON_REQUEST_TIMEOUT_MS
+ val matches = HashMap()
+ val initialOutcome = compareTitle(source, seeds.first(), timeout)
+ onTitleChecked()
+ initialOutcome.match?.let { match -> matches[match.seedId] = match }
+ if (initialOutcome.failed) {
+ repeat(seeds.size - 1) { onTitleChecked() }
+ return SourceComparisonResult(matches = matches, failed = true)
+ }
+ var processed = 1
+ var timeouts = 0
+ for (batch in seeds.drop(1).chunked(parallelism)) {
+ if (timeouts >= MAX_COMPARISON_TIMEOUTS_PER_SOURCE) {
+ break
+ }
+ val outcomes = coroutineScope {
+ batch.map { seed ->
+ async { compareTitle(source, seed, timeout) }
+ }.awaitAll()
+ }
+ processed += batch.size
+ outcomes.forEach { outcome ->
+ onTitleChecked()
+ if (outcome.timedOut) {
+ timeouts++
+ }
+ outcome.match?.let { match -> matches[match.seedId] = match }
+ }
+ }
+ repeat(seeds.size - processed) { onTitleChecked() }
+ return SourceComparisonResult(matches = matches, failed = false)
+ }
+
+ private suspend fun compareTitle(
+ source: MangaSource,
+ seed: Manga,
+ timeout: Long,
+ ): ComparisonOutcome {
+ val requestFailed = AtomicBoolean(false)
+ return withTimeoutOrNull(timeout) {
+ ComparisonOutcome(
+ match = findMatch(
+ seed = seed,
+ source = source,
+ loadDetails = false,
+ onFailure = { requestFailed.set(true) },
+ ),
+ timedOut = false,
+ failed = requestFailed.get(),
+ )
+ } ?: ComparisonOutcome(match = null, timedOut = true, failed = true)
+ }
+
+ private suspend fun findMatch(
+ seed: Manga,
+ source: MangaSource,
+ loadDetails: Boolean = true,
+ onFailure: (() -> Unit)? = null,
+ ): ScoredMatch? {
+ var best: ScoredMatch? = null
+ alternativesUseCase.searchSource(
+ manga = seed,
+ source = source,
+ loadDetails = loadDetails,
+ onFailure = onFailure,
+ ).collect { candidate ->
+ val scored = ScoredMatch(
+ seedId = seed.id,
+ manga = candidate,
+ titleSimilarity = SourceReplacementMatching.titleSimilarity(candidate, seed),
+ )
+ val current = best
+ if (current == null || SourceReplacementMatching.isBetter(
+ candidate = scored.manga,
+ candidateSimilarity = scored.titleSimilarity,
+ best = current.manga,
+ bestSimilarity = current.titleSimilarity,
+ )
+ ) {
+ best = scored
+ }
+ }
+ return best
+ }
+
+ private data class ScoredMatch(
+ val seedId: Long,
+ val manga: Manga,
+ val titleSimilarity: Float,
+ )
+
+ private data class ComparisonOutcome(
+ val match: ScoredMatch?,
+ val timedOut: Boolean,
+ val failed: Boolean,
+ )
+
+ private data class SourceComparisonResult(
+ val matches: Map,
+ val failed: Boolean,
+ )
+}
+
+data class SourceReplacementPlan(
+ val source: MangaSource,
+ val matches: Map,
+ val total: Int,
+ val averageTitleSimilarity: Float,
+) {
+ val matchedCount: Int
+ get() = matches.size
+
+ val matchRate: Float
+ get() = if (total == 0) 0f else matchedCount.toFloat() / total
+}
+
+data class SourceComparisonProgress(
+ val completedChecks: Int,
+ val totalChecks: Int,
+ val remainingSources: Int,
+ val totalSources: Int,
+ val sampleSize: Int,
+)
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/AlternativeAD.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/AlternativeAD.kt
index 8d478c9396..69983e82fa 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/AlternativeAD.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/AlternativeAD.kt
@@ -1,6 +1,7 @@
package io.github.landwarderer.futon.alternatives.ui
import android.text.style.ForegroundColorSpan
+import androidx.appcompat.widget.TooltipCompat
import androidx.core.content.ContextCompat
import androidx.core.text.buildSpannedString
import androidx.core.text.inSpans
@@ -49,6 +50,14 @@ fun alternativeAD(
bind { payloads ->
binding.textViewTitle.text = item.mangaModel.title
+ val migrationTooltip = when {
+ !item.isMigrationEnabled -> context.getString(R.string.migration_unavailable_search_in_progress)
+ item.chaptersCount == 0 -> context.getString(R.string.migration_unavailable_no_chapters)
+ else -> null
+ }
+ binding.buttonMigrate.isEnabled = migrationTooltip == null
+ TooltipCompat.setTooltipText(binding.buttonMigrate, migrationTooltip)
+ binding.buttonMigrate.contentDescription = migrationTooltip ?: context.getString(R.string.migrate)
with(binding.iconsView) {
clearIcons()
if (item.mangaModel.isSaved) addIcon(R.drawable.ic_storage)
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/AlternativesActivity.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/AlternativesActivity.kt
index f73333623a..02f567973b 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/AlternativesActivity.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/AlternativesActivity.kt
@@ -1,22 +1,32 @@
package io.github.landwarderer.futon.alternatives.ui
import android.os.Bundle
+import android.view.Menu
import android.view.View
import android.widget.Toast
import androidx.activity.viewModels
+import androidx.appcompat.widget.PopupMenu
import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.isVisible
import androidx.core.view.updatePadding
import coil3.ImageLoader
+import com.google.android.material.chip.Chip
import dagger.hilt.android.AndroidEntryPoint
import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.alternatives.domain.AlternativeSearchStatus
+import io.github.landwarderer.futon.alternatives.domain.AlternativeSortOrder
import io.github.landwarderer.futon.core.exceptions.resolve.SnackbarErrorObserver
import io.github.landwarderer.futon.core.model.getTitle
+import io.github.landwarderer.futon.core.model.languageCode
import io.github.landwarderer.futon.core.nav.router
import io.github.landwarderer.futon.core.ui.BaseActivity
import io.github.landwarderer.futon.core.ui.BaseListAdapter
import io.github.landwarderer.futon.core.ui.dialog.buildAlertDialog
import io.github.landwarderer.futon.core.ui.list.OnListItemClickListener
+import io.github.landwarderer.futon.core.ui.util.OptionsMenuBadgeHelper
+import io.github.landwarderer.futon.core.ui.widgets.ChipsView
import io.github.landwarderer.futon.core.util.ext.consumeAllSystemBarsInsets
+import io.github.landwarderer.futon.core.util.ext.getQuantityStringSafe
import io.github.landwarderer.futon.core.util.ext.observe
import io.github.landwarderer.futon.core.util.ext.observeEvent
import io.github.landwarderer.futon.core.util.ext.systemBarsInsets
@@ -24,37 +34,45 @@ import io.github.landwarderer.futon.databinding.ActivityAlternativesBinding
import io.github.landwarderer.futon.list.ui.adapter.ListItemType
import io.github.landwarderer.futon.list.ui.adapter.ListStateHolderListener
import io.github.landwarderer.futon.list.ui.adapter.TypedListSpacingDecoration
-import io.github.landwarderer.futon.list.ui.adapter.buttonFooterAD
import io.github.landwarderer.futon.list.ui.adapter.emptyStateListAD
import io.github.landwarderer.futon.list.ui.adapter.loadingFooterAD
import io.github.landwarderer.futon.list.ui.adapter.loadingStateAD
import io.github.landwarderer.futon.list.ui.model.ListModel
import org.koitharu.kotatsu.parsers.model.Manga
import javax.inject.Inject
+import androidx.appcompat.R as appcompatR
@AndroidEntryPoint
class AlternativesActivity : BaseActivity(),
ListStateHolderListener,
- OnListItemClickListener {
+ OnListItemClickListener,
+ ChipsView.OnChipClickListener,
+ ChipsView.OnChipCloseClickListener {
@Inject
lateinit var coil: ImageLoader
private val viewModel by viewModels()
+ private lateinit var filterBadge: OptionsMenuBadgeHelper
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(ActivityAlternativesBinding.inflate(layoutInflater))
- supportActionBar?.run {
- setDisplayHomeAsUpEnabled(true)
- subtitle = viewModel.manga.title
- }
+ supportActionBar?.setDisplayHomeAsUpEnabled(true)
+ viewBinding.planningProgressContainer.isVisible = false
+ viewBinding.summaryContainer.isVisible = false
+ viewBinding.recyclerView.isVisible = true
+ supportActionBar?.subtitle = buildReferenceSubtitle(MangaAlternativeReference(viewModel.manga))
+ addMenuProvider(AlternativesMenuProvider(this, viewModel))
+ filterBadge = OptionsMenuBadgeHelper(viewBinding.toolbar, R.id.action_alternatives_filter)
+ viewBinding.chipsSummary.onChipClickListener = this
+ viewBinding.chipsSummary.onChipCloseClickListener = this
+
val listAdapter = BaseListAdapter()
.addDelegate(ListItemType.MANGA_LIST_DETAILED, alternativeAD(coil, this, this))
.addDelegate(ListItemType.STATE_EMPTY, emptyStateListAD(null))
.addDelegate(ListItemType.FOOTER_LOADING, loadingFooterAD())
.addDelegate(ListItemType.STATE_LOADING, loadingStateAD())
- .addDelegate(ListItemType.FOOTER_BUTTON, buttonFooterAD(this))
with(viewBinding.recyclerView) {
setHasFixedSize(true)
addItemDecoration(TypedListSpacingDecoration(context, addHorizontalPadding = false))
@@ -63,6 +81,22 @@ class AlternativesActivity : BaseActivity(),
viewModel.onError.observeEvent(this, SnackbarErrorObserver(viewBinding.recyclerView, null))
viewModel.list.observe(this, listAdapter)
+ viewModel.options.observe(this) {
+ updateSummaryChips()
+ viewBinding.toolbar.post { filterBadge.setBadgeVisible(viewModel.hasCustomOptions()) }
+ invalidateMenu()
+ }
+ viewModel.scopeOptions.observe(this) {
+ updateSummaryChips()
+ invalidateMenu()
+ }
+ viewModel.searchStatus.observe(this) {
+ updateSearchProgress(it)
+ updateSummaryChips()
+ }
+ viewModel.referenceManga.observe(this) {
+ supportActionBar?.subtitle = buildReferenceSubtitle(it)
+ }
viewModel.onMigrated.observeEvent(this) {
Toast.makeText(this, R.string.migration_completed, Toast.LENGTH_SHORT).show()
router.openDetails(it)
@@ -70,10 +104,7 @@ class AlternativesActivity : BaseActivity(),
}
}
- override fun onApplyWindowInsets(
- v: View,
- insets: WindowInsetsCompat
- ): WindowInsetsCompat {
+ override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
val barsInsets = insets.systemBarsInsets
viewBinding.recyclerView.updatePadding(
left = barsInsets.left,
@@ -90,8 +121,10 @@ class AlternativesActivity : BaseActivity(),
override fun onItemClick(item: MangaAlternativeModel, view: View) {
when (view.id) {
- R.id.chip_source -> router.openSearch(item.manga.source, viewModel.manga.title)
- R.id.button_migrate -> confirmMigration(item.manga)
+ R.id.chip_source -> router.openSearch(item.manga.source, viewModel.options.value.query)
+ R.id.button_migrate -> if (item.isMigrationEnabled && item.chaptersCount > 0) {
+ confirmMigration(item.manga)
+ }
else -> router.openDetails(item.manga)
}
}
@@ -100,7 +133,61 @@ class AlternativesActivity : BaseActivity(),
override fun onEmptyActionClick() = Unit
- override fun onFooterButtonClick() = viewModel.continueSearch()
+ override fun onChipClick(chip: Chip, data: Any?) {
+ when (data as? SummaryChip) {
+ SummaryChip.QUERY -> viewBinding.toolbar.menu.findItem(R.id.action_search)?.expandActionView()
+ SummaryChip.SOURCE_SCOPE -> showSourceScopeMenu(chip)
+ SummaryChip.SORT -> showSortMenu(chip)
+ SummaryChip.RESET -> viewModel.resetOptions()
+ SummaryChip.STATUS, null -> Unit
+ else -> viewBinding.toolbar.menu.performIdentifierAction(R.id.action_alternatives_filter, 0)
+ }
+ }
+
+ private fun showSourceScopeMenu(anchor: View) {
+ PopupMenu(this, anchor).apply {
+ val scopeOptions = viewModel.scopeOptions.value
+ SourceScopeMenu.populate(menu, POPUP_GROUP, scopeOptions, viewModel.options.value.sourceScope)
+ setOnMenuItemClickListener { item ->
+ val scope = SourceScopeMenu.scopeFor(item.itemId, scopeOptions)
+ ?: return@setOnMenuItemClickListener false
+ viewModel.setSourceScope(scope)
+ true
+ }
+ show()
+ }
+ }
+
+ private fun showSortMenu(anchor: View) {
+ PopupMenu(this, anchor).apply {
+ AlternativeSortOrder.entries.forEachIndexed { index, sortOrder ->
+ menu.add(POPUP_GROUP, ACTION_SORT_FIRST + index, index, sortOrder.titleRes).apply {
+ isChecked = viewModel.options.value.sortOrder == sortOrder
+ }
+ }
+ menu.setGroupCheckable(POPUP_GROUP, true, true)
+ setOnMenuItemClickListener { item ->
+ val sortOrder = AlternativeSortOrder.entries.getOrNull(item.itemId - ACTION_SORT_FIRST)
+ ?: return@setOnMenuItemClickListener false
+ viewModel.setSortOrder(sortOrder)
+ true
+ }
+ show()
+ }
+ }
+
+ override fun onChipCloseClick(chip: Chip, data: Any?) {
+ when (data as? SummaryChip) {
+ SummaryChip.QUERY -> viewModel.setQuery(viewModel.manga.title)
+ SummaryChip.SOURCE_SCOPE -> viewModel.setSourceScope(viewModel.defaultScopeForReset())
+ SummaryChip.LANGUAGE -> viewModel.setSameLanguageOnly(false)
+ SummaryChip.CONTENT_TYPE -> viewModel.setSameContentTypeOnly(false)
+ SummaryChip.HAS_CHAPTERS -> viewModel.setHideNoChapters(false)
+ SummaryChip.SORT -> viewModel.setSortOrder(AlternativeSortOrder.BEST_MATCH)
+ SummaryChip.RESET -> viewModel.resetOptions()
+ SummaryChip.STATUS, null -> Unit
+ }
+ }
private fun confirmMigration(target: Manga) {
buildAlertDialog(this, isCentered = true) {
@@ -116,9 +203,131 @@ class AlternativesActivity : BaseActivity(),
),
)
setNegativeButton(android.R.string.cancel, null)
- setPositiveButton(R.string.migrate) { _, _ ->
- viewModel.migrate(target)
- }
+ setPositiveButton(R.string.migrate) { _, _ -> viewModel.migrate(target) }
}.show()
}
+
+ private fun buildReferenceSubtitle(reference: MangaAlternativeReference): String = buildList {
+ add(reference.manga.source.getTitle(this@AlternativesActivity))
+ reference.manga.source.languageCode?.uppercase()?.let(::add)
+ add(
+ resources.getQuantityStringSafe(
+ R.plurals.chapters,
+ reference.chaptersCount,
+ reference.chaptersCount,
+ ),
+ )
+ }.joinToString(" • ")
+
+ private fun updateSummaryChips() {
+ val options = viewModel.options.value
+ val status = viewModel.searchStatus.value
+ val resultCount = resources.getQuantityString(
+ R.plurals.search_results_count,
+ status.resultsCount,
+ status.resultsCount,
+ )
+ val statusText = when {
+ !status.isRunning -> resultCount
+ status.totalSources == 0 -> getString(R.string.preparing_search)
+ else -> getString(R.string.searching_sources_progress, status.completedSources, status.totalSources)
+ }
+ val sourceScopeTitle = SourceScopeMenu.title(this, options.sourceScope, viewModel.scopeOptions.value)
+ viewBinding.chipsSummary.setChips(
+ buildList {
+ add(
+ ChipsView.ChipModel(
+ title = options.query,
+ icon = appcompatR.drawable.abc_ic_search_api_material,
+ isCloseable = options.query != viewModel.manga.title,
+ data = SummaryChip.QUERY,
+ ),
+ )
+ add(ChipsView.ChipModel(title = statusText, isLoading = status.isRunning, data = SummaryChip.STATUS))
+ add(
+ ChipsView.ChipModel(
+ title = sourceScopeTitle,
+ icon = R.drawable.ic_manga_source,
+ isCloseable = options.sourceScope != viewModel.defaultScopeForReset(),
+ data = SummaryChip.SOURCE_SCOPE,
+ ),
+ )
+ if (options.sameLanguageOnly) add(
+ ChipsView.ChipModel(
+ titleResId = R.string.same_language,
+ icon = R.drawable.ic_language,
+ isCloseable = true,
+ data = SummaryChip.LANGUAGE,
+ ),
+ )
+ if (options.sameContentTypeOnly) add(
+ ChipsView.ChipModel(
+ titleResId = R.string.same_content_type,
+ isCloseable = true,
+ data = SummaryChip.CONTENT_TYPE,
+ ),
+ )
+ if (options.hideNoChapters) add(
+ ChipsView.ChipModel(
+ titleResId = R.string.has_chapters,
+ icon = R.drawable.ic_current_chapter,
+ isCloseable = true,
+ data = SummaryChip.HAS_CHAPTERS,
+ ),
+ )
+ add(
+ ChipsView.ChipModel(
+ titleResId = options.sortOrder.titleRes,
+ icon = R.drawable.ic_sort_desc,
+ isCloseable = options.sortOrder != AlternativeSortOrder.BEST_MATCH,
+ data = SummaryChip.SORT,
+ ),
+ )
+ if (viewModel.hasCustomOptions()) add(
+ ChipsView.ChipModel(
+ titleResId = R.string.reset,
+ icon = R.drawable.ic_clear_all,
+ data = SummaryChip.RESET,
+ ),
+ )
+ },
+ )
+ }
+
+ private fun updateSearchProgress(status: AlternativeSearchStatus) {
+ with(viewBinding.progressSources) {
+ if (status.totalSources > 0) {
+ isIndeterminate = false
+ max = status.totalSources
+ setProgressCompat(status.completedSources.coerceAtMost(status.totalSources), true)
+ } else {
+ isIndeterminate = true
+ }
+ isVisible = status.isRunning
+ }
+ }
+
+ private val AlternativeSortOrder.titleRes: Int
+ get() = when (this) {
+ AlternativeSortOrder.BEST_MATCH -> R.string.best_match
+ AlternativeSortOrder.MOST_CHAPTERS -> R.string.most_chapters
+ AlternativeSortOrder.CLOSEST_CHAPTER_COUNT -> R.string.closest_chapter_count
+ AlternativeSortOrder.SOURCE_PRIORITY -> R.string.source_priority
+ }
+
+ private enum class SummaryChip {
+ QUERY,
+ SOURCE_SCOPE,
+ LANGUAGE,
+ CONTENT_TYPE,
+ HAS_CHAPTERS,
+ SORT,
+ STATUS,
+ RESET,
+ }
+
+ private companion object {
+ const val POPUP_GROUP = Menu.FIRST + 2000
+ const val ACTION_SORT_FIRST = Menu.FIRST + 2010
+ }
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/AlternativesMenuProvider.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/AlternativesMenuProvider.kt
new file mode 100644
index 0000000000..2c4b1d8d08
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/AlternativesMenuProvider.kt
@@ -0,0 +1,87 @@
+package io.github.landwarderer.futon.alternatives.ui
+
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
+import androidx.appcompat.widget.SearchView
+import androidx.core.view.MenuProvider
+import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.alternatives.domain.AlternativeSortOrder
+
+class AlternativesMenuProvider(
+ private val activity: AlternativesActivity,
+ private val viewModel: AlternativesViewModel,
+) : MenuProvider, MenuItem.OnActionExpandListener, SearchView.OnQueryTextListener {
+
+ override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
+ menuInflater.inflate(R.menu.opt_regular_alternatives, menu)
+ val searchItem = menu.findItem(R.id.action_search)
+ searchItem.setOnActionExpandListener(this)
+ (searchItem.actionView as SearchView).run {
+ setOnQueryTextListener(this@AlternativesMenuProvider)
+ queryHint = activity.getString(R.string.search_manga)
+ }
+ }
+
+ override fun onPrepareMenu(menu: Menu) {
+ val options = viewModel.options.value
+ menu.findItem(R.id.action_alternatives_sources)?.subMenu?.let { sourcesMenu ->
+ sourcesMenu.clear()
+ SourceScopeMenu.populate(sourcesMenu, SOURCES_GROUP, viewModel.scopeOptions.value, options.sourceScope)
+ }
+ menu.findItem(R.id.action_alternatives_reset)?.isVisible = viewModel.hasCustomOptions()
+ menu.findItem(R.id.action_alternatives_same_language)?.isChecked = options.sameLanguageOnly
+ menu.findItem(R.id.action_alternatives_same_content_type)?.isChecked = options.sameContentTypeOnly
+ menu.findItem(R.id.action_alternatives_hide_no_chapters)?.isChecked = options.hideNoChapters
+ menu.findItem(
+ when (options.sortOrder) {
+ AlternativeSortOrder.BEST_MATCH -> R.id.action_alternatives_sort_best_match
+ AlternativeSortOrder.MOST_CHAPTERS -> R.id.action_alternatives_sort_most_chapters
+ AlternativeSortOrder.CLOSEST_CHAPTER_COUNT -> R.id.action_alternatives_sort_closest_chapters
+ AlternativeSortOrder.SOURCE_PRIORITY -> R.id.action_alternatives_sort_source_priority
+ },
+ )?.isChecked = true
+ }
+
+ override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
+ val options = viewModel.options.value
+ when (menuItem.itemId) {
+
+ R.id.action_alternatives_same_language -> viewModel.setSameLanguageOnly(!options.sameLanguageOnly)
+ R.id.action_alternatives_same_content_type -> viewModel.setSameContentTypeOnly(!options.sameContentTypeOnly)
+ R.id.action_alternatives_hide_no_chapters -> viewModel.setHideNoChapters(!options.hideNoChapters)
+ R.id.action_alternatives_sort_best_match -> viewModel.setSortOrder(AlternativeSortOrder.BEST_MATCH)
+ R.id.action_alternatives_sort_most_chapters -> viewModel.setSortOrder(AlternativeSortOrder.MOST_CHAPTERS)
+ R.id.action_alternatives_sort_closest_chapters ->
+ viewModel.setSortOrder(AlternativeSortOrder.CLOSEST_CHAPTER_COUNT)
+
+ R.id.action_alternatives_sort_source_priority -> viewModel.setSortOrder(AlternativeSortOrder.SOURCE_PRIORITY)
+ R.id.action_alternatives_reset -> viewModel.resetOptions()
+ else -> viewModel.setSourceScope(
+ SourceScopeMenu.scopeFor(menuItem.itemId, viewModel.scopeOptions.value) ?: return false,
+ )
+ }
+ activity.invalidateMenu()
+ return true
+ }
+
+ override fun onQueryTextSubmit(query: String?): Boolean {
+ query?.takeIf(String::isNotBlank)?.let(viewModel::setQuery)
+ return true
+ }
+
+ override fun onQueryTextChange(newText: String?): Boolean = false
+
+ override fun onMenuItemActionExpand(item: MenuItem): Boolean {
+ (item.actionView as? SearchView)?.post {
+ (item.actionView as? SearchView)?.setQuery(viewModel.options.value.query, false)
+ }
+ return true
+ }
+
+ override fun onMenuItemActionCollapse(item: MenuItem): Boolean = true
+
+ private companion object {
+ const val SOURCES_GROUP = Menu.FIRST + 4000
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/AlternativesViewModel.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/AlternativesViewModel.kt
index 5009f1aa93..a04a99cf50 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/AlternativesViewModel.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/AlternativesViewModel.kt
@@ -9,33 +9,44 @@ import kotlinx.coroutines.cancelAndJoin
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.update
import kotlinx.coroutines.plus
import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.alternatives.domain.AlternativeSearchEvent
+import io.github.landwarderer.futon.alternatives.domain.AlternativeSearchStatus
+import io.github.landwarderer.futon.alternatives.domain.AlternativeSortOrder
+import io.github.landwarderer.futon.alternatives.domain.AlternativeSourceScope
+import io.github.landwarderer.futon.alternatives.domain.AlternativeSourceScopeOptions
+import io.github.landwarderer.futon.alternatives.domain.AlternativesSearchOptions
import io.github.landwarderer.futon.alternatives.domain.AlternativesUseCase
import io.github.landwarderer.futon.alternatives.domain.MigrateUseCase
import io.github.landwarderer.futon.core.model.chaptersCount
+import io.github.landwarderer.futon.core.model.contentTypeCompat
+import io.github.landwarderer.futon.core.model.primaryLanguage
import io.github.landwarderer.futon.core.model.parcelable.ParcelableManga
import io.github.landwarderer.futon.core.nav.AppRouter
import io.github.landwarderer.futon.core.parser.MangaRepository
import io.github.landwarderer.futon.core.prefs.ListMode
import io.github.landwarderer.futon.core.ui.BaseViewModel
import io.github.landwarderer.futon.core.util.ext.MutableEventFlow
-import io.github.landwarderer.futon.core.util.ext.append
import io.github.landwarderer.futon.core.util.ext.call
import io.github.landwarderer.futon.core.util.ext.require
import io.github.landwarderer.futon.list.domain.MangaListMapper
-import io.github.landwarderer.futon.list.ui.model.ButtonFooter
import io.github.landwarderer.futon.list.ui.model.EmptyState
import io.github.landwarderer.futon.list.ui.model.ListModel
import io.github.landwarderer.futon.list.ui.model.LoadingFooter
import io.github.landwarderer.futon.list.ui.model.LoadingState
import io.github.landwarderer.futon.list.ui.model.MangaGridModel
import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaSource
import org.koitharu.kotatsu.parsers.util.suspendlazy.getOrDefault
import org.koitharu.kotatsu.parsers.util.suspendlazy.suspendLazy
+import java.util.Locale
import javax.inject.Inject
+import kotlin.math.abs
@HiltViewModel
class AlternativesViewModel @Inject constructor(
@@ -48,8 +59,14 @@ class AlternativesViewModel @Inject constructor(
val manga = savedStateHandle.require(AppRouter.KEY_MANGA).manga
- private var includeDisabledSources = MutableStateFlow(false)
private val results = MutableStateFlow>(emptyList())
+ private val sourceSearchStatus = MutableStateFlow(AlternativeSearchStatus())
+ val options = MutableStateFlow(AlternativesSearchOptions(query = manga.title))
+ val referenceManga = MutableStateFlow(MangaAlternativeReference(manga))
+ private val _scopeOptions = MutableStateFlow(null)
+ val scopeOptions = _scopeOptions.asStateFlow()
+ private var defaultSourceScope: AlternativeSourceScope = AlternativeSourceScope.Enabled
+ private var sourceScopeInitialized = false
private var migrationJob: Job? = null
private var searchJob: Job? = null
@@ -60,16 +77,29 @@ class AlternativesViewModel @Inject constructor(
val onMigrated = MutableEventFlow()
+ val searchStatus: StateFlow = combine(
+ sourceSearchStatus,
+ results,
+ options,
+ ) { status, results, options ->
+ status.copy(resultsCount = results.count { !options.hideNoChapters || it.chaptersCount > 0 })
+ }.stateIn(viewModelScope + Dispatchers.IO, SharingStarted.Eagerly, AlternativeSearchStatus())
+
val list: StateFlow> = combine(
results,
isLoading,
- includeDisabledSources,
- ) { list, loading, includeDisabled ->
+ options,
+ referenceManga,
+ ) { results, loading, options, reference ->
+ val filtered = results
+ .filterNot { options.hideNoChapters && it.chaptersCount == 0 }
+ .sortedWith(alternativeComparator(options, reference.manga, reference.chaptersCount))
when {
- list.isEmpty() -> listOf(
- when {
- loading -> LoadingState
- else -> EmptyState(
+ filtered.isEmpty() -> listOf(
+ if (loading) {
+ LoadingState()
+ } else {
+ EmptyState(
icon = R.drawable.ic_empty_common,
textPrimary = R.string.nothing_found,
textSecondary = R.string.text_search_holder_secondary,
@@ -78,37 +108,63 @@ class AlternativesViewModel @Inject constructor(
},
)
- loading -> list + LoadingFooter()
- includeDisabled -> list
- else -> list + ButtonFooter(R.string.search_disabled_sources)
+ loading -> filtered + LoadingFooter()
+ else -> filtered
}
- }.stateIn(viewModelScope + Dispatchers.IO, SharingStarted.Eagerly, listOf(LoadingState))
+ }.stateIn(viewModelScope + Dispatchers.IO, SharingStarted.Eagerly, listOf(LoadingState()))
init {
- doSearch(throughDisabledSources = false)
+ doSearch()
}
- fun retry() {
- searchJob?.cancel()
- results.value = emptyList()
- includeDisabledSources.value = false
- doSearch(throughDisabledSources = false)
+ fun retry() = doSearch()
+
+ fun setQuery(query: String) {
+ val value = query.trim()
+ if (value.isEmpty() || value == options.value.query) return
+ updateSearchOptions { copy(query = value) }
}
- fun continueSearch() {
- if (includeDisabledSources.value) {
- return
- }
- val prevJob = searchJob
- searchJob = launchLoadingJob(Dispatchers.IO) {
- includeDisabledSources.value = true
- prevJob?.join()
- doSearch(throughDisabledSources = true)
- }
+ fun setSourceScope(scope: AlternativeSourceScope) {
+ if (scope == options.value.sourceScope || scopeOptions.value?.isAvailable(scope) != true) return
+ updateSearchOptions { copy(sourceScope = scope) }
+ }
+
+ fun setSameLanguageOnly(enabled: Boolean) {
+ if (enabled != options.value.sameLanguageOnly) updateSearchOptions { copy(sameLanguageOnly = enabled) }
+ }
+
+ fun setSameContentTypeOnly(enabled: Boolean) {
+ if (enabled != options.value.sameContentTypeOnly) updateSearchOptions { copy(sameContentTypeOnly = enabled) }
}
+ fun setHideNoChapters(enabled: Boolean) {
+ if (enabled != options.value.hideNoChapters) options.update { it.copy(hideNoChapters = enabled) }
+ }
+
+ fun setSortOrder(sortOrder: AlternativeSortOrder) {
+ if (sortOrder != options.value.sortOrder) options.update { it.copy(sortOrder = sortOrder) }
+ }
+
+ fun resetOptions() {
+ val defaults = AlternativesSearchOptions(query = manga.title, sourceScope = defaultSourceScope)
+ val current = options.value
+ if (current == defaults) return
+ val requiresSearch = current.query != defaults.query ||
+ current.sourceScope != defaults.sourceScope ||
+ current.sameLanguageOnly != defaults.sameLanguageOnly ||
+ current.sameContentTypeOnly != defaults.sameContentTypeOnly
+ options.value = defaults
+ if (requiresSearch) doSearch()
+ }
+
+ fun hasCustomOptions(): Boolean = !options.value.isDefaultFor(manga.title, defaultSourceScope)
+
+ fun defaultScopeForReset(): AlternativeSourceScope = defaultSourceScope
+
fun migrate(target: Manga) {
- if (migrationJob?.isActive == true) {
+ val candidate = results.value.find { it.manga.id == target.id }
+ if (migrationJob?.isActive == true || candidate?.isMigrationEnabled != true || candidate.chaptersCount == 0) {
return
}
migrationJob = launchLoadingJob(Dispatchers.IO) {
@@ -117,20 +173,135 @@ class AlternativesViewModel @Inject constructor(
}
}
- private fun doSearch(throughDisabledSources: Boolean) {
- val prevJob = searchJob
+ private fun updateSearchOptions(block: AlternativesSearchOptions.() -> AlternativesSearchOptions) {
+ options.update(block)
+ doSearch()
+ }
+
+ private fun doSearch() {
+ results.update { current -> current.map { it.copy(isMigrationEnabled = false) } }
+ val previousJob = searchJob
searchJob = launchLoadingJob(Dispatchers.IO) {
- prevJob?.cancelAndJoin()
- val ref = mangaDetails.getOrDefault(manga)
- val refCount = ref.chaptersCount()
- alternativesUseCase.invoke(ref, throughDisabledSources)
- .collect {
- val model = MangaAlternativeModel(
- mangaModel = mangaListMapper.toListModel(it, ListMode.GRID) as MangaGridModel,
- referenceChapters = refCount,
- )
- results.append(model)
+ previousJob?.cancelAndJoin()
+ sourceSearchStatus.value = AlternativeSearchStatus(isRunning = true)
+ var receivedResult = false
+ try {
+ val reference = mangaDetails.getOrDefault(manga)
+ val referenceChapters = reference.chaptersCount()
+ referenceManga.value = MangaAlternativeReference(reference, referenceChapters)
+ if (!sourceScopeInitialized) {
+ val scopeOptions = alternativesUseCase.getSourceScopeOptions(reference.source)
+ defaultSourceScope = scopeOptions.defaultScope
+ _scopeOptions.value = scopeOptions
+ options.update { it.copy(sourceScope = defaultSourceScope) }
+ sourceScopeInitialized = true
+ }
+ val searchOptions = options.value
+ alternativesUseCase(reference, searchOptions).collect { event ->
+ when (event) {
+ is AlternativeSearchEvent.Progress -> sourceSearchStatus.update {
+ it.copy(
+ completedSources = maxOf(it.completedSources, event.completedSources),
+ totalSources = event.totalSources,
+ )
+ }
+
+ is AlternativeSearchEvent.Result -> {
+ if (!receivedResult) {
+ results.value = emptyList()
+ receivedResult = true
+ }
+ val model = MangaAlternativeModel(
+ mangaModel = mangaListMapper.toListModel(event.manga, ListMode.GRID) as MangaGridModel,
+ referenceChapters = referenceChapters,
+ )
+ results.update { current ->
+ current.filterNot { it.manga.id == model.manga.id } + model
+ }
+ }
+ }
}
+ if (!receivedResult) results.value = emptyList()
+ } finally {
+ sourceSearchStatus.update { it.copy(isRunning = false) }
+ }
}
}
+
+ private fun alternativeComparator(
+ options: AlternativesSearchOptions,
+ reference: Manga,
+ referenceChapters: Int,
+ ): Comparator = Comparator { left, right ->
+ val primary = when (options.sortOrder) {
+ AlternativeSortOrder.BEST_MATCH -> compareValues(
+ right.manga.titleMatchScore(options.query),
+ left.manga.titleMatchScore(options.query),
+ ).takeUnless { it == 0 } ?: compareValues(
+ right.chaptersCount > 0,
+ left.chaptersCount > 0,
+ ).takeUnless { it == 0 } ?: compareValues(
+ right.manga.source.priority(reference.source),
+ left.manga.source.priority(reference.source),
+ )
+
+ AlternativeSortOrder.MOST_CHAPTERS -> compareValues(right.chaptersCount, left.chaptersCount)
+ AlternativeSortOrder.CLOSEST_CHAPTER_COUNT -> compareValues(
+ left.chapterDistanceFrom(referenceChapters),
+ right.chapterDistanceFrom(referenceChapters),
+ )
+ AlternativeSortOrder.SOURCE_PRIORITY -> compareValues(
+ right.manga.source.priority(reference.source),
+ left.manga.source.priority(reference.source),
+ )
+ }
+ primary.takeUnless { it == 0 }
+ ?: compareValues(right.chaptersCount, left.chaptersCount).takeUnless { it == 0 }
+ ?: left.manga.source.name.compareTo(right.manga.source.name, ignoreCase = true).takeUnless { it == 0 }
+ ?: left.manga.title.compareTo(right.manga.title, ignoreCase = true).takeUnless { it == 0 }
+ ?: left.manga.id.compareTo(right.manga.id)
+ }
+
+ private fun MangaAlternativeModel.chapterDistanceFrom(referenceChapters: Int): Int =
+ if (chaptersCount == 0) Int.MAX_VALUE else abs(chaptersCount - referenceChapters)
+
+ private fun Manga.titleMatchScore(query: String): Int {
+ val normalizedQuery = query.normalizeTitle()
+ if (normalizedQuery.isEmpty()) return 0
+ return (sequenceOf(title) + altTitles.asSequence()).maxOf { candidate ->
+ val normalizedCandidate = candidate.normalizeTitle()
+ when {
+ normalizedCandidate == normalizedQuery -> 100
+ normalizedCandidate.startsWith(normalizedQuery) || normalizedQuery.startsWith(normalizedCandidate) -> 85
+ normalizedCandidate.contains(normalizedQuery) || normalizedQuery.contains(normalizedCandidate) -> 75
+ else -> {
+ val queryTokens = normalizedQuery.splitToSequence(' ').filter(String::isNotEmpty).toSet()
+ val candidateTokens = normalizedCandidate.splitToSequence(' ').filter(String::isNotEmpty).toSet()
+ val total = maxOf(queryTokens.size, candidateTokens.size)
+ if (total == 0) 0 else queryTokens.intersect(candidateTokens).size * 60 / total
+ }
+ }
+ }
+ }
+
+ private fun String.normalizeTitle(): String = lowercase(Locale.ROOT)
+ .replace(NON_TITLE_CHARACTER, " ")
+ .trim()
+ .replace(MULTIPLE_SPACES, " ")
+
+ private fun MangaSource.priority(ref: MangaSource): Int {
+ var result = 0
+ val language = primaryLanguage
+ if (language != null) {
+ if (language == ref.primaryLanguage) result += 4 else if (language == Locale.getDefault().language) result += 2
+ }
+ val type = contentTypeCompat
+ if (type != null && type == ref.contentTypeCompat) result++
+ return result
+ }
+
+ private companion object {
+ val NON_TITLE_CHARACTER = Regex("[^\\p{L}\\p{N}]+")
+ val MULTIPLE_SPACES = Regex("\\s+")
+ }
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/MangaAlternativeModel.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/MangaAlternativeModel.kt
index 078045880c..aadaf81f19 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/MangaAlternativeModel.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/MangaAlternativeModel.kt
@@ -8,6 +8,7 @@ import org.koitharu.kotatsu.parsers.model.Manga
data class MangaAlternativeModel(
val mangaModel: MangaGridModel,
private val referenceChapters: Int,
+ val isMigrationEnabled: Boolean = true,
) : ListModel {
val manga: Manga
@@ -28,3 +29,8 @@ data class MangaAlternativeModel(
null
}
}
+
+data class MangaAlternativeReference(
+ val manga: Manga,
+ val chaptersCount: Int = manga.chaptersCount(),
+)
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/MangaUnavailableDialog.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/MangaUnavailableDialog.kt
new file mode 100644
index 0000000000..86919de001
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/MangaUnavailableDialog.kt
@@ -0,0 +1,66 @@
+package io.github.landwarderer.futon.alternatives.ui
+
+import android.content.Context
+import android.content.DialogInterface
+import android.view.LayoutInflater
+import androidx.annotation.UiContext
+import androidx.appcompat.app.AlertDialog
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.core.model.getTitle
+import io.github.landwarderer.futon.core.model.isLocal
+import io.github.landwarderer.futon.databinding.DialogMangaUnavailableBinding
+import org.koitharu.kotatsu.parsers.model.Manga
+
+/**
+ * Prompt shown when a manga the user just opened is gone from its source (404 / removed), offering to
+ * look for the same title elsewhere instead of leaving them with a dead-end error.
+ */
+class MangaUnavailableDialog private constructor(
+ private val delegate: AlertDialog,
+ private val binding: DialogMangaUnavailableBinding,
+ private val manga: Manga,
+) : DialogInterface by delegate {
+
+ val isShowing: Boolean
+ get() = delegate.isShowing
+
+ fun show() {
+ delegate.show()
+ // After show(), so the view is attached and Coil can bind to the dialog's lifecycle.
+ binding.imageViewCover.setImageAsync(manga.coverUrl, manga)
+ }
+
+ class Builder(@UiContext context: Context, private val manga: Manga) {
+
+ private val binding = DialogMangaUnavailableBinding.inflate(LayoutInflater.from(context))
+
+ private val delegate = MaterialAlertDialogBuilder(context)
+ .setView(binding.root)
+
+ init {
+ binding.textViewTitle.setText(R.string.manga_unavailable_title)
+ val sourceTitle = if (manga.isLocal) null else manga.source.getTitle(context)
+ binding.textViewMessage.text = if (sourceTitle != null) {
+ context.getString(R.string.manga_unavailable_message, manga.title, sourceTitle)
+ } else {
+ context.getString(R.string.manga_unavailable_message_no_source, manga.title)
+ }
+ }
+
+ fun setOnAlternativesClickListener(listener: Runnable) = apply {
+ binding.button1.setOnClickListener {
+ val dialog = binding.root.tag as DialogInterface
+ dialog.dismiss()
+ listener.run()
+ }
+ }
+
+ fun create(): MangaUnavailableDialog {
+ val dialog = delegate.create()
+ binding.root.tag = dialog
+ binding.buttonClose.setOnClickListener { dialog.dismiss() }
+ return MangaUnavailableDialog(dialog, binding, manga)
+ }
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceReplacementAD.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceReplacementAD.kt
new file mode 100644
index 0000000000..b3a04239fa
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceReplacementAD.kt
@@ -0,0 +1,42 @@
+package io.github.landwarderer.futon.alternatives.ui
+
+import androidx.core.view.isVisible
+import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
+import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.core.model.getTitle
+import io.github.landwarderer.futon.databinding.ItemSourceReplacementBinding
+import io.github.landwarderer.futon.list.ui.model.ListModel
+import org.koitharu.kotatsu.parsers.model.MangaSource
+
+fun sourceReplacementAD(
+ onClick: (MangaSource?) -> Unit,
+) = adapterDelegateViewBinding(
+ { inflater, parent -> ItemSourceReplacementBinding.inflate(inflater, parent, false) },
+) {
+ binding.root.setOnClickListener { onClick(item.source) }
+
+ bind {
+ val source = item.source
+ binding.textViewTitle.text = source?.getTitle(context)
+ ?: context.getString(R.string.handle_remaining_manually)
+ binding.textViewSubtitle.text = if (source == null) {
+ context.getString(R.string.handle_remaining_manually_summary)
+ } else {
+ context.getString(
+ R.string.source_match_rate_summary,
+ item.matched,
+ item.total,
+ )
+ }
+ binding.textViewPercent.isVisible = source != null
+ binding.textViewPercent.text = context.getString(R.string.percent_format, item.matchPercent)
+ binding.progressMatch.isVisible = source != null
+ binding.progressMatch.setProgressCompat(item.matchPercent, false)
+ binding.imageViewSelected.isVisible = item.isSelected
+ if (source == null) {
+ binding.imageViewIcon.setImageResource(R.drawable.ic_web)
+ } else {
+ binding.imageViewIcon.setImageAsync(source)
+ }
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceReplacementActivity.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceReplacementActivity.kt
new file mode 100644
index 0000000000..a60862f349
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceReplacementActivity.kt
@@ -0,0 +1,507 @@
+package io.github.landwarderer.futon.alternatives.ui
+
+import android.os.Bundle
+import android.view.Menu
+import android.view.MenuItem
+import android.view.SubMenu
+import android.view.View
+import android.widget.Toast
+import androidx.activity.viewModels
+import androidx.appcompat.widget.SearchView
+import androidx.core.view.isVisible
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.updatePadding
+import coil3.ImageLoader
+import dagger.hilt.android.AndroidEntryPoint
+import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.core.exceptions.resolve.SnackbarErrorObserver
+import io.github.landwarderer.futon.core.model.getTitle
+import io.github.landwarderer.futon.core.nav.router
+import io.github.landwarderer.futon.core.ui.BaseActivity
+import io.github.landwarderer.futon.core.ui.BaseListAdapter
+import io.github.landwarderer.futon.core.ui.dialog.buildAlertDialog
+import io.github.landwarderer.futon.core.ui.list.OnListItemClickListener
+import io.github.landwarderer.futon.core.util.ext.consumeAllSystemBarsInsets
+import io.github.landwarderer.futon.core.util.ext.observe
+import io.github.landwarderer.futon.core.util.ext.observeEvent
+import io.github.landwarderer.futon.core.util.ext.systemBarsInsets
+import io.github.landwarderer.futon.databinding.ActivityAlternativesBinding
+import io.github.landwarderer.futon.list.ui.adapter.ListItemType
+import io.github.landwarderer.futon.list.ui.adapter.ListStateHolderListener
+import io.github.landwarderer.futon.list.ui.adapter.TypedListSpacingDecoration
+import io.github.landwarderer.futon.list.ui.adapter.buttonFooterAD
+import io.github.landwarderer.futon.list.ui.adapter.loadingFooterAD
+import io.github.landwarderer.futon.list.ui.adapter.loadingStateAD
+import io.github.landwarderer.futon.list.ui.model.ListModel
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class SourceReplacementActivity : BaseActivity(),
+ ListStateHolderListener,
+ OnListItemClickListener {
+
+ @Inject
+ lateinit var coil: ImageLoader
+
+ private val viewModel by viewModels()
+ private var sourceMenuItem: MenuItem? = null
+ private var sourceScopeMenuItem: MenuItem? = null
+ private var sourceScopeSubMenu: SubMenu? = null
+ private var searchMenuItem: MenuItem? = null
+ private var nextSourceMenuItem: MenuItem? = null
+ private var skipMenuItem: MenuItem? = null
+ private var isShowingSummary = false
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ setContentView(ActivityAlternativesBinding.inflate(layoutInflater))
+ supportActionBar?.setDisplayHomeAsUpEnabled(true)
+ viewBinding.progressSources.isVisible = false
+ viewBinding.scrollViewSummary.isVisible = false
+ val listAdapter = BaseListAdapter()
+ .addDelegate(ListItemType.MANGA_LIST_DETAILED, alternativeAD(coil, this, this))
+ .addDelegate(ListItemType.SOURCE_REPLACEMENT, sourceReplacementAD(::onSourceMatchClick))
+ .addDelegate(
+ ListItemType.STATE_EMPTY,
+ sourceReplacementEmptyStateAD(
+ onEditTitle = { searchMenuItem?.expandActionView() },
+ onSkip = viewModel::skipCurrent,
+ ),
+ ) .addDelegate(ListItemType.FOOTER_LOADING, loadingFooterAD())
+ .addDelegate(ListItemType.STATE_LOADING, loadingStateAD())
+ .addDelegate(ListItemType.FOOTER_BUTTON, buttonFooterAD(this))
+ with(viewBinding.recyclerView) {
+ setHasFixedSize(true)
+ addItemDecoration(TypedListSpacingDecoration(context, addHorizontalPadding = false))
+ adapter = listAdapter
+ }
+
+ viewModel.onError.observeEvent(this, SnackbarErrorObserver(viewBinding.recyclerView, null))
+ viewModel.list.observe(this, listAdapter)
+ viewModel.currentManga.observe(this) {
+ updateHeader()
+ }
+ viewModel.queuePosition.observe(this) {
+ updateHeader()
+ }
+ viewModel.queueSize.observe(this) {
+ updateHeader()
+ }
+ viewModel.selectedSource.observe(this) {
+ updateHeader()
+ }
+ viewModel.matchedCount.observe(this) {
+ updateHeader()
+ }
+ viewModel.isPlanning.observe(this) {
+ updateHeader()
+ updatePlanningProgress()
+ }
+ viewModel.planningStep.observe(this) {
+ updatePlanningProgress()
+ }
+ viewModel.planningProgress.observe(this) {
+ updateHeader()
+ updatePlanningProgress()
+ }
+ viewModel.planningTotal.observe(this) {
+ updateHeader()
+ updatePlanningProgress()
+ }
+ viewModel.planningSourcesRemaining.observe(this) {
+ updatePlanningProgress()
+ }
+ viewModel.planningSampleSize.observe(this) {
+ updatePlanningProgress()
+ }
+ viewModel.planningCurrentSource.observe(this) {
+ updatePlanningProgress()
+ }
+ viewModel.isManualMode.observe(this) {
+ updateHeader()
+ }
+ viewModel.isComparingSources.observe(this) {
+ updateHeader()
+ }
+ viewModel.sourceScope.observe(this) {
+ updateSourceScopeMenu()
+ }
+ viewModel.scopeOptions.observe(this) {
+ updateSourceScopeMenu()
+ }
+ viewModel.onMigrated.observeEvent(this) { result ->
+ if (result.remaining > 0) {
+ Toast.makeText(this, R.string.migration_completed, Toast.LENGTH_SHORT).show()
+ }
+ }
+ viewModel.onBatchMigrated.observeEvent(this) { result ->
+ if (result.remaining > 0) {
+ val message = getString(
+ R.string.source_replacement_batch_completed,
+ result.replaced,
+ result.remaining,
+ )
+ Toast.makeText(this, message, Toast.LENGTH_LONG).show()
+ }
+ }
+ viewModel.replacementSummary.observe(this) { summary ->
+ summary?.let(::showReplacementSummary)
+ }
+ viewModel.onPlanReady.observeEvent(this) {
+ viewModel.showSourceComparison()
+ }
+ updateHeader()
+ updatePlanningProgress()
+ }
+
+ override fun onStop() {
+ if (isFinishing) {
+ viewModel.cancelPendingChecks()
+ }
+ super.onStop()
+ }
+
+ override fun onCreateOptionsMenu(menu: Menu): Boolean {
+ super.onCreateOptionsMenu(menu)
+ menuInflater.inflate(R.menu.opt_alternatives, menu)
+ sourceMenuItem = menu.findItem(R.id.action_choose_source)
+ searchMenuItem = menu.add(Menu.NONE, R.id.action_search, Menu.NONE, R.string.search).apply {
+ setIcon(androidx.appcompat.R.drawable.abc_ic_search_api_material)
+ setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM or MenuItem.SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW)
+ actionView = SearchView(this@SourceReplacementActivity).apply {
+ queryHint = getString(R.string.search_manga)
+ setOnQueryTextListener(object : SearchView.OnQueryTextListener {
+ override fun onQueryTextSubmit(query: String?): Boolean {
+ viewModel.search(query.orEmpty())
+ clearFocus()
+ return true
+ }
+
+ override fun onQueryTextChange(newText: String?): Boolean = false
+ })
+ }
+ setOnActionExpandListener(object : MenuItem.OnActionExpandListener {
+ override fun onMenuItemActionExpand(item: MenuItem): Boolean {
+ (item.actionView as? SearchView)?.setQuery(viewModel.manga.title, false)
+ return true
+ }
+
+ override fun onMenuItemActionCollapse(item: MenuItem): Boolean = true
+ })
+ }
+ nextSourceMenuItem = menu.add(Menu.NONE, ACTION_NEXT_SOURCE, Menu.NONE, R.string.next).apply {
+ setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER)
+ }
+ skipMenuItem = menu.add(Menu.NONE, ACTION_SKIP, Menu.NONE, R.string.skip).apply {
+ setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER)
+ }
+ val scopeMenu = menu.addSubMenu(
+ Menu.NONE,
+ ACTION_SOURCE_SCOPE,
+ Menu.NONE,
+ R.string.preset_sources,
+ )
+ sourceScopeMenuItem = scopeMenu.item.apply {
+ setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER)
+ }
+ sourceScopeSubMenu = scopeMenu
+ updateSourceScopeMenu()
+ updateHeader()
+ return true
+ }
+
+ override fun onOptionsItemSelected(item: MenuItem): Boolean = when (item.itemId) {
+ android.R.id.home -> {
+ finishAfterTransition()
+ true
+ }
+
+ R.id.action_choose_source -> {
+ viewModel.showSourceComparison()
+ true
+ }
+
+ ACTION_NEXT_SOURCE -> {
+ viewModel.selectNextSource()
+ true
+ }
+
+ ACTION_SKIP -> {
+ viewModel.skipCurrent()
+ true
+ }
+
+ else -> {
+ val scope = SourceScopeMenu.scopeFor(item.itemId, viewModel.scopeOptions.value)
+ if (scope != null) {
+ viewModel.selectSourceScope(scope)
+ true
+ } else {
+ super.onOptionsItemSelected(item)
+ }
+ }
+ }
+
+ override fun onApplyWindowInsets(
+ v: View,
+ insets: WindowInsetsCompat,
+ ): WindowInsetsCompat {
+ val barsInsets = insets.systemBarsInsets
+ viewBinding.recyclerView.updatePadding(
+ left = barsInsets.left,
+ right = barsInsets.right,
+ bottom = barsInsets.bottom,
+ )
+ viewBinding.summaryContainer.updatePadding(
+ left = barsInsets.left,
+ right = barsInsets.right,
+ bottom = barsInsets.bottom,
+ )
+ viewBinding.appbar.updatePadding(
+ left = barsInsets.left,
+ right = barsInsets.right,
+ top = barsInsets.top,
+ )
+ return insets.consumeAllSystemBarsInsets()
+ }
+
+ override fun onItemClick(item: MangaAlternativeModel, view: View) {
+ when (view.id) {
+ R.id.chip_source -> viewModel.selectSource(item.manga.source)
+ R.id.button_migrate -> confirmMigration(item.manga)
+ else -> router.openDetails(item.manga)
+ }
+ }
+
+ override fun onRetryClick(error: Throwable) = viewModel.retry()
+
+ override fun onEmptyActionClick() {
+ if (viewModel.selectedSource.value == null) {
+ viewModel.showSourceComparison()
+ } else {
+ searchMenuItem?.expandActionView()
+ }
+ }
+
+ override fun onFooterButtonClick() {
+ if (viewModel.isComparingSources.value) {
+ viewModel.skipRemaining()
+ } else {
+ viewModel.skipCurrent()
+ }
+ }
+ /** Outside manual mode, picking a source migrates every matched title at once, so ask first */
+ private fun onSourceMatchClick(source: MangaSource?) {
+ if (source == null || viewModel.isManualMode.value) {
+ viewModel.selectSource(source)
+ return
+ }
+ buildAlertDialog(this, isCentered = true) {
+ setIcon(R.drawable.ic_replace)
+ setTitle(R.string.replace_source)
+ setMessage(getString(R.string.source_replacement_confirm, source.getTitle(context)))
+ setNegativeButton(android.R.string.cancel, null)
+ setPositiveButton(R.string.replace) { _, _ ->
+ viewModel.selectSource(source)
+ }
+ }.show()
+ }
+
+ private fun confirmMigration(target: Manga) {
+ val source = viewModel.manga
+ buildAlertDialog(this, isCentered = true) {
+ setIcon(R.drawable.ic_replace)
+ setTitle(R.string.replace_source)
+ setMessage(
+ getString(
+ R.string.migrate_confirmation,
+ source.title,
+ source.source.getTitle(context),
+ target.title,
+ target.source.getTitle(context),
+ ),
+ )
+ setNegativeButton(android.R.string.cancel, null)
+ setPositiveButton(R.string.replace) { _, _ ->
+ viewModel.migrate(target)
+ }
+ }.show()
+ }
+
+ private fun updateHeader() {
+ if (isShowingSummary) {
+ supportActionBar?.subtitle = null
+ sourceMenuItem?.isVisible = false
+ sourceScopeMenuItem?.isVisible = false
+ searchMenuItem?.isVisible = false
+ nextSourceMenuItem?.isVisible = false
+ skipMenuItem?.isVisible = false
+ return
+ }
+ val total = viewModel.queueSize.value
+ if (viewModel.isPlanning.value) {
+ supportActionBar?.subtitle = null
+ sourceMenuItem?.isEnabled = false
+ sourceScopeMenuItem?.isEnabled = false
+ searchMenuItem?.isVisible = false
+ nextSourceMenuItem?.isVisible = false
+ skipMenuItem?.isVisible = false
+ return
+ }
+ if (viewModel.isComparingSources.value) {
+ supportActionBar?.subtitle = getString(R.string.compare_source_matches)
+ sourceMenuItem?.isVisible = false
+ searchMenuItem?.isVisible = false
+ nextSourceMenuItem?.isVisible = false
+ skipMenuItem?.isVisible = viewModel.isManualMode.value
+ return
+ }
+ sourceMenuItem?.isVisible = true
+ sourceScopeMenuItem?.isVisible = true
+ sourceScopeMenuItem?.isEnabled = true
+ val manual = viewModel.isManualMode.value
+ searchMenuItem?.isVisible = manual && viewModel.selectedSource.value != null
+ nextSourceMenuItem?.isVisible = manual
+ skipMenuItem?.isVisible = manual
+ val target = viewModel.selectedSource.value?.getTitle(this) ?: getString(R.string.top_source_matches)
+ val manga = viewModel.manga
+ supportActionBar?.subtitle = if (total > 1) {
+ getString(
+ R.string.source_replacement_subtitle_batch,
+ manga.title,
+ viewModel.queuePosition.value,
+ total,
+ target,
+ )
+ } else {
+ getString(R.string.source_replacement_subtitle, manga.title, target)
+ }
+ sourceMenuItem?.title = if (viewModel.selectedSource.value == null) {
+ getString(R.string.choose_source)
+ } else {
+ getString(R.string.source_selected, target)
+ }
+ sourceMenuItem?.isEnabled = true
+ }
+
+ private fun updateSourceScopeMenu() {
+ val scopeOptions = viewModel.scopeOptions.value
+ sourceScopeSubMenu?.let { subMenu ->
+ subMenu.clear()
+ SourceScopeMenu.populate(subMenu, SOURCE_SCOPE_GROUP, scopeOptions, viewModel.sourceScope.value)
+ }
+ val selectedTitle = SourceScopeMenu.title(this, viewModel.sourceScope.value, scopeOptions)
+ sourceScopeMenuItem?.title = getString(R.string.preset_sources) + ": " + selectedTitle
+ }
+
+ private fun showReplacementSummary(summary: SourceReplacementViewModel.ReplacementSummary) {
+ isShowingSummary = true
+ viewBinding.recyclerView.isVisible = false
+ viewBinding.planningProgressContainer.isVisible = false
+ viewBinding.summaryContainer.isVisible = true
+ supportActionBar?.title = getString(R.string.source_replacement_summary_title)
+ supportActionBar?.subtitle = null
+ sourceMenuItem?.isVisible = false
+
+ viewBinding.textViewSummaryTitle.setText(
+ when (summary.replaced) {
+ 0 -> R.string.source_replacement_summary_zero_title
+ 1 -> R.string.source_replacement_summary_one_title
+ else -> R.string.source_replacement_summary_many_title
+ },
+ )
+ viewBinding.textViewSummaryMessage.text = when (summary.replaced) {
+ 0 -> getString(R.string.source_replacement_summary_zero_message)
+ 1 -> getString(R.string.source_replacement_summary_one_message)
+ else -> getString(R.string.source_replacement_summary_many_message, summary.replaced)
+ }
+ viewBinding.textViewSummaryReplaced.text = summary.replaced.toString()
+ viewBinding.textViewSummarySources.text = summary.sources.size.toString()
+ viewBinding.summaryMixContainer.isVisible = summary.sources.isNotEmpty()
+ viewBinding.textViewSummaryMix.text = summary.sources.joinToString(separator = " • ") {
+ getString(
+ R.string.source_replacement_summary_source_item,
+ it.source.getTitle(this),
+ it.count,
+ )
+ }
+ viewBinding.buttonSummaryDone.setOnClickListener {
+ finishAfterTransition()
+ }
+ }
+
+ private fun updatePlanningProgress() {
+ val planning = viewModel.isPlanning.value
+ viewBinding.planningProgressContainer.isVisible = planning
+ if (!planning) {
+ return
+ }
+ val completed = viewModel.planningProgress.value
+ val total = viewModel.planningTotal.value
+ val remaining = (total - completed).coerceAtLeast(0)
+ viewBinding.textViewPlanningStep.text = when (viewModel.planningStep.value) {
+ SourceReplacementStep.COMPARING_SOURCES -> if (total == 0) {
+ getString(R.string.source_replacement_step_preparing)
+ } else {
+ getString(R.string.source_replacement_step_comparing, viewModel.planningSampleSize.value)
+ }
+
+ SourceReplacementStep.MATCHING_TITLES -> getString(
+ R.string.source_replacement_step_matching,
+ viewModel.selectedSource.value?.getTitle(this) ?: getString(R.string.automatic),
+ )
+
+ SourceReplacementStep.SMART_MIX -> getString(
+ R.string.source_replacement_step_smart_mix,
+ viewModel.planningCurrentSource.value?.getTitle(this) ?: getString(R.string.automatic),
+ )
+
+ SourceReplacementStep.APPLYING_MATCHES -> getString(R.string.source_replacement_step_applying)
+ }
+ viewBinding.textViewPlanningRemaining.text = when (viewModel.planningStep.value) {
+ SourceReplacementStep.COMPARING_SOURCES -> if (total == 0) {
+ null
+ } else {
+ getString(
+ R.string.source_replacement_remaining_checks,
+ viewModel.planningSourcesRemaining.value,
+ remaining,
+ )
+ }
+
+ SourceReplacementStep.MATCHING_TITLES -> getString(
+ R.string.source_replacement_remaining_titles,
+ remaining,
+ )
+
+ SourceReplacementStep.SMART_MIX -> getString(
+ R.string.source_replacement_remaining_mix,
+ viewModel.planningSourcesRemaining.value,
+ remaining,
+ )
+
+ SourceReplacementStep.APPLYING_MATCHES -> getString(
+ R.string.source_replacement_remaining_replacements,
+ remaining,
+ )
+ }
+ with(viewBinding.planningProgressBar) {
+ if (total == 0) {
+ isIndeterminate = true
+ } else {
+ isIndeterminate = false
+ max = total
+ setProgressCompat(completed.coerceIn(0, total), true)
+ }
+ }
+ }
+
+ private companion object {
+ const val ACTION_SOURCE_SCOPE = Menu.FIRST + 1000
+ const val SOURCE_SCOPE_GROUP = Menu.FIRST + 1003
+ const val ACTION_NEXT_SOURCE = Menu.FIRST + 1004
+ const val ACTION_SKIP = Menu.FIRST + 1005
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceReplacementEmptyStateAD.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceReplacementEmptyStateAD.kt
new file mode 100644
index 0000000000..ec910765ad
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceReplacementEmptyStateAD.kt
@@ -0,0 +1,56 @@
+package io.github.landwarderer.futon.alternatives.ui
+
+import android.view.ViewGroup
+import android.widget.LinearLayout
+import androidx.core.view.isVisible
+import com.google.android.material.button.MaterialButton
+import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
+import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.databinding.ItemEmptyStateBinding
+import io.github.landwarderer.futon.list.ui.model.ListModel
+
+object SourceReplacementEmptyState : ListModel {
+ override fun equals(other: Any?): Boolean = other === this
+
+ override fun hashCode(): Int = javaClass.hashCode()
+
+ override fun areItemsTheSame(other: ListModel): Boolean = other === this
+}
+
+fun sourceReplacementEmptyStateAD(
+ onEditTitle: () -> Unit,
+ onSkip: () -> Unit,
+) = adapterDelegateViewBinding(
+ { inflater, parent -> ItemEmptyStateBinding.inflate(inflater, parent, false) },
+) {
+ val skipButton = MaterialButton(
+ context,
+ null,
+ com.google.android.material.R.attr.materialButtonOutlinedStyle,
+ ).apply {
+ setText(R.string.skip)
+ layoutParams = LinearLayout.LayoutParams(
+ ViewGroup.LayoutParams.WRAP_CONTENT,
+ ViewGroup.LayoutParams.WRAP_CONTENT,
+ ).apply {
+ topMargin = resources.getDimensionPixelSize(R.dimen.margin_small)
+ }
+ setOnClickListener { onSkip() }
+ }
+ binding.root.addView(skipButton)
+ binding.buttonRetry.apply {
+ isVisible = true
+ setText(R.string.edit)
+ setOnClickListener { onEditTitle() }
+ }
+
+ bind {
+ binding.icon.isVisible = true
+ binding.icon.setImageAsync(R.drawable.ic_empty_common)
+ binding.textPrimary.setText(R.string.nothing_found)
+ binding.textSecondary.apply {
+ isVisible = true
+ setText(R.string.source_replacement_empty_summary)
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceReplacementModel.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceReplacementModel.kt
new file mode 100644
index 0000000000..a6866dc47e
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceReplacementModel.kt
@@ -0,0 +1,17 @@
+package io.github.landwarderer.futon.alternatives.ui
+
+import io.github.landwarderer.futon.list.ui.model.ListModel
+import org.koitharu.kotatsu.parsers.model.MangaSource
+
+data class SourceReplacementModel(
+ val source: MangaSource?,
+ val matched: Int,
+ val total: Int,
+ val matchPercent: Int,
+ val isSelected: Boolean,
+) : ListModel {
+
+ override fun areItemsTheSame(other: ListModel): Boolean {
+ return other is SourceReplacementModel && other.source?.name == source?.name
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceReplacementViewModel.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceReplacementViewModel.kt
new file mode 100644
index 0000000000..0d4cebf237
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceReplacementViewModel.kt
@@ -0,0 +1,646 @@
+package io.github.landwarderer.futon.alternatives.ui
+
+import androidx.lifecycle.SavedStateHandle
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.plus
+import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.alternatives.domain.AlternativeSourceScope
+import io.github.landwarderer.futon.alternatives.domain.AlternativeSourceScopeOptions
+import io.github.landwarderer.futon.alternatives.domain.AlternativesUseCase
+import io.github.landwarderer.futon.alternatives.domain.MigrateUseCase
+import io.github.landwarderer.futon.alternatives.domain.SourceReplacementPlan
+import io.github.landwarderer.futon.alternatives.domain.SourceReplacementPlannerUseCase
+import io.github.landwarderer.futon.core.model.chaptersCount
+import io.github.landwarderer.futon.core.model.parcelable.ParcelableManga
+import io.github.landwarderer.futon.core.nav.AppRouter
+import io.github.landwarderer.futon.core.parser.MangaDataRepository
+import io.github.landwarderer.futon.core.parser.MangaRepository
+import io.github.landwarderer.futon.core.prefs.ListMode
+import io.github.landwarderer.futon.core.ui.BaseViewModel
+import io.github.landwarderer.futon.core.util.ext.MutableEventFlow
+import io.github.landwarderer.futon.core.util.ext.call
+import io.github.landwarderer.futon.core.util.ext.require
+import io.github.landwarderer.futon.list.domain.MangaListMapper
+import io.github.landwarderer.futon.list.ui.model.ButtonFooter
+import io.github.landwarderer.futon.list.ui.model.ListModel
+import io.github.landwarderer.futon.list.ui.model.LoadingFooter
+import io.github.landwarderer.futon.list.ui.model.LoadingState
+import io.github.landwarderer.futon.list.ui.model.MangaGridModel
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
+import javax.inject.Inject
+
+@HiltViewModel
+class SourceReplacementViewModel @Inject constructor(
+ private val savedStateHandle: SavedStateHandle,
+ private val mangaRepositoryFactory: MangaRepository.Factory,
+ private val mangaDataRepository: MangaDataRepository,
+ private val alternativesUseCase: AlternativesUseCase,
+ private val replacementPlanner: SourceReplacementPlannerUseCase,
+ private val migrateUseCase: MigrateUseCase,
+ private val mangaListMapper: MangaListMapper,
+) : BaseViewModel() {
+
+ private val requestedManga: List = savedStateHandle
+ .get>(AppRouter.KEY_MANGA_LIST)
+ ?.map(ParcelableManga::manga)
+ ?.distinctBy(Manga::id)
+ ?.takeIf(List::isNotEmpty)
+ ?: listOf(savedStateHandle.require(AppRouter.KEY_MANGA).manga)
+ private val originSource = requestedManga.first().source
+ private var mangaQueue = requestedManga.filter { it.source.name == originSource.name }
+ private val originalSourceNames = setOf(originSource.name)
+ private var currentIndex = (savedStateHandle.get(AppRouter.KEY_INDEX) ?: 0)
+ .coerceIn(mangaQueue.indices)
+
+ private val _currentManga = MutableStateFlow(mangaQueue[currentIndex])
+ val currentManga = _currentManga.asStateFlow()
+ val manga: Manga
+ get() = _currentManga.value
+
+ private val _queueSize = MutableStateFlow(mangaQueue.size)
+ val queueSize = _queueSize.asStateFlow()
+ private val _queuePosition = MutableStateFlow(currentIndex + 1)
+ val queuePosition = _queuePosition.asStateFlow()
+
+ private val _selectedSource = MutableStateFlow(null)
+ val selectedSource = _selectedSource.asStateFlow()
+ private val _matchedCount = MutableStateFlow(0)
+ val matchedCount = _matchedCount.asStateFlow()
+
+ private val results = MutableStateFlow>(emptyList())
+ private val sourceComparisonItems = MutableStateFlow>(emptyList())
+ private val _isComparingSources = MutableStateFlow(false)
+ val isComparingSources = _isComparingSources.asStateFlow()
+
+ private val replacementPlans = MutableStateFlow>(emptyList())
+ private val failedSourceNames = mutableSetOf()
+ private val usedSourceNames = mutableSetOf()
+ private val activeMatches = MutableStateFlow>(emptyMap())
+ private val _isManualMode = MutableStateFlow(false)
+ val isManualMode = _isManualMode.asStateFlow()
+ private val _isPlanning = MutableStateFlow(true)
+ val isPlanning = _isPlanning.asStateFlow()
+ private val _planningStep = MutableStateFlow(SourceReplacementStep.COMPARING_SOURCES)
+ val planningStep = _planningStep.asStateFlow()
+ private val _planningProgress = MutableStateFlow(0)
+ val planningProgress = _planningProgress.asStateFlow()
+ private val _planningTotal = MutableStateFlow(0)
+ val planningTotal = _planningTotal.asStateFlow()
+ private val _planningSourcesRemaining = MutableStateFlow(0)
+ val planningSourcesRemaining = _planningSourcesRemaining.asStateFlow()
+ private val _planningSampleSize = MutableStateFlow(0)
+ val planningSampleSize = _planningSampleSize.asStateFlow()
+ private val _planningCurrentSource = MutableStateFlow(null)
+ val planningCurrentSource = _planningCurrentSource.asStateFlow()
+ private val _sourceScope = MutableStateFlow(AlternativeSourceScope.Enabled)
+ val sourceScope = _sourceScope.asStateFlow()
+ private val _scopeOptions = MutableStateFlow(null)
+ val scopeOptions = _scopeOptions.asStateFlow()
+ private var sourceScopeInitialized = false
+ private var queueInitialized = false
+
+ private var planningJob: Job? = null
+ private var migrationJob: Job? = null
+ private var searchJob: Job? = null
+ private var manualSourceOrder = emptyList()
+ private val manualTriedSourceNames = mutableSetOf()
+
+ val onPlanReady = MutableEventFlow()
+ val onMigrated = MutableEventFlow()
+ val onBatchMigrated = MutableEventFlow()
+ private val _replacementSummary = MutableStateFlow(null)
+ val replacementSummary = _replacementSummary.asStateFlow()
+ private val replacementSourceUsage = linkedMapOf()
+ private var replacementCount = 0
+
+ private val screenState = combine(
+ isPlanning,
+ isComparingSources,
+ sourceComparisonItems,
+ ) { planning, comparing, sourceItems ->
+ ReplacementScreenState(planning, comparing, sourceItems)
+ }
+
+ val list: StateFlow> = combine(
+ results,
+ isLoading,
+ selectedSource,
+ screenState,
+ ) { result, loading, source, screen ->
+ when {
+ screen.planning -> emptyList()
+ screen.comparing -> screen.sourceItems + if (isManualMode.value) {
+ listOf(ButtonFooter(R.string.skip))
+ } else {
+ emptyList()
+ }
+ result.isEmpty() -> listOf(
+ when {
+ loading -> LoadingState()
+ source == null -> ButtonFooter(R.string.choose_source)
+ else -> SourceReplacementEmptyState
+ },
+ )
+
+ loading -> result + LoadingFooter()
+ else -> result
+ }
+ }.stateIn(viewModelScope + Dispatchers.IO, SharingStarted.Eagerly, emptyList())
+
+ init {
+ buildReplacementPlan()
+ }
+
+ fun selectSource(source: MangaSource?) {
+ if (isPlanning.value) {
+ return
+ }
+ if (source?.name in originalSourceNames) {
+ return
+ }
+ _isComparingSources.value = false
+ sourceComparisonItems.value = emptyList()
+ if (source == null) {
+ _isManualMode.value = true
+ _selectedSource.value = null
+ activeMatches.value = emptyMap()
+ results.value = emptyList()
+ updateMatchedCount()
+ return
+ }
+ _selectedSource.value = source
+ if (isManualMode.value) {
+ manualTriedSourceNames += source.name
+ activeMatches.value = emptyMap()
+ updateMatchedCount()
+ startSearch()
+ } else {
+ resolveSource(source)
+ }
+ }
+
+ fun retry() {
+ if (selectedSource.value == null) {
+ showSourceComparison()
+ } else {
+ startSearch()
+ }
+ }
+
+ fun search(query: String) {
+ if (!isManualMode.value || selectedSource.value == null) {
+ return
+ }
+ val normalizedQuery = query.trim()
+ if (normalizedQuery.isNotEmpty()) {
+ startSearch(normalizedQuery)
+ }
+ }
+
+ fun selectNextSource() {
+ if (isPlanning.value || !isManualMode.value) {
+ return
+ }
+ val next = manualSourceOrder.firstOrNull { it.name !in manualTriedSourceNames }
+ if (next == null) {
+ showSourceComparison()
+ } else {
+ selectSource(next)
+ }
+ }
+
+ fun skipCurrent() {
+ if (isPlanning.value || migrationJob?.isActive == true || mangaQueue.isEmpty()) {
+ return
+ }
+ planningJob?.cancel()
+ searchJob?.cancel()
+ val skipped = manga
+ mangaQueue = mangaQueue.filterNot { it.id == skipped.id }
+ _selectedSource.value = null
+ results.value = emptyList()
+ activeMatches.value = emptyMap()
+ manualSourceOrder = emptyList()
+ manualTriedSourceNames.clear()
+ _queueSize.value = mangaQueue.size
+ updateMatchedCount()
+ if (mangaQueue.isEmpty()) {
+ _replacementSummary.value = createReplacementSummary()
+ return
+ }
+ currentIndex = currentIndex.coerceAtMost(mangaQueue.lastIndex)
+ savedStateHandle[AppRouter.KEY_INDEX] = currentIndex
+ _currentManga.value = mangaQueue[currentIndex]
+ _queuePosition.value = currentIndex + 1
+ showSourceComparison()
+ }
+
+ fun skipRemaining() {
+ if (isPlanning.value || migrationJob?.isActive == true || mangaQueue.isEmpty()) {
+ return
+ }
+ planningJob?.cancel()
+ searchJob?.cancel()
+ mangaQueue = emptyList()
+ _selectedSource.value = null
+ _isComparingSources.value = false
+ results.value = emptyList()
+ sourceComparisonItems.value = emptyList()
+ activeMatches.value = emptyMap()
+ manualSourceOrder = emptyList()
+ manualTriedSourceNames.clear()
+ _queueSize.value = 0
+ updateMatchedCount()
+ _replacementSummary.value = createReplacementSummary()
+ }
+
+ fun selectSourceScope(sourceScope: AlternativeSourceScope) {
+ if (sourceScope == _sourceScope.value || scopeOptions.value?.isAvailable(sourceScope) != true) {
+ return
+ }
+ sourceScopeInitialized = true
+ _sourceScope.value = sourceScope
+ _selectedSource.value = null
+ _isComparingSources.value = false
+ _isManualMode.value = false
+ sourceComparisonItems.value = emptyList()
+ activeMatches.value = emptyMap()
+ results.value = emptyList()
+ updateMatchedCount()
+ buildReplacementPlan()
+ }
+
+ fun showSourceComparison() {
+ if (isPlanning.value) {
+ return
+ }
+ searchJob?.cancel()
+ _isComparingSources.value = true
+ sourceComparisonItems.value = emptyList()
+ searchJob = launchLoadingJob(Dispatchers.IO) {
+ val manual = isManualMode.value
+ val choices = getAvailableSources().let { available ->
+ if (manual) available.sortedBy { it.source.name } else available
+ }
+ val selectedName = selectedSource.value?.name
+ if (manual) {
+ manualSourceOrder = choices.map(SourceChoice::source)
+ }
+ sourceComparisonItems.value = choices.map { choice ->
+ SourceReplacementModel(
+ source = choice.source,
+ matched = choice.matched,
+ total = choice.total,
+ matchPercent = choice.matchPercent,
+ isSelected = choice.source.name == selectedName,
+ )
+ } + SourceReplacementModel(
+ source = null,
+ matched = 0,
+ total = 0,
+ matchPercent = 0,
+ isSelected = false,
+ )
+ }
+ }
+
+ private suspend fun getAvailableSources(): List {
+ val excludedNames = originalSourceNames + usedSourceNames + failedSourceNames
+ val ranked = replacementPlans.value.filter { it.source.name !in excludedNames }.map { plan ->
+ SourceChoice(
+ source = plan.source,
+ matched = plan.matchedCount,
+ total = plan.total,
+ averageTitleSimilarity = plan.averageTitleSimilarity,
+ )
+ }.sortedWith(
+ compareByDescending(SourceChoice::matched)
+ .thenByDescending(SourceChoice::averageTitleSimilarity),
+ )
+ val rankedSourceNames = ranked.mapTo(hashSetOf()) { it.source.name }
+ val sampleSize = replacementPlans.value.firstOrNull()?.total ?: mangaQueue.size.coerceAtMost(25)
+ val other = alternativesUseCase.getCandidateSources(
+ ref = originSource,
+ sourceScope = sourceScope.value,
+ sameLanguageOnly = true,
+ )
+ .filter { it.name !in excludedNames && it.name !in rankedSourceNames }
+ .sortedBy(MangaSource::name)
+ .map { SourceChoice(it, matched = 0, total = sampleSize, averageTitleSimilarity = 0f) }
+ return ranked + other
+ }
+
+ fun migrate(target: Manga) {
+ if (migrationJob?.isActive == true) {
+ return
+ }
+ val seed = manga
+ migrationJob = launchLoadingJob(Dispatchers.IO) {
+ migrateUseCase(seed, target)
+ recordReplacement(target.source)
+ mangaQueue = mangaQueue.filterNot { it.id == seed.id }
+ val remaining = mangaQueue.size
+ if (remaining > 0) {
+ moveToFirstRemaining()
+ }
+ _queueSize.value = remaining
+ updateMatchedCount()
+ if (remaining > 0) {
+ _selectedSource.value = null
+ results.value = emptyList()
+ showSourceComparison()
+ }
+ onMigrated.call(MigrationResult(target, remaining))
+ if (remaining == 0) {
+ _replacementSummary.value = createReplacementSummary()
+ }
+ }
+ }
+
+ private fun buildReplacementPlan() {
+ planningJob?.cancel()
+ _isPlanning.value = true
+ _planningStep.value = SourceReplacementStep.COMPARING_SOURCES
+ _planningProgress.value = 0
+ _planningTotal.value = 0
+ _planningSourcesRemaining.value = 0
+ _planningSampleSize.value = 0
+ _planningCurrentSource.value = null
+ results.value = emptyList()
+ planningJob = launchLoadingJob(Dispatchers.IO) {
+ var ready: PlanReady? = null
+ try {
+ val scopeOptions = alternativesUseCase.getSourceScopeOptions(
+ ref = originSource,
+ sameLanguageOnly = true,
+ )
+ _scopeOptions.value = scopeOptions
+ // Fall back to the default when the chosen scope went away, e.g. its preset was deleted.
+ if (!sourceScopeInitialized || !scopeOptions.isAvailable(_sourceScope.value)) {
+ _sourceScope.value = scopeOptions.defaultScope
+ sourceScopeInitialized = true
+ }
+ val sourceManga = mangaDataRepository.findAllMangaBySource(originSource)
+ if (!queueInitialized) {
+ val libraryManga = mangaDataRepository.findLibraryMangaBySource(originSource)
+ mangaQueue = (requestedManga.filter { it.source.name == originSource.name } + libraryManga)
+ .distinctBy(Manga::id)
+ queueInitialized = true
+ }
+ _replacementSummary.value = null
+ val initial = requestedManga.first { it.source.name == originSource.name }
+ currentIndex = mangaQueue.indexOfFirst { it.id == initial.id }.coerceAtLeast(0)
+ _currentManga.value = mangaQueue[currentIndex]
+ _queueSize.value = mangaQueue.size
+ _queuePosition.value = currentIndex + 1
+ val comparisonPool = (mangaQueue + sourceManga).distinctBy(Manga::id)
+ val plans = replacementPlanner(
+ manga = comparisonPool,
+ sourceScope = sourceScope.value,
+ excludedSourceNames = originalSourceNames + usedSourceNames + failedSourceNames,
+ onProgress = { progress ->
+ _planningProgress.value = progress.completedChecks
+ _planningTotal.value = progress.totalChecks
+ _planningSourcesRemaining.value = progress.remainingSources
+ _planningSampleSize.value = progress.sampleSize
+ },
+ onSourceFailed = { failedSourceNames += it.name },
+ )
+ val availablePlans = plans.filter { it.source.name !in usedSourceNames && it.source.name !in failedSourceNames }
+ replacementPlans.value = availablePlans
+ val best = availablePlans.firstOrNull()
+ _selectedSource.value = best?.source
+ activeMatches.value = emptyMap()
+ updateMatchedCount()
+ ready = PlanReady(best?.matchedCount ?: 0, mangaQueue.size)
+ } finally {
+ _isPlanning.value = false
+ }
+ ready?.let(onPlanReady::call)
+ }
+ }
+
+ private fun resolveSource(source: MangaSource) {
+ planningJob?.cancel()
+ searchJob?.cancel()
+ results.value = emptyList()
+ activeMatches.value = emptyMap()
+ updateMatchedCount()
+ _isPlanning.value = true
+ _planningStep.value = SourceReplacementStep.MATCHING_TITLES
+ _planningProgress.value = 0
+ _planningTotal.value = mangaQueue.size
+ _planningSourcesRemaining.value = 0
+ _planningSampleSize.value = mangaQueue.size
+ _planningCurrentSource.value = source
+ planningJob = launchLoadingJob(Dispatchers.IO) {
+ var showManual = false
+ try {
+ val resolved = replacementPlanner.resolve(mangaQueue, source) { completed, total ->
+ _planningProgress.value = completed
+ _planningTotal.value = total
+ }
+ if (selectedSource.value == source && !isManualMode.value) {
+ val combinedMatches = resolved.toMutableMap()
+ var unmatched = mangaQueue.filterNot { it.id in combinedMatches }
+ updateMatchedCount()
+ usedSourceNames += source.name
+ val mixSources = replacementPlans.value.map(SourceReplacementPlan::source)
+ .filter { it.name !in usedSourceNames && it.name !in originalSourceNames }
+ .distinctBy(MangaSource::name)
+ _planningStep.value = SourceReplacementStep.SMART_MIX
+ for ((index, mixSource) in mixSources.withIndex()) {
+ if (unmatched.isEmpty()) {
+ break
+ }
+ _planningCurrentSource.value = mixSource
+ _planningProgress.value = 0
+ _planningTotal.value = unmatched.size
+ _planningSourcesRemaining.value = mixSources.size - index
+ val mixed = replacementPlanner.resolve(unmatched, mixSource) { completed, total ->
+ _planningProgress.value = completed
+ _planningTotal.value = total
+ }
+ usedSourceNames += mixSource.name
+ combinedMatches.putAll(mixed)
+ unmatched = unmatched.filterNot { it.id in mixed }
+ }
+ activeMatches.value = combinedMatches
+ updateMatchedCount()
+ val replacements = getMatches()
+ _planningStep.value = SourceReplacementStep.APPLYING_MATCHES
+ _planningCurrentSource.value = null
+ _planningProgress.value = 0
+ _planningTotal.value = replacements.size
+ // Each migration is its own transaction: a failure (or cancellation) leaves the titles
+ // already moved in place and the rest untouched, still in the queue.
+ val replacedIds = HashSet(replacements.size)
+ var firstError: Throwable? = null
+ try {
+ replacements.forEachIndexed { index, (seed, target) ->
+ runCatchingCancellable {
+ migrateUseCase(seed, target)
+ }.onSuccess {
+ replacedIds += seed.id
+ recordReplacement(target.source)
+ }.onFailure { e ->
+ if (firstError == null) firstError = e
+ }
+ _planningProgress.value = index + 1
+ }
+ } finally {
+ mangaQueue = mangaQueue.filterNot { it.id in replacedIds }
+ }
+ firstError?.let { errorEvent.call(it) }
+ val remaining = mangaQueue.size
+ if (remaining > 0) {
+ moveToFirstRemaining()
+ }
+ _queueSize.value = remaining
+ activeMatches.value = emptyMap()
+ _isManualMode.value = remaining > 0
+ _selectedSource.value = null
+ updateMatchedCount()
+ showManual = remaining > 0
+ onBatchMigrated.call(BatchMigrationResult(replacedIds.size, remaining))
+ if (remaining == 0) {
+ _replacementSummary.value = createReplacementSummary()
+ }
+ }
+ } finally {
+ _isPlanning.value = false
+ }
+ if (showManual) {
+ showSourceComparison()
+ }
+ }
+ }
+
+ fun cancelPendingChecks() {
+ planningJob?.cancel()
+ searchJob?.cancel()
+ }
+
+ private fun moveToFirstRemaining() {
+ currentIndex = 0
+ savedStateHandle[AppRouter.KEY_INDEX] = currentIndex
+ val next = mangaQueue.first()
+ _queuePosition.value = 1
+ _currentManga.value = next
+ manualSourceOrder = emptyList()
+ manualTriedSourceNames.clear()
+ }
+
+ private fun updateMatchedCount() {
+ _matchedCount.value = if (selectedSource.value == null) 0 else getMatches().size
+ }
+
+ private fun recordReplacement(source: MangaSource) {
+ replacementCount++
+ val previous = replacementSourceUsage[source.name]
+ replacementSourceUsage[source.name] = SourceUsage(source, (previous?.count ?: 0) + 1)
+ }
+
+ private fun createReplacementSummary() = ReplacementSummary(
+ replaced = replacementCount,
+ sources = replacementSourceUsage.values.toList(),
+ )
+
+ private fun getMatches(): List> {
+ val resolved = activeMatches.value
+ return mangaQueue.mapNotNull { seed ->
+ resolved[seed.id]?.let { target -> seed to target }
+ }
+ }
+
+ private fun startSearch(query: String = manga.title) {
+ val seed = manga
+ val source = selectedSource.value ?: run {
+ results.value = emptyList()
+ return
+ }
+ searchJob?.cancel()
+ results.value = emptyList()
+ searchJob = launchLoadingJob(Dispatchers.IO) {
+ val reference = runCatchingCancellable {
+ mangaRepositoryFactory.create(seed.source).getDetails(seed)
+ }.getOrDefault(seed)
+ val candidates = alternativesUseCase.searchSource(reference, source, query)
+ candidates.collect { candidate ->
+ if (manga.id != seed.id || selectedSource.value != source) {
+ return@collect
+ }
+ val model = candidate.toAlternativeModel(reference)
+ results.update { current ->
+ if (current.any { it.manga.id == candidate.id }) current else current + model
+ }
+ }
+ }
+ }
+
+ private suspend fun Manga.toAlternativeModel(reference: Manga) = MangaAlternativeModel(
+ mangaModel = mangaListMapper.toListModel(this, ListMode.GRID) as MangaGridModel,
+ referenceChapters = reference.chaptersCount(),
+ )
+
+ data class SourceChoice(
+ val source: MangaSource,
+ val matched: Int,
+ val total: Int,
+ val averageTitleSimilarity: Float,
+ ) {
+ val matchPercent: Int
+ get() = if (total == 0) 0 else matched * 100 / total
+ }
+
+ data class PlanReady(
+ val matched: Int,
+ val total: Int,
+ )
+
+ data class MigrationResult(
+ val target: Manga,
+ val remaining: Int,
+ )
+
+ data class BatchMigrationResult(
+ val replaced: Int,
+ val remaining: Int,
+ )
+
+ data class SourceUsage(
+ val source: MangaSource,
+ val count: Int,
+ )
+
+ data class ReplacementSummary(
+ val replaced: Int,
+ val sources: List,
+ )
+
+}
+
+enum class SourceReplacementStep {
+ COMPARING_SOURCES,
+ MATCHING_TITLES,
+ SMART_MIX,
+ APPLYING_MATCHES,
+}
+
+private data class ReplacementScreenState(
+ val planning: Boolean,
+ val comparing: Boolean,
+ val sourceItems: List,
+)
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceScopeMenu.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceScopeMenu.kt
new file mode 100644
index 0000000000..c326265ec2
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/SourceScopeMenu.kt
@@ -0,0 +1,54 @@
+package io.github.landwarderer.futon.alternatives.ui
+
+import android.content.Context
+import android.view.Menu
+import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.alternatives.domain.AlternativeSourceScope
+import io.github.landwarderer.futon.alternatives.domain.AlternativeSourceScopeOptions
+
+/**
+ * The source-scope choices shared by the alternatives screen and source replacement: every usable
+ * preset, then enabled and disabled sources. Kept in one place so both screens always offer the same
+ * list in the same order.
+ */
+internal object SourceScopeMenu {
+
+ private const val ID_ENABLED = Menu.FIRST + 3000
+ private const val ID_DISABLED = Menu.FIRST + 3001
+ private const val ID_PRESET_FIRST = Menu.FIRST + 3100
+
+ /** Adds one checkable item per available scope to [menu], in [group]. */
+ fun populate(
+ menu: Menu,
+ group: Int,
+ options: AlternativeSourceScopeOptions?,
+ selected: AlternativeSourceScope,
+ ) {
+ options?.presets?.forEachIndexed { index, preset ->
+ menu.add(group, ID_PRESET_FIRST + index, Menu.NONE, preset.title).isChecked =
+ selected == AlternativeSourceScope.Preset(preset.id)
+ }
+ menu.add(group, ID_ENABLED, Menu.NONE, R.string.enabled_sources).isChecked =
+ selected == AlternativeSourceScope.Enabled
+ if (options?.hasDisabledSources == true) {
+ menu.add(group, ID_DISABLED, Menu.NONE, R.string.disabled_sources).isChecked =
+ selected == AlternativeSourceScope.Disabled
+ }
+ menu.setGroupCheckable(group, true, true)
+ }
+
+ /** The scope a tapped item stands for, or null when the id is not one of ours. */
+ fun scopeFor(itemId: Int, options: AlternativeSourceScopeOptions?): AlternativeSourceScope? = when (itemId) {
+ ID_ENABLED -> AlternativeSourceScope.Enabled
+ ID_DISABLED -> AlternativeSourceScope.Disabled
+ else -> options?.presets?.getOrNull(itemId - ID_PRESET_FIRST)?.let { AlternativeSourceScope.Preset(it.id) }
+ }
+
+ fun title(context: Context, scope: AlternativeSourceScope, options: AlternativeSourceScopeOptions?): String =
+ when (scope) {
+ AlternativeSourceScope.Enabled -> context.getString(R.string.enabled_sources)
+ AlternativeSourceScope.Disabled -> context.getString(R.string.disabled_sources)
+ is AlternativeSourceScope.Preset -> options?.presetTitle(scope.id)
+ ?: context.getString(R.string.source_presets)
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/covers/AlternativeCoverAD.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/covers/AlternativeCoverAD.kt
new file mode 100644
index 0000000000..dac4e3fa2b
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/covers/AlternativeCoverAD.kt
@@ -0,0 +1,33 @@
+package io.github.landwarderer.futon.alternatives.ui.covers
+
+import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
+import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.core.model.getTitle
+import io.github.landwarderer.futon.core.ui.list.AdapterDelegateClickListenerAdapter
+import io.github.landwarderer.futon.core.ui.list.OnListItemClickListener
+import io.github.landwarderer.futon.databinding.ItemCoverAlternativeBinding
+import io.github.landwarderer.futon.list.ui.model.ListModel
+
+fun alternativeCoverAD(
+ listener: OnListItemClickListener,
+) = adapterDelegateViewBinding(
+ { inflater, parent -> ItemCoverAlternativeBinding.inflate(inflater, parent, false) },
+) {
+
+ itemView.setOnClickListener(AdapterDelegateClickListenerAdapter(this, listener))
+
+ bind {
+ binding.textViewSource.text = if (item.isCurrent) {
+ context.getString(R.string.current_cover)
+ } else {
+ item.source.getTitle(context)
+ }
+ binding.imageViewCover.setImageAsync(item.coverUrl, item.manga)
+ // A ring on the thumbnail ties the carousel to the big preview above it.
+ binding.imageViewCover.strokeWidth = if (item.isSelected) {
+ context.resources.getDimension(R.dimen.cover_selection_stroke)
+ } else {
+ 0f
+ }
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/covers/AlternativeCoverModel.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/covers/AlternativeCoverModel.kt
new file mode 100644
index 0000000000..02638bb83c
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/covers/AlternativeCoverModel.kt
@@ -0,0 +1,28 @@
+package io.github.landwarderer.futon.alternatives.ui.covers
+
+import io.github.landwarderer.futon.list.ui.ListModelDiffCallback
+import io.github.landwarderer.futon.list.ui.model.ListModel
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaSource
+
+data class AlternativeCoverModel(
+ val coverUrl: String,
+ val source: MangaSource,
+ val manga: Manga,
+ /** The cover already in use, kept first in the carousel so it can be compared against. */
+ val isCurrent: Boolean,
+ val isSelected: Boolean,
+) : ListModel {
+
+ override fun areItemsTheSame(other: ListModel): Boolean {
+ return other is AlternativeCoverModel && other.coverUrl == coverUrl
+ }
+
+ override fun getChangePayload(previousState: ListModel): Any? {
+ return if (previousState is AlternativeCoverModel && previousState.isSelected != isSelected) {
+ ListModelDiffCallback.PAYLOAD_CHECKED_CHANGED
+ } else {
+ super.getChangePayload(previousState)
+ }
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/covers/AlternativeCoversActivity.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/covers/AlternativeCoversActivity.kt
new file mode 100644
index 0000000000..0550f62c8b
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/covers/AlternativeCoversActivity.kt
@@ -0,0 +1,132 @@
+package io.github.landwarderer.futon.alternatives.ui.covers
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.view.View
+import androidx.activity.result.contract.ActivityResultContract
+import androidx.activity.viewModels
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.isVisible
+import androidx.core.view.updatePadding
+import dagger.hilt.android.AndroidEntryPoint
+import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.core.model.MangaSource
+import io.github.landwarderer.futon.core.model.getTitle
+import io.github.landwarderer.futon.core.model.parcelable.ParcelableManga
+import io.github.landwarderer.futon.core.nav.AppRouter
+import io.github.landwarderer.futon.core.ui.BaseActivity
+import io.github.landwarderer.futon.core.ui.BaseListAdapter
+import io.github.landwarderer.futon.core.ui.list.OnListItemClickListener
+import io.github.landwarderer.futon.core.util.ext.consumeAll
+import io.github.landwarderer.futon.core.util.ext.observe
+import io.github.landwarderer.futon.databinding.ActivityAlternativeCoversBinding
+import io.github.landwarderer.futon.list.ui.adapter.ListItemType
+import io.github.landwarderer.futon.list.ui.model.ListModel
+import kotlinx.coroutines.flow.combine
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaSource
+
+/**
+ * Covers for the same title from other sources, to be compared against the current one and picked.
+ */
+@AndroidEntryPoint
+class AlternativeCoversActivity :
+ BaseActivity(),
+ OnListItemClickListener {
+
+ private val viewModel by viewModels()
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ setContentView(ActivityAlternativeCoversBinding.inflate(layoutInflater))
+ setDisplayHomeAsUp(isEnabled = true, showUpAsClose = true)
+ title = getString(R.string.alternative_covers)
+
+ val adapter = BaseListAdapter()
+ .addDelegate(ListItemType.MANGA_GRID, alternativeCoverAD(this))
+ viewBinding.recyclerView.adapter = adapter
+ viewBinding.buttonApply.setOnClickListener { applySelection() }
+
+ viewModel.covers.observe(this) { covers ->
+ adapter.items = covers
+ }
+ combine(viewModel.covers, viewModel.selectedUrl, ::Pair).observe(this) { (covers, url) ->
+ val selected = covers.firstOrNull { it.coverUrl == url }
+ viewBinding.imageViewPreview.setImageAsync(url, selected?.manga ?: viewModel.manga)
+ viewBinding.textViewStatus.text = when {
+ selected == null -> null
+ selected.isCurrent -> getString(R.string.current_cover)
+ else -> selected.source.getTitle(this)
+ }
+ // Re-picking the cover already in use would be a no-op write.
+ viewBinding.buttonApply.isEnabled = selected != null && !selected.isCurrent
+ }
+ combine(viewModel.covers, viewModel.isRunning, ::Pair).observe(this) { (covers, isRunning) ->
+ viewBinding.progress.isVisible = isRunning
+ // Count only alternatives: the current cover leads the list, but is absent entirely when the
+ // manga has no cover of its own.
+ val showEmpty = covers.none { !it.isCurrent } && !isRunning
+ viewBinding.textViewEmpty.isVisible = showEmpty
+ viewBinding.recyclerView.isVisible = !showEmpty
+ }
+ }
+
+ override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
+ val typeMask = WindowInsetsCompat.Type.systemBars()
+ val barsInsets = insets.getInsets(typeMask)
+ viewBinding.root.updatePadding(
+ left = barsInsets.left,
+ top = barsInsets.top,
+ right = barsInsets.right,
+ bottom = barsInsets.bottom,
+ )
+ return insets.consumeAll(typeMask)
+ }
+
+ /** Tapping the carousel only previews; applying is a deliberate second step. */
+ override fun onItemClick(item: AlternativeCoverModel, view: View) {
+ viewModel.select(item.coverUrl)
+ }
+
+ private fun applySelection() {
+ val url = viewModel.selectedUrl.value ?: return
+ val selected = viewModel.covers.value.firstOrNull { it.coverUrl == url } ?: return
+ // Whatever is still in flight is no longer worth fetching.
+ viewModel.cancelSearch()
+ setResult(
+ RESULT_OK,
+ Intent()
+ .putExtra(EXTRA_COVER_URL, url)
+ .putExtra(EXTRA_SOURCE, selected.source.name),
+ )
+ finish()
+ }
+
+ /** A cover picked from another source, with the source it came from (for request headers). */
+ data class PickedCover(
+ val url: String,
+ val source: MangaSource,
+ )
+
+ class Contract : ActivityResultContract() {
+
+ override fun createIntent(context: Context, input: Manga) =
+ Intent(context, AlternativeCoversActivity::class.java)
+ .putExtra(AppRouter.KEY_MANGA, ParcelableManga(input, withDescription = false))
+
+ override fun parseResult(resultCode: Int, intent: Intent?): PickedCover? {
+ if (resultCode != RESULT_OK || intent == null) {
+ return null
+ }
+ val url = intent.getStringExtra(EXTRA_COVER_URL) ?: return null
+ return PickedCover(url, MangaSource(intent.getStringExtra(EXTRA_SOURCE)))
+ }
+ }
+
+ private companion object {
+
+ const val EXTRA_COVER_URL = "cover_url"
+ const val EXTRA_SOURCE = "cover_source"
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/covers/AlternativeCoversViewModel.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/covers/AlternativeCoversViewModel.kt
new file mode 100644
index 0000000000..62bdbd8959
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/covers/AlternativeCoversViewModel.kt
@@ -0,0 +1,167 @@
+package io.github.landwarderer.futon.alternatives.ui.covers
+
+import android.content.Context
+import androidx.lifecycle.SavedStateHandle
+import coil3.ImageLoader
+import coil3.request.ImageRequest
+import coil3.request.allowRgb565
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.android.qualifiers.ApplicationContext
+import io.github.landwarderer.futon.alternatives.domain.AlternativesUseCase
+import io.github.landwarderer.futon.core.model.parcelable.ParcelableManga
+import io.github.landwarderer.futon.core.nav.AppRouter
+import io.github.landwarderer.futon.core.ui.BaseViewModel
+import io.github.landwarderer.futon.core.util.ext.mangaSourceExtra
+import io.github.landwarderer.futon.core.util.ext.require
+import io.github.landwarderer.futon.core.util.ext.toBitmapOrNull
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.Semaphore
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.sync.withPermit
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
+import java.util.Collections
+import javax.inject.Inject
+
+private const val HASH_PARALLELISM = 4
+
+@HiltViewModel
+class AlternativeCoversViewModel @Inject constructor(
+ savedStateHandle: SavedStateHandle,
+ private val alternativesUseCase: AlternativesUseCase,
+ @ApplicationContext private val context: Context,
+ private val coil: ImageLoader,
+) : BaseViewModel() {
+
+ val manga: Manga = savedStateHandle.require(AppRouter.KEY_MANGA).manga
+
+ /** Appended to as sources answer, so covers show up without waiting for the slowest source. */
+ val covers = MutableStateFlow>(emptyList())
+
+ /** Which cover the big preview is showing. */
+ val selectedUrl = MutableStateFlow(null)
+
+ val isRunning = MutableStateFlow(true)
+
+ /** Candidates are processed in parallel, so this must tolerate concurrent access. */
+ private val seenKeys = Collections.synchronizedSet(HashSet())
+
+ /** Perceptual hashes of the covers already accepted; candidates are hashed in parallel. */
+ private val acceptedHashes = ArrayList()
+ private val hashMutex = Mutex()
+ private val hashSemaphore = Semaphore(HASH_PARALLELISM)
+ private var searchJob: Job? = null
+
+ init {
+ // The current cover leads the carousel so a candidate can be compared against it, and its key is
+ // seeded so no source can offer the same image back as an "alternative".
+ manga.coverUrl?.takeUnless { it.isEmpty() }?.let { current ->
+ seenKeys += current.dedupKey()
+ covers.value = listOf(
+ AlternativeCoverModel(
+ coverUrl = current,
+ source = manga.source,
+ manga = manga,
+ isCurrent = true,
+ isSelected = true,
+ ),
+ )
+ selectedUrl.value = current
+ }
+ searchJob = launchLoadingJob(Dispatchers.Default) {
+ try {
+ // Seed the current cover's hash first, so a source offering the same artwork back is
+ // dropped rather than shown as an alternative to itself.
+ manga.coverUrl?.takeUnless { it.isEmpty() }?.let { rememberHash(it, manga.source) }
+ alternativesUseCase(manga, throughDisabledSources = false).collect { candidate ->
+ launch { onCandidate(candidate) }
+ }
+ } finally {
+ isRunning.value = false
+ }
+ }
+ }
+
+ /** Nothing more is worth fetching once a cover is chosen, or once the screen is left. */
+ fun cancelSearch() {
+ searchJob?.cancel()
+ searchJob = null
+ isRunning.value = false
+ }
+
+ override fun onCleared() {
+ cancelSearch()
+ super.onCleared()
+ }
+
+ fun select(url: String) {
+ if (selectedUrl.value == url) {
+ return
+ }
+ selectedUrl.value = url
+ covers.update { list -> list.map { it.copy(isSelected = it.coverUrl == url) } }
+ }
+
+ private suspend fun onCandidate(candidate: Manga) {
+ val url = candidate.coverUrl
+ if (url.isNullOrEmpty() || !seenKeys.add(url.dedupKey())) {
+ return
+ }
+ // Cheap url check first, then the image itself: sources republish the same artwork under
+ // different names often enough that the url tells you almost nothing.
+ if (!rememberHash(url, candidate.source)) {
+ return
+ }
+ covers.update { current ->
+ current + AlternativeCoverModel(
+ coverUrl = url,
+ source = candidate.source,
+ manga = candidate,
+ isCurrent = false,
+ isSelected = false,
+ )
+ }
+ }
+
+ /**
+ * Hashes a cover and records it, returning `false` when it looks like one already accepted.
+ *
+ * A cover that cannot be decoded is kept: a duplicate is a smaller problem than a missing option.
+ */
+ private suspend fun rememberHash(url: String, source: MangaSource): Boolean {
+ val hash = hashSemaphore.withPermit { hashOf(url, source) } ?: return true
+ return hashMutex.withLock {
+ if (acceptedHashes.any { CoverHash.isSame(it, hash) }) {
+ false
+ } else {
+ acceptedHashes.add(hash)
+ true
+ }
+ }
+ }
+
+ private suspend fun hashOf(url: String, source: MangaSource): Long? = runCatchingCancellable {
+ val request = ImageRequest.Builder(context)
+ .data(url)
+ .size(CoverHash.SAMPLE_WIDTH, CoverHash.SAMPLE_HEIGHT)
+ .allowRgb565(false)
+ .mangaSourceExtra(source)
+ .build()
+ coil.execute(request).toBitmapOrNull()?.let(CoverHash::of)
+ }.getOrNull()
+
+ /**
+ * Sources routinely mirror the same artwork under different urls, so comparing whole urls dedupes
+ * almost nothing. The filename is a decent proxy for "same image" without decoding anything.
+ */
+ private fun String.dedupKey(): String = substringBefore('?')
+ .substringAfterLast('/')
+ .lowercase()
+ .ifEmpty { this }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/covers/CoverHash.kt b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/covers/CoverHash.kt
new file mode 100644
index 0000000000..062f8036cf
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/alternatives/ui/covers/CoverHash.kt
@@ -0,0 +1,160 @@
+package io.github.landwarderer.futon.alternatives.ui.covers
+
+import android.graphics.Bitmap
+import androidx.core.graphics.get
+import kotlin.math.cos
+
+/**
+ * Perceptual hash of a cover, for spotting the same artwork republished by another source.
+ *
+ * Sources re-encode, pad and re-scale the same image, so url or byte equality catches almost none of
+ * the duplicates people actually see. Three steps make the comparison survive that:
+ *
+ * 1. trim near-uniform edges, which removes letterboxing and padding;
+ * 2. centre-crop to a fixed aspect, so covers stored at different proportions still line up;
+ * 3. hash the low-frequency DCT coefficients, which describe overall structure and ignore sharpening,
+ * compression and brightness.
+ *
+ * Known limit: a genuinely tighter crop of the same art still scores far apart.
+ */
+object CoverHash {
+
+ /** Source bitmap size to hash. Big enough that trimming edges leaves real detail behind. */
+ const val SAMPLE_WIDTH = 64
+ const val SAMPLE_HEIGHT = 96
+
+ /** Differing bits (out of 63) below which two covers are treated as the same image. */
+ const val MAX_DISTANCE = 12
+
+ private const val DCT_SIZE = 32
+ private const val HASH_SIZE = 8
+ private const val UNIFORM_TOLERANCE = 12
+ private const val TARGET_ASPECT = 2f / 3f
+
+ fun of(bitmap: Bitmap): Long = ofLuma(bitmap.toLuma())
+
+ /**
+ * Hashes a luma matrix (rows of 0..255 values). Pure, so it can be unit tested without Android.
+ */
+ fun ofLuma(luma: Array): Long {
+ require(luma.isNotEmpty() && luma[0].isNotEmpty()) { "Empty image" }
+ val trimmed = luma.autoCrop().centerToAspect()
+ val matrix = trimmed.scaleTo(DCT_SIZE)
+ val dct = matrix.dct2d()
+ // Low-frequency block only, minus the DC term: DC is average brightness, which we want ignored.
+ val values = DoubleArray(HASH_SIZE * HASH_SIZE - 1)
+ var i = 0
+ for (y in 0 until HASH_SIZE) {
+ for (x in 0 until HASH_SIZE) {
+ if (x != 0 || y != 0) {
+ values[i++] = dct[y][x]
+ }
+ }
+ }
+ val median = values.sortedArray()[values.size / 2]
+ var hash = 0L
+ values.forEachIndexed { index, value ->
+ if (value > median) {
+ hash = hash or (1L shl index)
+ }
+ }
+ return hash
+ }
+
+ fun distance(a: Long, b: Long): Int = java.lang.Long.bitCount(a xor b)
+
+ fun isSame(a: Long, b: Long): Boolean = distance(a, b) <= MAX_DISTANCE
+
+ private fun Bitmap.toLuma(): Array {
+ // getPixel throws on a hardware bitmap, and a fixed-size copy is needed anyway.
+ val software = if (config == Bitmap.Config.HARDWARE) copy(Bitmap.Config.ARGB_8888, false) ?: this else this
+ val scaled = Bitmap.createScaledBitmap(software, SAMPLE_WIDTH, SAMPLE_HEIGHT, true)
+ val out = Array(SAMPLE_HEIGHT) { IntArray(SAMPLE_WIDTH) }
+ for (y in 0 until SAMPLE_HEIGHT) {
+ for (x in 0 until SAMPLE_WIDTH) {
+ val pixel = scaled[x, y]
+ val r = (pixel shr 16) and 0xFF
+ val g = (pixel shr 8) and 0xFF
+ val b = pixel and 0xFF
+ // Rec. 601 luma in integer maths; float precision is meaningless at this size.
+ out[y][x] = (r * 299 + g * 587 + b * 114) / 1000
+ }
+ }
+ if (scaled !== software) scaled.recycle()
+ if (software !== this) software.recycle()
+ return out
+ }
+
+ /** Drops near-uniform edge rows and columns, so padding and letterboxing stop counting as content. */
+ private fun Array.autoCrop(): Array {
+ var top = 0
+ var bottom = size - 1
+ while (top < bottom && isRowUniform(top)) top++
+ while (bottom > top && isRowUniform(bottom)) bottom--
+ var left = 0
+ var right = this[0].size - 1
+ while (left < right && isColumnUniform(left, top, bottom)) left++
+ while (right > left && isColumnUniform(right, top, bottom)) right--
+ return Array(bottom - top + 1) { y -> this[top + y].copyOfRange(left, right + 1) }
+ }
+
+ private fun Array.centerToAspect(): Array {
+ val height = size
+ val width = this[0].size
+ val wantWidth = minOf(width, (height * TARGET_ASPECT).toInt()).coerceAtLeast(1)
+ val wantHeight = minOf(height, (wantWidth / TARGET_ASPECT).toInt()).coerceAtLeast(1)
+ val x0 = (width - wantWidth) / 2
+ val y0 = (height - wantHeight) / 2
+ return Array(wantHeight) { y -> this[y0 + y].copyOfRange(x0, x0 + wantWidth) }
+ }
+
+ private fun Array.scaleTo(size: Int): Array {
+ val height = this.size
+ val width = this[0].size
+ return Array(size) { y ->
+ DoubleArray(size) { x ->
+ this[y * height / size][x * width / size].toDouble()
+ }
+ }
+ }
+
+ private fun Array.dct2d(): Array {
+ val n = size
+ val rows = Array(n) { y -> this[y].dct1d() }
+ val out = Array(n) { DoubleArray(n) }
+ val column = DoubleArray(n)
+ for (x in 0 until n) {
+ for (y in 0 until n) column[y] = rows[y][x]
+ val transformed = column.dct1d()
+ for (y in 0 until n) out[y][x] = transformed[y]
+ }
+ return out
+ }
+
+ private fun DoubleArray.dct1d(): DoubleArray {
+ val n = size
+ return DoubleArray(n) { k ->
+ var sum = 0.0
+ for (i in 0 until n) {
+ sum += this[i] * cos(Math.PI * (i + 0.5) * k / n)
+ }
+ sum
+ }
+ }
+
+ private fun Array.isRowUniform(y: Int): Boolean {
+ val row = this[y]
+ return row.max() - row.min() <= UNIFORM_TOLERANCE
+ }
+
+ private fun Array.isColumnUniform(x: Int, top: Int, bottom: Int): Boolean {
+ var min = Int.MAX_VALUE
+ var max = Int.MIN_VALUE
+ for (y in top..bottom) {
+ val v = this[y][x]
+ if (v < min) min = v
+ if (v > max) max = v
+ }
+ return max - min <= UNIFORM_TOLERANCE
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/backups/data/BackupRepository.kt b/app/src/main/kotlin/io/github/landwarderer/futon/backups/data/BackupRepository.kt
index 62b3c43555..a331ac3de4 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/backups/data/BackupRepository.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/backups/data/BackupRepository.kt
@@ -191,8 +191,17 @@ class BackupRepository @Inject constructor(
getBookmarksDao().upsert(it.bookmarks.map { b -> b.toEntity() })
}
- BackupSection.SOURCES -> input.readJsonArray(serializer()).restoreToDb {
- getSourcesDao().upsert(it.toEntity())
+ BackupSection.SOURCES -> {
+ val sources = input.readJsonArray(serializer()).toList()
+ if (!isMerge && sources.isNotEmpty()) {
+ // The backup holds only the enabled sources, so a plain upsert would keep every
+ // source already enabled here, e.g. the defaults enabled on a fresh install.
+ // Replace the selection instead; merging keeps adding to it.
+ database.getSourcesDao().disableAllSources()
+ }
+ sources.asSequence().restoreToDb {
+ getSourcesDao().upsert(it.toEntity())
+ }
}
BackupSection.SCROBBLING -> input.readJsonArray(serializer()).restoreToDb {
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/bookmarks/ui/AllBookmarksViewModel.kt b/app/src/main/kotlin/io/github/landwarderer/futon/bookmarks/ui/AllBookmarksViewModel.kt
index 28e73b94b7..1f0d891fb0 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/bookmarks/ui/AllBookmarksViewModel.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/bookmarks/ui/AllBookmarksViewModel.kt
@@ -48,7 +48,7 @@ class AllBookmarksViewModel @Inject constructor(
}
}
.catch { e -> emit(listOf(e.toErrorState(canRetry = false))) }
- .stateIn(viewModelScope + Dispatchers.IO, SharingStarted.Eagerly, listOf(LoadingState))
+ .stateIn(viewModelScope + Dispatchers.IO, SharingStarted.Eagerly, listOf(LoadingState()))
fun removeBookmarks(ids: Set) {
launchJob(Dispatchers.IO) {
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/browser/cloudflare/CloudFlareActivity.kt b/app/src/main/kotlin/io/github/landwarderer/futon/browser/cloudflare/CloudFlareActivity.kt
index 3782d29c8c..212e48823f 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/browser/cloudflare/CloudFlareActivity.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/browser/cloudflare/CloudFlareActivity.kt
@@ -6,38 +6,67 @@ import android.os.Bundle
import android.util.Log
import android.view.Menu
import android.view.MenuItem
+import android.view.WindowManager
+import android.webkit.CookieManager
+import android.webkit.WebSettings
+import androidx.activity.OnBackPressedCallback
import androidx.activity.result.contract.ActivityResultContract
+import androidx.core.view.doOnLayout
+import androidx.core.view.isGone
import androidx.core.view.isInvisible
import androidx.lifecycle.lifecycleScope
import com.google.android.material.snackbar.Snackbar
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runInterruptible
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withTimeoutOrNull
import kotlinx.coroutines.yield
import okhttp3.HttpUrl
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
import io.github.landwarderer.futon.R
import io.github.landwarderer.futon.browser.BaseBrowserActivity
import io.github.landwarderer.futon.core.exceptions.CloudFlareProtectedException
+import io.github.landwarderer.futon.core.exceptions.resolve.CaptchaAutoResolveCoordinator
import io.github.landwarderer.futon.core.exceptions.resolve.CaptchaHandler
import io.github.landwarderer.futon.core.model.MangaSource
import io.github.landwarderer.futon.core.nav.AppRouter
import io.github.landwarderer.futon.core.network.cookies.MutableCookieJar
+import io.github.landwarderer.futon.core.network.webview.CF_STATE_JS
import io.github.landwarderer.futon.core.parser.ParserMangaRepository
import io.github.landwarderer.futon.core.util.ext.getDisplayMessage
import io.github.landwarderer.futon.core.util.ext.printStackTraceDebug
+import io.github.landwarderer.futon.core.util.ext.processLifecycleScope
import org.koitharu.kotatsu.parsers.config.ConfigKey
import org.koitharu.kotatsu.parsers.model.MangaSource
import org.koitharu.kotatsu.parsers.network.CloudFlareHelper
import org.koitharu.kotatsu.parsers.util.ifNullOrEmpty
import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
import javax.inject.Inject
+import kotlin.coroutines.resume
@AndroidEntryPoint
-class CloudFlareActivity : BaseBrowserActivity(), CloudFlareCallback {
+open class CloudFlareActivity : BaseBrowserActivity(), CloudFlareCallback {
+
+ protected open val isHiddenAutoResolveActivity = false
private var pendingResult = RESULT_CANCELED
+ private val isAutoResolve: Boolean by lazy { intent?.getBooleanExtra(EXTRA_AUTO_RESOLVE, false) == true }
+ val sessionId: Long by lazy { intent?.getLongExtra(EXTRA_SESSION_ID, 0L) ?: 0L }
+ private var resultNotified = false
+ private val autoRecreateCount: Int by lazy {
+ intent?.getIntExtra(EXTRA_AUTO_RECREATE_COUNT, 0) ?: 0
+ }
+ private var recreateRequested = false
+ private var clearanceAtLaunch: String? = null
+ private var clearanceUpdateObservedAt = 0L
+ private var challengeStartedAt = 0L
+ private var resolveJob: Job? = null
+ private var isHiddenPresentation = false
+ private var hiddenBackPressedCallback: OnBackPressedCallback? = null
@Inject
lateinit var cookieJar: MutableCookieJar
@@ -45,15 +74,41 @@ class CloudFlareActivity : BaseBrowserActivity(), CloudFlareCallback {
@Inject
lateinit var captchaHandler: CaptchaHandler
+ @Inject
+ lateinit var captchaAutoResolveCoordinator: CaptchaAutoResolveCoordinator
+
private lateinit var cfClient: CloudFlareClient
+ private var alignedUserAgent: String? = null
override fun onCreate2(savedInstanceState: Bundle?, source: MangaSource, repository: ParserMangaRepository?) {
- setDisplayHomeAsUp(isEnabled = true, showUpAsClose = true)
+ if (isHiddenAutoResolveActivity) {
+ isHiddenPresentation = true
+ // Keep the window focused and the WebView rendered: Turnstile treats a non-focused or
+ // detached WebView differently. The translucent theme exposes the previous screen.
+ viewBinding.appbar.isGone = true
+ viewBinding.root.alpha = HIDDEN_RENDER_ALPHA
+ window.setDimAmount(0f)
+ window.addFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE)
+ // Back must cancel the invisible solver, not navigate its WebView history.
+ hiddenBackPressedCallback = object : OnBackPressedCallback(true) {
+ override fun handleOnBackPressed() = cancelAutomaticResolve()
+ }.also { onBackPressedDispatcher.addCallback(this, it) }
+ (this as? CloudFlareHiddenActivity)?.let {
+ captchaAutoResolveCoordinator.registerHiddenActivity(it, sessionId)
+ }
+ if (isFinishing) {
+ return
+ }
+ } else {
+ setDisplayHomeAsUp(isEnabled = true, showUpAsClose = true)
+ }
val url = intent?.dataString
if (url.isNullOrEmpty()) {
finishAfterTransition()
return
}
+ clearanceAtLaunch = CloudFlareHelper.getClearanceCookie(cookieJar, url)
+ alignUserAgentWithEngine(repository)
// Check if source needs header interception
val needsInterception = shouldUseInterception(source, repository)
@@ -74,14 +129,32 @@ class CloudFlareActivity : BaseBrowserActivity(), CloudFlareCallback {
} catch (e: Exception) {
Snackbar.make(viewBinding.webView, e.getDisplayMessage(resources), Snackbar.LENGTH_LONG).show()
}
- if (savedInstanceState == null) {
+ if (savedInstanceState == null || autoRecreateCount > 0) {
+ if (isAutoResolve && autoRecreateCount == 0) {
+ // The clearance OkHttp has been presenting was rejected: do not let it short-circuit
+ // the challenge in the WebView.
+ url.toHttpUrlOrNull()?.let {
+ clearRejectedClearance(it)
+ CookieManager.getInstance().flush()
+ }
+ }
+ awaitChallengeViewport()
onTitleChanged(getString(R.string.loading_), url)
+ // Arm the resolve budget only now: the proxy config and the viewport wait above can take a while.
+ challengeStartedAt = System.currentTimeMillis()
viewBinding.webView.loadUrl(url)
+ } else {
+ // Restored after a configuration change: the WebView kept its page.
+ challengeStartedAt = System.currentTimeMillis()
}
}
+ // A cf_clearance change is not a completion signal. Cloudflare can update it while the
+ // interstitial is still running, so only the loaded page state may complete this flow.
+ resolveJob = lifecycleScope.launch { runResolveLoop() }
}
override fun onCreateOptionsMenu(menu: Menu?): Boolean {
+ if (isHiddenPresentation) return false
menuInflater.inflate(R.menu.opt_captcha, menu)
return super.onCreateOptionsMenu(menu)
}
@@ -103,32 +176,207 @@ class CloudFlareActivity : BaseBrowserActivity(), CloudFlareCallback {
override fun finish() {
setResult(pendingResult)
+ notifyAutoResolveResult()
super.finish()
}
+ override fun onDestroy() {
+ if (!isChangingConfigurations && !recreateRequested) {
+ // Destroyed without finish(): the coordinator must not wait for this solver any longer.
+ notifyAutoResolveResult()
+ }
+ (this as? CloudFlareHiddenActivity)?.let {
+ captchaAutoResolveCoordinator.unregisterHiddenActivity(it)
+ }
+ super.onDestroy()
+ }
+
+ /**
+ * In auto-resolve mode the originating screen may already be gone, so its ActivityResultLauncher won't
+ * deliver the result. Notify the singleton coordinator instead.
+ */
+ private fun notifyAutoResolveResult() {
+ if (isAutoResolve && !resultNotified) {
+ resultNotified = true
+ captchaAutoResolveCoordinator.notifyResolveResult(sessionId, pendingResult == RESULT_OK)
+ }
+ }
+
+ /** True only while this same WebView should remain invisible and at the top of the task. */
+ fun shouldStayHiddenAndFocused(): Boolean =
+ isAutoResolve && isHiddenPresentation && !isFinishing && !isDestroyed
+
+ /** Cancels the automatic session without leaving a hidden Activity or WebView behind. */
+ fun cancelAutomaticResolve() {
+ if (!isAutoResolve || isFinishing || isDestroyed) return
+ resolveJob?.cancel()
+ if (hasViewBinding()) {
+ viewBinding.webView.stopLoading()
+ }
+ finishAfterTransition()
+ }
+
override fun onLoadingStateChanged(isLoading: Boolean) = Unit
override fun onPageLoaded() {
viewBinding.progressBar.isInvisible = true
}
- override fun onLoopDetected() {
- restartCheck()
- }
+ // The resolve loop decides when the challenge is over; a reloading interstitial is not a failure by itself.
+ override fun onLoopDetected() = Unit
override fun onCheckPassed() {
+ if (isAutoResolve && autoRecreateCount < MAX_AUTO_RECREATE_COUNT) {
+ markClearanceUpdateObserved()
+ }
+ }
+
+ /**
+ * Do not start Turnstile until this Activity has a real viewport. The focus wait is bounded: a hidden
+ * solver that never wins focus must still load its URL.
+ */
+ private suspend fun awaitChallengeViewport() {
+ val focusDeadline = System.currentTimeMillis() + VIEWPORT_FOCUS_TIMEOUT_MS
+ while (!viewBinding.webView.hasWindowFocus() && System.currentTimeMillis() < focusDeadline) {
+ delay(VIEWPORT_POLL_INTERVAL_MS)
+ }
+ suspendCancellableCoroutine { cont ->
+ viewBinding.webView.doOnLayout {
+ if (cont.isActive) cont.resume(Unit)
+ }
+ }
+ suspendCancellableCoroutine { cont ->
+ viewBinding.webView.postOnAnimation {
+ if (cont.isActive) cont.resume(Unit)
+ }
+ }
+ }
+
+ /**
+ * Drives the challenge to completion. The target page must report [CF_STATE_JS] == "ok" for several
+ * consecutive probes, so the short DOM gap between two managed-challenge stages is not accepted.
+ * The probe is a passive, read-only DOM query of the parent page and does not perturb the challenge.
+ */
+ private suspend fun runResolveLoop() {
+ val budget = if (autoRecreateCount < MAX_AUTO_RECREATE_COUNT) {
+ AUTO_RETRY_DELAY_MS
+ } else {
+ MANUAL_FALLBACK_DELAY_MS
+ }
+ var consecutivePasses = 0
+ var lastState: String? = null
+ val requiredStablePasses = if (isHiddenAutoResolveActivity && autoRecreateCount > 0) {
+ HIDDEN_RECREATED_STABLE_PASSES
+ } else {
+ REQUIRED_STABLE_PASSES
+ }
+ while (true) {
+ delay(RESOLVE_POLL_INTERVAL_MS)
+ val startedAt = challengeStartedAt
+ if (startedAt == 0L) {
+ continue // nothing is loading yet
+ }
+ if (isAutoResolve && autoRecreateCount < MAX_AUTO_RECREATE_COUNT) {
+ val clearance = intent.dataString?.let {
+ CloudFlareHelper.getClearanceCookie(cookieJar, it)
+ }
+ if (clearance != null && clearance != clearanceAtLaunch) {
+ markClearanceUpdateObserved()
+ }
+ }
+ val state = probeChallengeState()
+ if (state != lastState) {
+ Log.d(TAG, "Challenge state: $state")
+ lastState = state
+ }
+ if (state == CF_STATE_OK) {
+ consecutivePasses++
+ if (consecutivePasses >= requiredStablePasses) {
+ finishSuccess()
+ return
+ }
+ } else {
+ consecutivePasses = 0
+ val now = System.currentTimeMillis()
+ val retryAt = startedAt + budget
+ if (
+ clearanceUpdateObservedAt != 0L &&
+ now - clearanceUpdateObservedAt >= CLEARANCE_RECREATE_GRACE_MS
+ ) {
+ requestAutoRecreate()
+ return
+ }
+ if (isAutoResolve && autoRecreateCount < MAX_AUTO_RECREATE_COUNT && now >= retryAt) {
+ requestAutoRecreate()
+ return
+ }
+ if (isAutoResolve && autoRecreateCount >= MAX_AUTO_RECREATE_COUNT && now >= retryAt) {
+ revealForManualCompletion()
+ }
+ }
+ }
+ }
+
+ private fun markClearanceUpdateObserved() {
+ if (clearanceUpdateObservedAt == 0L) {
+ clearanceUpdateObservedAt = System.currentTimeMillis()
+ }
+ }
+
+ /** Recreates the solver once, keeping the warmed-up browser profile (cookies, storage). */
+ private fun requestAutoRecreate() {
+ if (recreateRequested || autoRecreateCount >= MAX_AUTO_RECREATE_COUNT) return
+ recreateRequested = true
+ resolveJob?.cancel()
+ CookieManager.getInstance().flush()
+ intent.putExtra(EXTRA_AUTO_RECREATE_COUNT, autoRecreateCount + 1)
+ recreate()
+ }
+
+ /** Falls back to manual completion without discarding the warmed browser profile or WebView. */
+ private fun revealForManualCompletion() {
+ if (!isHiddenPresentation) return
+ isHiddenPresentation = false
+ viewBinding.root.alpha = 1f
+ viewBinding.appbar.isGone = false
+ window.clearFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE)
+ hiddenBackPressedCallback?.isEnabled = false
+ setDisplayHomeAsUp(isEnabled = true, showUpAsClose = true)
+ invalidateOptionsMenu()
+ }
+
+ /** A WebView busy navigating may never answer [evaluateJavascript]: count that as still waiting. */
+ private suspend fun probeChallengeState(): String = withTimeoutOrNull(PROBE_TIMEOUT_MS) {
+ suspendCancellableCoroutine { cont ->
+ viewBinding.webView.evaluateJavascript(CF_STATE_JS) { raw ->
+ if (cont.isActive) {
+ cont.resume(raw?.removeSurrounding("\"") ?: CF_STATE_WAIT)
+ }
+ }
+ }
+ } ?: CF_STATE_WAIT
+
+ private fun finishSuccess() {
+ if (pendingResult == RESULT_OK) return
pendingResult = RESULT_OK
- lifecycleScope.launch {
- val source = intent?.getStringExtra(AppRouter.KEY_SOURCE)
- if (source != null) {
+ resolveJob?.cancel()
+ rememberAlignedUserAgent()
+ // Persist the final cookie state before the WebView is destroyed and the parser retries.
+ CookieManager.getInstance().flush()
+ val source = intent?.getStringExtra(AppRouter.KEY_SOURCE)
+ if (source != null) {
+ // Not tied to this Activity: discard() waits for the captcha lock and rebuilds the remaining
+ // captcha notifications, favicons included. Closing must not wait for that, and closing (or the
+ // user tapping X meanwhile) must not cancel it, or the solve is never reported.
+ processLifecycleScope.launch {
runCatchingCancellable {
captchaHandler.discard(MangaSource(source))
}.onFailure {
- it.printStackTraceDebug("CloudFlareActivity::onCheckPassed")
+ it.printStackTraceDebug("CloudFlareActivity::finishSuccess")
}
}
- finishAfterTransition()
}
+ finishAfterTransition()
}
override fun onTitleChanged(title: CharSequence, subtitle: CharSequence?) {
@@ -138,23 +386,65 @@ class CloudFlareActivity : BaseBrowserActivity(), CloudFlareCallback {
private fun restartCheck() {
lifecycleScope.launch {
+ resolveJob?.cancel()
viewBinding.webView.stopLoading()
yield()
cfClient.reset()
val targetUrl = intent?.dataString?.toHttpUrlOrNull()
if (targetUrl != null) {
clearCfCookies(targetUrl)
+ clearanceUpdateObservedAt = 0L
+ challengeStartedAt = System.currentTimeMillis()
viewBinding.webView.loadUrl(targetUrl.toString())
+ resolveJob = lifecycleScope.launch { runResolveLoop() }
}
}
}
+ private suspend fun clearRejectedClearance(url: HttpUrl) = runInterruptible(Dispatchers.IO) {
+ cookieJar.removeCookies(url) { cookie ->
+ cookie.name == CLEARANCE_COOKIE_NAME
+ }
+ }
+
private suspend fun clearCfCookies(url: HttpUrl) = runInterruptible(Dispatchers.IO) {
cookieJar.removeCookies(url) { cookie ->
CloudFlareHelper.isCloudFlareCookie(cookie.name)
}
}
+ /**
+ * Turnstile cannot be passed by a WebView that lies about what it is. Some parsers pin a desktop
+ * User-Agent, which contradicts everything the challenge script measures (`navigator.userAgentData`,
+ * platform, touch points, WebGL renderer), so the challenge reloads forever. Realign such an agent
+ * with the engine's own; sources whose agent already looks like Android are left untouched.
+ */
+ private fun alignUserAgentWithEngine(repository: ParserMangaRepository?) {
+ if (repository == null) return
+ val engineUserAgent = runCatching { WebSettings.getDefaultUserAgent(this) }.getOrNull()
+ if (engineUserAgent.isNullOrEmpty() || ANDROID_UA_TOKEN !in engineUserAgent) return
+ val currentUserAgent = viewBinding.webView.settings.userAgentString
+ if (currentUserAgent.isNullOrEmpty() || ANDROID_UA_TOKEN in currentUserAgent) return
+ viewBinding.webView.settings.userAgentString = engineUserAgent
+ alignedUserAgent = engineUserAgent
+ }
+
+ /**
+ * The clearance cookie is bound to the User-Agent that earned it, so OkHttp has to present the same
+ * one. Writing [ConfigKey.UserAgent] would not do, since parsers with a hard-coded agent never read it.
+ */
+ private fun rememberAlignedUserAgent() {
+ val userAgent = alignedUserAgent ?: return
+ val source = intent?.getStringExtra(AppRouter.KEY_SOURCE) ?: return
+ runCatching {
+ (mangaRepositoryFactory.create(MangaSource(source)) as? ParserMangaRepository)
+ ?.getConfig()
+ ?.cloudFlareUserAgent = userAgent
+ }.onFailure {
+ it.printStackTraceDebug("CloudFlareActivity::rememberAlignedUserAgent")
+ }
+ }
+
private fun shouldUseInterception(source: MangaSource, repository: ParserMangaRepository?): Boolean {
Log.d(TAG, "shouldUseInterception called for source: ${source.name}")
Log.d(TAG, "Repository type: ${repository?.javaClass?.simpleName}")
@@ -193,5 +483,23 @@ class CloudFlareActivity : BaseBrowserActivity(), CloudFlareCallback {
companion object {
const val TAG = "CloudFlareActivity"
+ const val EXTRA_AUTO_RESOLVE = "auto_resolve"
+ const val EXTRA_SESSION_ID = "auto_resolve_session"
+ private const val EXTRA_AUTO_RECREATE_COUNT = "auto_recreate_count"
+ private const val VIEWPORT_POLL_INTERVAL_MS = 16L
+ private const val VIEWPORT_FOCUS_TIMEOUT_MS = 2_000L
+ private const val RESOLVE_POLL_INTERVAL_MS = 800L
+ private const val PROBE_TIMEOUT_MS = 2_000L
+ private const val AUTO_RETRY_DELAY_MS = 6_000L
+ private const val MANUAL_FALLBACK_DELAY_MS = 15_000L
+ private const val CLEARANCE_RECREATE_GRACE_MS = 500L
+ private const val REQUIRED_STABLE_PASSES = 3
+ private const val HIDDEN_RECREATED_STABLE_PASSES = 1
+ private const val MAX_AUTO_RECREATE_COUNT = 1
+ private const val CLEARANCE_COOKIE_NAME = "cf_clearance"
+ private const val HIDDEN_RENDER_ALPHA = 0.01f
+ private const val CF_STATE_OK = "ok"
+ private const val CF_STATE_WAIT = "wait"
+ private const val ANDROID_UA_TOKEN = "Android"
}
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/browser/cloudflare/CloudFlareHiddenActivity.kt b/app/src/main/kotlin/io/github/landwarderer/futon/browser/cloudflare/CloudFlareHiddenActivity.kt
new file mode 100644
index 0000000000..a0524496c1
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/browser/cloudflare/CloudFlareHiddenActivity.kt
@@ -0,0 +1,14 @@
+package io.github.landwarderer.futon.browser.cloudflare
+
+import dagger.hilt.android.AndroidEntryPoint
+
+/**
+ * Automatic Cloudflare resolver that remains focused and rendered behind a translucent window.
+ */
+@AndroidEntryPoint
+class CloudFlareHiddenActivity : CloudFlareActivity() {
+
+ override val applyColorSchemeTheme: Boolean = false
+
+ override val isHiddenAutoResolveActivity = true
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/AppModule.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/AppModule.kt
index c5d07a2c12..05f90f91cb 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/AppModule.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/AppModule.kt
@@ -28,8 +28,10 @@ import dagger.multibindings.ElementsIntoSet
import io.github.landwarderer.futon.BuildConfig
import io.github.landwarderer.futon.backups.domain.BackupObserver
import io.github.landwarderer.futon.core.db.MangaDatabase
+import io.github.landwarderer.futon.core.exceptions.resolve.CaptchaAutoResolveCoordinator
import io.github.landwarderer.futon.core.exceptions.resolve.CaptchaHandler
import io.github.landwarderer.futon.core.image.AvifImageDecoder
+import io.github.landwarderer.futon.core.image.JxlImageDecoder
import io.github.landwarderer.futon.core.image.CbzFetcher
import io.github.landwarderer.futon.core.image.MangaSourceHeaderInterceptor
import io.github.landwarderer.futon.core.network.MangaHttpClient
@@ -41,6 +43,7 @@ import io.github.landwarderer.futon.core.parser.favicon.FaviconFetcher
import io.github.landwarderer.futon.core.prefs.AppSettings
import io.github.landwarderer.futon.core.ui.image.CoilImageGetter
import io.github.landwarderer.futon.core.ui.util.ActivityRecreationHandle
+import io.github.landwarderer.futon.core.ui.util.ForegroundActivityHolder
import io.github.landwarderer.futon.core.util.FileSize
import io.github.landwarderer.futon.core.util.ext.connectivityManager
import io.github.landwarderer.futon.core.util.ext.isLowRamDevice
@@ -140,6 +143,7 @@ interface AppModule {
add(SvgDecoder.Factory())
add(CbzFetcher.Factory())
add(AvifImageDecoder.Factory())
+ add(JxlImageDecoder.Factory())
add(faviconFetcherFactory)
add(MangaPageKeyer())
add(pageFetcherFactory)
@@ -174,11 +178,15 @@ interface AppModule {
appProtectHelper: AppProtectHelper,
activityRecreationHandle: ActivityRecreationHandle,
screenshotPolicyHelper: ScreenshotPolicyHelper,
+ foregroundActivityHolder: ForegroundActivityHolder,
+ captchaAutoResolveCoordinator: CaptchaAutoResolveCoordinator,
): Set<@JvmSuppressWildcards Application.ActivityLifecycleCallbacks> = arraySetOf(
appProtectHelper,
activityRecreationHandle,
screenshotPolicyHelper,
- )
+ foregroundActivityHolder,
+ captchaAutoResolveCoordinator,
+ )
@Provides
@Singleton
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/ContentTypeCondition.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/ContentTypeCondition.kt
new file mode 100644
index 0000000000..1342aeba6a
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/ContentTypeCondition.kt
@@ -0,0 +1,54 @@
+package io.github.landwarderer.futon.core.db
+
+import org.koitharu.kotatsu.parsers.model.ContentType
+import org.koitharu.kotatsu.parsers.model.MangaParserSource
+
+/**
+ * SQL predicate selecting library manga of the given [contentType], for a query joined with `manga`.
+ *
+ * Built-in parsers declare a content type, so their manga are selected by source name. Mihon
+ * extensions do not: Futon's wrapper reports every Mihon source as plain manga (or hentai), so a
+ * source-based lookup would put every Mihon webtoon under "Manga" and hide it from "Manhwa". For
+ * those sources the manga's own genre tags are used instead - many sites tag their entries with
+ * "Manhwa" or "Manhua" - and a Mihon manga carrying no such tag is only listed when no content type
+ * is selected.
+ */
+internal fun contentTypeCondition(
+ contentType: ContentType,
+ parserSources: Collection = MangaParserSource.entries,
+): String {
+ val conditions = ArrayList(2)
+ val sourceNames = parserSources.filter { it.contentType == contentType }
+ if (sourceNames.isNotEmpty()) {
+ conditions += sourceNames.joinToString(
+ prefix = "manga.source IN (",
+ postfix = ")",
+ transform = { sqlQuote(it.name) },
+ )
+ }
+ val tagTitles = contentTypeTagTitles(contentType)
+ if (tagTitles.isNotEmpty()) {
+ conditions += "($MIHON_SOURCE_CONDITION AND EXISTS(SELECT 1 FROM manga_tags " +
+ "INNER JOIN tags ON tags.tag_id = manga_tags.tag_id WHERE manga_tags.manga_id = manga.manga_id " +
+ "AND LOWER(tags.title) IN (${tagTitles.joinToString { sqlQuote(it) }})))"
+ }
+ return when (conditions.size) {
+ 0 -> "0"
+ 1 -> conditions.single()
+ else -> conditions.joinToString(separator = " OR ", prefix = "(", postfix = ")")
+ }
+}
+
+/** Lower-case genre tag titles that mark a manga from a source without a declared content type. */
+internal fun contentTypeTagTitles(contentType: ContentType): List = when (contentType) {
+ ContentType.MANGA -> listOf("manga")
+ ContentType.MANHWA -> listOf("manhwa")
+ ContentType.MANHUA -> listOf("manhua")
+ else -> emptyList()
+}
+
+/** Matches the names Mihon sources are stored under (see `MangaSource(name)`). */
+private const val MIHON_SOURCE_CONDITION = "(manga.source LIKE 'MIHON\\_%' ESCAPE '\\' OR manga.source LIKE 'mihon:%')"
+
+/** Quotes a constant as an SQL string literal. Only used for values built into the app. */
+internal fun sqlQuote(value: String): String = "'" + value.replace("'", "''") + "'"
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/LibrarySearchQuery.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/LibrarySearchQuery.kt
new file mode 100644
index 0000000000..2ddf159255
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/LibrarySearchQuery.kt
@@ -0,0 +1,59 @@
+package io.github.landwarderer.futon.core.db
+
+/**
+ * Text filtering a library screen (History, Favourites), together with the source names it was
+ * resolved to by [SourceSearchFilter].
+ */
+data class LibrarySearchQuery(
+ val text: String,
+ val sourceNames: List = emptyList(),
+) {
+
+ fun isEmpty() = text.isEmpty()
+
+ companion object {
+
+ val EMPTY = LibrarySearchQuery("")
+ }
+}
+
+/** An SQL fragment with the arguments bound to its `?` placeholders, in order. */
+class SqlCondition(
+ val sql: String,
+ val args: List,
+)
+
+/** `%text%` with LIKE wildcards in [text] escaped, for use with `ESCAPE '\'`. */
+fun likeContainsPattern(text: String): String = buildString(text.length + 2) {
+ append('%')
+ for (c in text) {
+ if (c == '\\' || c == '%' || c == '_') {
+ append('\\')
+ }
+ append(c)
+ }
+ append('%')
+}
+
+/**
+ * Matches anything that identifies an entry on a library screen: its title, the source it came
+ * from, and the favourites list it is filed under. All user text is bound, never inlined.
+ *
+ * @param categoryMatch a predicate on the entry's favourites lists with a single `?` placeholder
+ * for the LIKE pattern, e.g. `EXISTS(... c.title LIKE ? ESCAPE '\')`
+ */
+fun librarySearchCondition(query: LibrarySearchQuery, categoryMatch: String): SqlCondition {
+ require(categoryMatch.count { it == '?' } == 1) { "categoryMatch must have exactly one placeholder" }
+ val pattern = likeContainsPattern(query.text)
+ val args = ArrayList(3 + query.sourceNames.size)
+ val sql = StringBuilder("(manga.title LIKE ? ESCAPE '\\' OR manga.alt_title LIKE ? ESCAPE '\\'")
+ args += pattern
+ args += pattern
+ if (query.sourceNames.isNotEmpty()) {
+ query.sourceNames.joinTo(sql, prefix = " OR manga.source IN (", postfix = ")") { "?" }
+ args.addAll(query.sourceNames)
+ }
+ sql.append(" OR ").append(categoryMatch).append(')')
+ args += pattern
+ return SqlCondition(sql.toString(), args)
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/MangaDatabase.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/MangaDatabase.kt
index 8deadeef22..a39dd96f33 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/MangaDatabase.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/MangaDatabase.kt
@@ -47,6 +47,7 @@ import io.github.landwarderer.futon.core.db.migrations.Migration27To28
import io.github.landwarderer.futon.core.db.migrations.Migration28To29
import io.github.landwarderer.futon.core.db.migrations.Migration29To30
import io.github.landwarderer.futon.core.db.migrations.Migration2To3
+import io.github.landwarderer.futon.core.db.migrations.Migration30To31
import io.github.landwarderer.futon.core.db.migrations.Migration3To4
import io.github.landwarderer.futon.core.db.migrations.Migration4To5
import io.github.landwarderer.futon.core.db.migrations.Migration5To6
@@ -59,6 +60,8 @@ import io.github.landwarderer.futon.download.data.dao.DownloadQueueDao
import io.github.landwarderer.futon.download.data.dao.SmartDownloadDao
import io.github.landwarderer.futon.download.data.entity.DownloadQueueEntity
import io.github.landwarderer.futon.download.data.entity.SmartDownloadEntity
+import io.github.landwarderer.futon.explore.data.SourcePresetEntity
+import io.github.landwarderer.futon.explore.data.SourcePresetsDao
import io.github.landwarderer.futon.favourites.data.FavouriteCategoriesDao
import io.github.landwarderer.futon.favourites.data.FavouriteCategoryEntity
import io.github.landwarderer.futon.favourites.data.FavouriteEntity
@@ -81,7 +84,7 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.isActive
import kotlinx.coroutines.launch
-const val DATABASE_VERSION = 30
+const val DATABASE_VERSION = 31
@Database(
entities = [
@@ -89,7 +92,7 @@ const val DATABASE_VERSION = 30
FavouriteCategoryEntity::class, FavouriteEntity::class, MangaPrefsEntity::class, TrackEntity::class,
TrackLogEntity::class, SuggestionEntity::class, BookmarkEntity::class, ScrobblingEntity::class,
MangaSourceEntity::class, StatsEntity::class, LocalMangaIndexEntity::class, ExternalExtensionRepoEntity::class,
- DownloadQueueEntity::class, SmartDownloadEntity::class,
+ DownloadQueueEntity::class, SmartDownloadEntity::class, SourcePresetEntity::class,
],
version = DATABASE_VERSION,
)
@@ -131,6 +134,8 @@ abstract class MangaDatabase : RoomDatabase() {
abstract fun getDownloadQueueDao(): DownloadQueueDao
abstract fun getSmartDownloadDao(): SmartDownloadDao
+
+ abstract fun getSourcePresetsDao(): SourcePresetsDao
}
fun getDatabaseMigrations(context: Context): Array = arrayOf(
@@ -163,7 +168,8 @@ fun getDatabaseMigrations(context: Context): Array = arrayOf(
Migration26To27(),
Migration27To28(),
Migration28To29(),
- Migration29To30(),
+ Migration29To30(),
+ Migration30To31(),
)
fun MangaDatabase(context: Context): MangaDatabase = Room
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/MangaQueryBuilder.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/MangaQueryBuilder.kt
index 8b7f6a79a4..6dd4f0f3bf 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/MangaQueryBuilder.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/MangaQueryBuilder.kt
@@ -11,6 +11,7 @@ class MangaQueryBuilder(
private var filterOptions: Collection = emptyList()
private var whereConditions = LinkedList()
+ private val whereArgs = ArrayList()
private var orderBy: String? = null
private var groupBy: String? = null
private var extraJoins: String? = null
@@ -24,6 +25,12 @@ class MangaQueryBuilder(
whereConditions.add(condition)
}
+ /** A condition with bound arguments; they are bound in the order the conditions were added. */
+ fun where(condition: SqlCondition) = apply {
+ whereConditions.add(condition.sql)
+ whereArgs.addAll(condition.args)
+ }
+
fun orderBy(orderBy: String?) = apply {
this@MangaQueryBuilder.orderBy = orderBy
}
@@ -97,7 +104,7 @@ class MangaQueryBuilder(
append(" LIMIT ")
append(limit)
}
- }.let { SimpleSQLiteQuery(it) }
+ }.let { SimpleSQLiteQuery(it, whereArgs.toTypedArray()) }
private fun getConditionOrThrow(option: ListFilterOption): String = when (option) {
is ListFilterOption.Inverted -> "NOT(${getConditionOrThrow(option.option)})"
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/SourceSearchFilter.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/SourceSearchFilter.kt
new file mode 100644
index 0000000000..1ad4a0d38d
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/SourceSearchFilter.kt
@@ -0,0 +1,88 @@
+package io.github.landwarderer.futon.core.db
+
+import dagger.Reusable
+import io.github.landwarderer.futon.mihon.MihonExtensionManager
+import org.koitharu.kotatsu.parsers.model.MangaParserSource
+import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
+import javax.inject.Inject
+
+/**
+ * Resolves search text to the source names stored in `manga.source`.
+ *
+ * The column holds identifiers (`MANGAFIRE_EN` for a built-in parser, `MIHON_` for a Mihon
+ * extension) while everything the user sees - the search bar, the suggestion row - carries the
+ * display title ("MangaFire (English)", "Asura Scans"). The two are not derivable from one another,
+ * so the text is matched against the real source list and the exact names are emitted.
+ *
+ * Mihon titles come from the installed extensions and, for extensions that have since been
+ * uninstalled, from the titles persisted in the `sources` table.
+ */
+@Reusable
+class SourceSearchFilter @Inject constructor(
+ private val db: MangaDatabase,
+ private val mihonExtensionManager: MihonExtensionManager,
+) {
+
+ /** The screen filter for [text], with the sources it names resolved. */
+ suspend fun resolve(text: String): LibrarySearchQuery = if (text.isEmpty()) {
+ LibrarySearchQuery.EMPTY
+ } else {
+ LibrarySearchQuery(text, findSourceNames(text))
+ }
+
+ suspend fun findSourceNames(query: String): List {
+ if (query.trim().length < MIN_QUERY_LENGTH) {
+ return emptyList()
+ }
+ val candidates = ArrayList(MangaParserSource.entries.size + 64)
+ MangaParserSource.entries.mapTo(candidates) { SourceCandidate(it.name, it.title) }
+ mihonExtensionManager.getMihonMangaSources().mapTo(candidates) { SourceCandidate(it.name, it.displayName) }
+ runCatchingCancellable {
+ db.getSourcesDao().findAll()
+ }.getOrNull()?.forEach { entity ->
+ val title = entity.title
+ if (!title.isNullOrEmpty() && isMihonSourceName(entity.source)) {
+ candidates += SourceCandidate(entity.source, title)
+ }
+ }
+ return matchSourceNames(query, candidates)
+ }
+
+ data class SourceCandidate(
+ val name: String,
+ val title: String,
+ )
+
+ companion object {
+
+ /** Two characters is where a contains match stops selecting most of the source list. */
+ private const val MIN_QUERY_LENGTH = 2
+
+ private const val MAX_SOURCES = 24
+
+ fun isMihonSourceName(name: String) = name.startsWith("MIHON_") || name.startsWith("mihon:")
+
+ /**
+ * An exact title match wins, which is what a tapped suggestion produces and what keeps sibling
+ * locales apart - picking "MangaFire (English)" must not also select `MANGAFIRE_PTBR`. Typed
+ * text falls back to a contains match, where selecting every MangaFire locale is the
+ * reasonable reading.
+ */
+ fun matchSourceNames(query: String, candidates: Collection): List {
+ val q = query.trim()
+ if (q.length < MIN_QUERY_LENGTH) {
+ return emptyList()
+ }
+ val exact = candidates.filter { it.title.equals(q, ignoreCase = true) }
+ if (exact.isNotEmpty()) {
+ return exact.mapTo(LinkedHashSet()) { it.name }.toList()
+ }
+ return candidates.asSequence()
+ .filter { it.title.contains(q, ignoreCase = true) }
+ .map { it.name }
+ .distinct()
+ .take(MAX_SOURCES)
+ .toList()
+ }
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/Tables.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/Tables.kt
index 5b7602df7d..d0158e56a5 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/Tables.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/Tables.kt
@@ -11,3 +11,4 @@ const val TABLE_CHAPTERS = "chapters"
const val TABLE_PREFERENCES = "preferences"
const val TABLE_DOWNLOAD_QUEUE = "download_queue"
const val TABLE_SMART_DOWNLOADS = "smart_downloads"
+const val TABLE_SOURCE_PRESETS = "source_presets"
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/ChaptersDao.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/ChaptersDao.kt
index e3ff8079d0..e5694c8b64 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/ChaptersDao.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/ChaptersDao.kt
@@ -13,6 +13,9 @@ abstract class ChaptersDao {
@Query("SELECT * FROM chapters WHERE manga_id = :mangaId ORDER BY `index` ASC")
abstract suspend fun findAll(mangaId: Long): List
+ @Query("SELECT * FROM chapters WHERE manga_id = :mangaId AND chapter_id = :chapterId")
+ abstract suspend fun find(mangaId: Long, chapterId: Long): ChapterEntity?
+
@Query("DELETE FROM chapters WHERE manga_id = :mangaId")
abstract suspend fun deleteAll(mangaId: Long)
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/MangaDao.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/MangaDao.kt
index aef1d31f2b..4b0ea84f7c 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/MangaDao.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/MangaDao.kt
@@ -31,6 +31,10 @@ abstract class MangaDao {
@Query("SELECT * FROM manga WHERE source = :source")
abstract suspend fun findAllBySource(source: String): List
+ @Transaction
+ @Query("SELECT * FROM manga WHERE source = :source AND manga_id IN (SELECT manga_id FROM favourites WHERE deleted_at = 0 UNION SELECT manga_id FROM history WHERE deleted_at = 0)")
+ abstract suspend fun findLibraryBySource(source: String): List
+
@Query("SELECT author FROM manga WHERE author LIKE :query GROUP BY author ORDER BY COUNT(author) DESC LIMIT :limit")
abstract suspend fun findAuthors(query: String, limit: Int): List
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/TagsDao.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/TagsDao.kt
index ea2f203f95..f6c6f7d0f0 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/TagsDao.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/TagsDao.kt
@@ -86,6 +86,26 @@ abstract class TagsDao {
)
abstract suspend fun findRelatedTags(ids: Set): List
+ /**
+ * How many stored manga carry each tag, by title across every source: how common a tag is in
+ * everything the app has seen, which is what tells `action` from `villainess`.
+ */
+ @Query(
+ """SELECT LOWER(TRIM(tags.title)) AS title, COUNT(DISTINCT manga_tags.manga_id) AS count FROM tags
+ JOIN manga_tags ON tags.tag_id = manga_tags.tag_id
+ GROUP BY LOWER(TRIM(tags.title))""",
+ )
+ abstract suspend fun countMangaPerTag(): List
+
+ @Query("SELECT COUNT(DISTINCT manga_id) FROM manga_tags")
+ abstract suspend fun countTaggedManga(): Int
+
@Upsert
abstract suspend fun upsert(tags: Iterable)
}
+
+/** One row of [TagsDao.countMangaPerTag]: a lowercased tag title and how many manga carry it. */
+data class TagFrequency(
+ val title: String,
+ val count: Int,
+)
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/TrackLogsDao.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/TrackLogsDao.kt
index 078da3dcea..5ceb2e227a 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/TrackLogsDao.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/dao/TrackLogsDao.kt
@@ -36,6 +36,12 @@ abstract class TrackLogsDao : MangaQueryBuilder.ConditionCallback {
@Query("UPDATE track_logs SET unread = 0 WHERE id = :id")
abstract suspend fun markAsRead(id: Long)
+ @Query("SELECT * FROM track_logs WHERE id = :id")
+ abstract suspend fun find(id: Long): TrackLogEntity?
+
+ @Query("DELETE FROM track_logs WHERE id = :id")
+ abstract suspend fun delete(id: Long)
+
@Insert(onConflict = OnConflictStrategy.REPLACE)
abstract suspend fun insert(entity: TrackLogEntity): Long
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/db/migrations/Migration30To31.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/migrations/Migration30To31.kt
new file mode 100644
index 0000000000..717223cb95
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/db/migrations/Migration30To31.kt
@@ -0,0 +1,21 @@
+package io.github.landwarderer.futon.core.db.migrations
+
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
+
+class Migration30To31 : Migration(30, 31) {
+
+ override fun migrate(db: SupportSQLiteDatabase) {
+ db.execSQL(
+ """CREATE TABLE IF NOT EXISTS `source_presets` (
+ `preset_id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+ `title` TEXT NOT NULL,
+ `languages` TEXT NOT NULL,
+ `sources` TEXT NOT NULL,
+ `created_at` INTEGER NOT NULL,
+ `sort_key` INTEGER NOT NULL,
+ `deleted_at` INTEGER NOT NULL DEFAULT 0
+ )""",
+ )
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/exceptions/resolve/CaptchaAutoResolveCoordinator.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/exceptions/resolve/CaptchaAutoResolveCoordinator.kt
new file mode 100644
index 0000000000..97773ff4d6
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/exceptions/resolve/CaptchaAutoResolveCoordinator.kt
@@ -0,0 +1,298 @@
+package io.github.landwarderer.futon.core.exceptions.resolve
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.widget.Toast
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.ProcessLifecycleOwner
+import dagger.hilt.android.qualifiers.ApplicationContext
+import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.browser.cloudflare.CloudFlareActivity
+import io.github.landwarderer.futon.browser.cloudflare.CloudFlareHiddenActivity
+import io.github.landwarderer.futon.core.exceptions.CloudFlareProtectedException
+import io.github.landwarderer.futon.core.model.UnknownMangaSource
+import io.github.landwarderer.futon.core.nav.AppRouter
+import io.github.landwarderer.futon.core.prefs.SourceSettings
+import io.github.landwarderer.futon.core.ui.DefaultActivityLifecycleCallbacks
+import io.github.landwarderer.futon.core.ui.util.ForegroundActivityHolder
+import io.github.landwarderer.futon.core.util.ext.findCloudFlareException
+import io.github.landwarderer.futon.core.util.ext.printStackTraceDebug
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withTimeoutOrNull
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import java.lang.ref.WeakReference
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicLong
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Owns the single automatic Cloudflare verification session allowed in the app process.
+ *
+ * A session is a [CloudFlareHiddenActivity] started on top of the foreground screen. Sessions are only
+ * started for explicit user actions (opening a catalog, a manga or a chapter); background work may wait
+ * for a running session but never starts one.
+ */
+@Singleton
+class CaptchaAutoResolveCoordinator @Inject constructor(
+ @ApplicationContext private val context: Context,
+ private val foregroundActivityHolder: ForegroundActivityHolder,
+) : DefaultActivityLifecycleCallbacks, DefaultLifecycleObserver {
+
+ private val stateMutex = Mutex()
+ private val scope by lazy { CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) }
+ private val recentSuccessAt = ConcurrentHashMap()
+ private val recentFailureAt = ConcurrentHashMap()
+ private val mainHandler by lazy { Handler(Looper.getMainLooper()) }
+ private val reorderPending = AtomicBoolean(false)
+ private val isProcessObserverRegistered = AtomicBoolean(false)
+ private val sessionIdCounter = AtomicLong(0L)
+
+ @Volatile
+ private var activeSession: ResolveSession? = null
+
+ @Volatile
+ private var hiddenActivityRef: WeakReference? = null
+
+ fun registerHiddenActivity(activity: CloudFlareHiddenActivity, sessionId: Long) {
+ val session = activeSession?.takeIf { it.id == sessionId }
+ if (session == null) {
+ // A solver of a session which has already ended (e.g. restored by the system): it must not linger.
+ activity.finish()
+ return
+ }
+ hiddenActivityRef = WeakReference(activity)
+ reorderPending.set(false)
+ session.launched.complete(Unit)
+ }
+
+ fun unregisterHiddenActivity(activity: CloudFlareHiddenActivity) {
+ if (hiddenActivityRef?.get() === activity) {
+ hiddenActivityRef = null
+ }
+ }
+
+ /** Called by the solver Activity of session [sessionId] when it finishes or is cancelled. */
+ fun notifyResolveResult(sessionId: Long, success: Boolean) {
+ activeSession
+ ?.takeIf { it.id == sessionId }
+ ?.activityResult
+ ?.complete(success)
+ }
+
+ fun isResolveActive(): Boolean = activeSession != null
+
+ /** Waits for whichever session is active. This method never starts verification. */
+ suspend fun awaitActiveResolve(): Boolean? = activeSession?.result?.await()
+
+ /**
+ * Runs an operation in sync with the solver. Background and prefetch callers pass
+ * [mayStartVerification] as false: they may wait for an existing session but never create one.
+ */
+ suspend fun runWithVerification(
+ mayStartVerification: Boolean,
+ block: suspend () -> T,
+ ): T {
+ activeSession?.result?.await()
+ var didVerify = false
+ while (true) {
+ try {
+ return block()
+ } catch (e: Exception) {
+ val cf = e.findCloudFlareException()
+ if (cf !is CloudFlareProtectedException || !mayStartVerification) throw e
+ if (didVerify) {
+ // Verification reported success and this request is *still* Cloudflare-protected.
+ // Another identical session cannot fix that, so stop asking for one.
+ notifyVerificationIneffective(cf.source)
+ throw e
+ }
+ if (!resolveIfEnabled(cf)) throw e
+ didVerify = true
+ }
+ }
+ }
+
+ /**
+ * Reports that verification which finished successfully did not actually unblock [source]
+ * (e.g. Cloudflare does not honour the clearance for OkHttp). Suppresses automatic solving for a
+ * while so the app does not re-solve the same challenge forever.
+ */
+ fun notifyVerificationIneffective(source: MangaSource) {
+ recentSuccessAt.remove(source)
+ recentFailureAt[source] = System.currentTimeMillis()
+ }
+
+ /** Resolves [exception] only when automatic solving is enabled for its source. */
+ suspend fun resolveIfEnabled(exception: CloudFlareProtectedException): Boolean {
+ val source = exception.source
+ if (source == UnknownMangaSource) return false
+ if (SourceSettings(context, source).isCaptchaAutoResolveDisabled) return false
+ val now = System.currentTimeMillis()
+ val lastSuccess = recentSuccessAt[source]
+ if (lastSuccess != null && now - lastSuccess < RECENT_SUCCESS_COOLDOWN_MS) {
+ // Requests that started before the recent session finished: just let them retry.
+ return true
+ }
+ // A source whose challenge just failed must not spawn a solver for every following request.
+ // Report "not resolved" instead so the caller falls back to the ordinary manual "Solve".
+ val lastFailure = recentFailureAt[source]
+ if (lastFailure != null && now - lastFailure < RECENT_FAILURE_COOLDOWN_MS) {
+ return false
+ }
+ return resolve(exception)
+ }
+
+ /** Joins the current session for the same source or atomically creates the only allowed session. */
+ private suspend fun resolve(exception: CloudFlareProtectedException): Boolean {
+ val source = exception.source
+ while (true) {
+ val claim = stateMutex.withLock {
+ activeSession?.let { return@withLock SessionClaim(it, isOwner = false) }
+ if (foregroundActivityHolder.current == null) {
+ // The app is in background: never start a solver from there.
+ return false
+ }
+ val session = ResolveSession(
+ id = sessionIdCounter.incrementAndGet(),
+ source = source,
+ exception = exception,
+ )
+ activeSession = session
+ SessionClaim(session, isOwner = true)
+ }
+ if (claim.isOwner) {
+ showSolvingToast()
+ scope.launch { runSession(claim.session) }
+ }
+ val result = claim.session.result.await()
+ if (claim.session.source == source) {
+ return result
+ }
+ // That session was solving another source, ours is still protected: try to claim the next one.
+ }
+ }
+
+ private suspend fun runSession(session: ResolveSession) {
+ var success = false
+ try {
+ if (launch(session)) {
+ val launched = withTimeoutOrNull(LAUNCH_TIMEOUT_MS) { session.launched.await() }
+ if (launched != null) {
+ success = session.activityResult.await()
+ }
+ }
+ } catch (e: Throwable) {
+ e.printStackTraceDebug("CaptchaAutoResolveCoordinator::runSession")
+ } finally {
+ if (success) {
+ recentSuccessAt[session.source] = System.currentTimeMillis()
+ recentFailureAt.remove(session.source)
+ } else if (!session.isCancelledByBackground) {
+ // Backgrounding is the user's choice, not a verdict on the challenge, so it must not
+ // arm the cooldown.
+ recentFailureAt[session.source] = System.currentTimeMillis()
+ }
+ stateMutex.withLock {
+ if (activeSession === session) activeSession = null
+ }
+ hiddenActivityRef?.get()?.takeIf { it.sessionId == session.id }?.cancelAutomaticResolve()
+ hiddenActivityRef = null
+ reorderPending.set(false)
+ // Clear ownership before releasing waiters, so they can claim the next session.
+ session.result.complete(success)
+ }
+ }
+
+ private fun launch(session: ResolveSession): Boolean {
+ val launcher = foregroundActivityHolder.current ?: return false
+ val intent = AppRouter.cloudFlareResolveIntent(launcher, session.exception, hidden = true).apply {
+ putExtra(CloudFlareActivity.EXTRA_AUTO_RESOLVE, true)
+ putExtra(CloudFlareActivity.EXTRA_SESSION_ID, session.id)
+ }
+ return runCatching {
+ launcher.startActivity(intent)
+ }.onFailure {
+ it.printStackTraceDebug("CaptchaAutoResolveCoordinator::launch")
+ }.isSuccess
+ }
+
+ override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
+ // Registered lazily, so that no session can ever outlive the app going to background.
+ if (isProcessObserverRegistered.compareAndSet(false, true)) {
+ ProcessLifecycleOwner.get().lifecycle.addObserver(this)
+ }
+ }
+
+ /** Keep the existing hidden WebView above newly opened app screens without constructing another one. */
+ override fun onActivityResumed(activity: Activity) {
+ if (activity is CloudFlareActivity) {
+ reorderPending.set(false)
+ return
+ }
+ val solver = hiddenActivityRef?.get()?.takeUnless { it.isFinishing || it.isDestroyed } ?: return
+ if (solver.taskId != activity.taskId) return // reordering cannot reach another task, it would create a copy
+ if (!solver.shouldStayHiddenAndFocused() || !reorderPending.compareAndSet(false, true)) return
+ mainHandler.post {
+ if (!solver.shouldStayHiddenAndFocused() || activity.isFinishing || activity.isDestroyed) {
+ reorderPending.set(false)
+ return@post
+ }
+ activity.startActivity(
+ Intent(activity, CloudFlareHiddenActivity::class.java).addFlags(
+ Intent.FLAG_ACTIVITY_REORDER_TO_FRONT or Intent.FLAG_ACTIVITY_SINGLE_TOP,
+ ),
+ )
+ }
+ }
+
+ /** App backgrounding cancels the session and therefore releases every waiter with failure. */
+ override fun onStop(owner: LifecycleOwner) {
+ val session = activeSession ?: return
+ session.isCancelledByBackground = true
+ session.activityResult.complete(false)
+ }
+
+ private fun showSolvingToast() {
+ mainHandler.post {
+ Toast.makeText(context, R.string.captcha_solving, Toast.LENGTH_LONG).show()
+ }
+ }
+
+ private class ResolveSession(
+ val id: Long,
+ val source: MangaSource,
+ val exception: CloudFlareProtectedException,
+ ) {
+ val launched = CompletableDeferred()
+ val activityResult = CompletableDeferred()
+ val result = CompletableDeferred()
+
+ @Volatile
+ var isCancelledByBackground = false
+ }
+
+ private class SessionClaim(
+ val session: ResolveSession,
+ val isOwner: Boolean,
+ )
+
+ private companion object {
+
+ const val RECENT_SUCCESS_COOLDOWN_MS = 30_000L
+ const val RECENT_FAILURE_COOLDOWN_MS = 3 * 60_000L
+ const val LAUNCH_TIMEOUT_MS = 10_000L
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/exceptions/resolve/CaptchaHandler.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/exceptions/resolve/CaptchaHandler.kt
index 12f8953854..e3abe98b5f 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/exceptions/resolve/CaptchaHandler.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/exceptions/resolve/CaptchaHandler.kt
@@ -36,7 +36,6 @@ import io.github.landwarderer.futon.core.model.UnknownMangaSource
import io.github.landwarderer.futon.core.model.getTitle
import io.github.landwarderer.futon.core.model.isNsfw
import io.github.landwarderer.futon.core.nav.AppRouter
-import io.github.landwarderer.futon.core.network.webview.WebViewExecutor
import io.github.landwarderer.futon.core.parser.favicon.faviconUri
import io.github.landwarderer.futon.core.prefs.SourceSettings
import io.github.landwarderer.futon.core.util.ext.checkNotificationPermission
@@ -54,6 +53,9 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.launch
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
@@ -67,17 +69,30 @@ class CaptchaHandler @Inject constructor(
@LocalizedAppContext private val context: Context,
private val databaseProvider: Provider,
private val coilProvider: Provider,
- private val webViewExecutor: WebViewExecutor,
+ private val captchaAutoResolveCoordinator: CaptchaAutoResolveCoordinator,
) : EventListener() {
private val exceptionMap = MutableScatterMap()
private val mutex = Mutex()
+ private val solvedSourcesFlow = MutableSharedFlow(extraBufferCapacity = SOLVED_BUFFER_CAPACITY)
+ /** Sources whose captcha was just solved, by the user or automatically. */
+ val solvedSources: SharedFlow = solvedSourcesFlow.asSharedFlow()
+
+ /**
+ * Records [exception] and notifies the user about it.
+ *
+ * @param tryAutoResolve whether a silent solver may be started first. Background work must pass `false`:
+ * the solver is an Activity and may only run for an explicit user action.
+ */
@CheckResult
- suspend fun handle(exception: CloudFlareException): Boolean = handleException(exception.source, exception, true)
+ suspend fun handle(exception: CloudFlareException, tryAutoResolve: Boolean): Boolean =
+ handleException(exception.source, exception, notify = true, tryAutoResolve = tryAutoResolve)
+ /** Called once the captcha of [source] has been solved. */
suspend fun discard(source: MangaSource) {
- handleException(source, null, true)
+ handleException(source, null, notify = true, tryAutoResolve = false)
+ solvedSourcesFlow.emit(source)
}
override fun onError(request: ImageRequest, result: ErrorResult) {
@@ -86,15 +101,14 @@ class CaptchaHandler @Inject constructor(
if (e is CloudFlareException) {
val scope = request.lifecycle?.coroutineScope ?: processLifecycleScope
scope.launch {
- if (
- handleException(
- source = e.source,
- exception = e,
- notify = request.extras[suppressCaptchaKey] != true,
- )
- ) {
- coilProvider.get().enqueue(request) // TODO check if ok
- }
+ // Never auto-resolve from coil's error path: every failed favicon / cover load would queue up
+ // a solver. Auto-resolve only happens for explicit interactions (catalog, details, reader).
+ handleException(
+ source = e.source,
+ exception = e,
+ notify = request.extras[suppressCaptchaKey] != true,
+ tryAutoResolve = false,
+ )
}
}
}
@@ -103,11 +117,16 @@ class CaptchaHandler @Inject constructor(
source: MangaSource,
exception: CloudFlareException?,
notify: Boolean,
+ tryAutoResolve: Boolean,
): Boolean = withContext(Dispatchers.IO) {
if (source == UnknownMangaSource) {
return@withContext false
}
- if (exception != null && webViewExecutor.tryResolveCaptcha(exception, RESOLVE_TIMEOUT)) {
+ if (
+ tryAutoResolve &&
+ exception is CloudFlareProtectedException &&
+ captchaAutoResolveCoordinator.resolveIfEnabled(exception)
+ ) {
return@withContext true
}
mutex.withLock {
@@ -268,7 +287,12 @@ class CaptchaHandler @Inject constructor(
override fun onReceive(context: Context?, intent: Intent?) {
val sourceName = intent?.getStringExtra(AppRouter.KEY_SOURCE) ?: return
goAsync {
- captchaHandler.handleException(MangaSource(sourceName), exception = null, notify = false)
+ captchaHandler.handleException(
+ source = MangaSource(sourceName),
+ exception = null,
+ notify = false,
+ tryAutoResolve = false,
+ )
}
}
}
@@ -287,6 +311,6 @@ class CaptchaHandler @Inject constructor(
private const val GROUP_NOTIFICATION_ID = 34
private const val SETTINGS_ACTION_CODE = 3
private const val ACTION_DISCARD = "io.github.landwarderer.futon.CAPTCHA_DISCARD"
- private const val RESOLVE_TIMEOUT = 20_000L
+ private const val SOLVED_BUFFER_CAPACITY = 8
}
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/exceptions/resolve/ExceptionResolver.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/exceptions/resolve/ExceptionResolver.kt
index 017b8e6a7c..1a54a0af2d 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/exceptions/resolve/ExceptionResolver.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/exceptions/resolve/ExceptionResolver.kt
@@ -45,6 +45,7 @@ import kotlin.coroutines.suspendCoroutine
class ExceptionResolver private constructor(
private val host: Host,
private val settings: AppSettings,
+ private val captchaCoordinator: CaptchaAutoResolveCoordinator,
private val scrobblerAuthHelperProvider: Provider,
) {
private val continuations = MutableScatterMap>(1)
@@ -63,9 +64,14 @@ class ExceptionResolver private constructor(
host.router.showErrorDialog(e, url)
}
- suspend fun resolve(e: Throwable): Boolean = host.lifecycleScope.async {
+ /**
+ * @param tryAutoResolve whether a CloudFlare captcha may be solved silently first (see
+ * [CaptchaAutoResolveCoordinator]). Only pass `true` for an explicit user action such as opening a catalog
+ * or a manga; a "Solve" button press wants the visible solver.
+ */
+ suspend fun resolve(e: Throwable, tryAutoResolve: Boolean = false): Boolean = host.lifecycleScope.async {
when (e) {
- is CloudFlareProtectedException -> resolveCF(e)
+ is CloudFlareProtectedException -> resolveCF(e, tryAutoResolve)
is AuthRequiredException -> resolveAuthException(e.source)
is SSLException,
is CertPathValidatorException -> {
@@ -123,9 +129,20 @@ class ExceptionResolver private constructor(
browserActionContract.launch(e)
}
- private suspend fun resolveCF(e: CloudFlareProtectedException): Boolean = suspendCoroutine { cont ->
- continuations[CloudFlareActivity.TAG] = cont
- cloudflareContract.launch(e)
+ private suspend fun resolveCF(e: CloudFlareProtectedException, tryAutoResolve: Boolean): Boolean {
+ if (captchaCoordinator.isResolveActive()) {
+ // Never stack a visible solver on top of the silent one: wait for it instead.
+ return captchaCoordinator.awaitActiveResolve() == true
+ }
+ if (tryAutoResolve) {
+ // Delegated to the singleton coordinator: it owns the solver lifecycle, so the result is delivered
+ // even if this screen dies while the solver is still running.
+ return captchaCoordinator.resolveIfEnabled(e)
+ }
+ return suspendCoroutine { cont ->
+ continuations[CloudFlareActivity.TAG] = cont
+ cloudflareContract.launch(e)
+ }
}
private suspend fun resolveAuthException(source: MangaSource): Boolean = suspendCoroutine { cont ->
@@ -165,18 +182,21 @@ class ExceptionResolver private constructor(
class Factory @Inject constructor(
private val settings: AppSettings,
+ private val captchaCoordinator: CaptchaAutoResolveCoordinator,
private val scrobblerAuthHelperProvider: Provider,
) {
fun create(fragment: Fragment) = ExceptionResolver(
host = Host.FragmentHost(fragment),
settings = settings,
+ captchaCoordinator = captchaCoordinator,
scrobblerAuthHelperProvider = scrobblerAuthHelperProvider,
)
fun create(activity: FragmentActivity) = ExceptionResolver(
host = Host.ActivityHost(activity),
settings = settings,
+ captchaCoordinator = captchaCoordinator,
scrobblerAuthHelperProvider = scrobblerAuthHelperProvider,
)
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/image/BitmapDecoderCompat.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/image/BitmapDecoderCompat.kt
index 54dbc9050f..962e6c7bac 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/image/BitmapDecoderCompat.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/image/BitmapDecoderCompat.kt
@@ -7,6 +7,9 @@ import android.graphics.ImageDecoder
import android.os.Build
import androidx.annotation.RequiresApi
import androidx.core.graphics.createBitmap
+import com.awxkee.jxlcoder.JxlCoder
+import com.awxkee.jxlcoder.PreferredColorConfig
+import com.awxkee.jxlcoder.ScaleMode
import com.davemorrissey.labs.subscaleview.decoder.ImageDecodeException
import io.github.landwarderer.futon.core.util.MimeTypes
import io.github.landwarderer.futon.core.util.ext.MimeType
@@ -15,6 +18,9 @@ import io.github.landwarderer.futon.core.util.ext.readByteBuffer
import io.github.landwarderer.futon.core.util.ext.toByteBuffer
import io.github.landwarderer.futon.core.util.ext.toMimeTypeOrNull
import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
+import okio.BufferedSource
+import okio.ByteString
+import okio.ByteString.Companion.toByteString
import okio.IOException
import okio.buffer
import okio.source
@@ -28,14 +34,31 @@ import java.nio.ByteBuffer
object BitmapDecoderCompat {
private const val FORMAT_AVIF = "avif"
+ private const val FORMAT_JXL = "jxl"
+
+ /** A bare JPEG XL codestream. */
+ private val JXL_CODESTREAM = byteArrayOf(0xFF.toByte(), 0x0A).toByteString()
+
+ /** The signature box that opens a JPEG XL in its ISOBMFF container. */
+ private val JXL_CONTAINER = byteArrayOf(
+ 0x00, 0x00, 0x00, 0x0C, 0x4A, 0x58, 0x4C, 0x20, 0x0D, 0x0A, 0x87.toByte(), 0x0A,
+ ).toByteString()
+
+ private const val JXL_HEADER_SIZE = 12
@Blocking
- fun decode(file: File): Bitmap = when (val format = probeMimeType(file)?.subtype) {
- FORMAT_AVIF -> file.source().buffer().use { decodeAvif(it.readByteBuffer()) }
- else -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
- ImageDecoder.decodeBitmap(ImageDecoder.createSource(file))
- } else {
- checkBitmapNotNull(BitmapFactory.decodeFile(file.absolutePath), format)
+ fun decode(file: File): Bitmap {
+ // By content, not name: sites serve JPEG XL under .jpg URLs to browsers that accept it
+ if (isJxl(file)) {
+ return decodeJxl(file.readBytes())
+ }
+ return when (val format = probeMimeType(file)?.subtype) {
+ FORMAT_AVIF -> file.source().buffer().use { decodeAvif(it.readByteBuffer()) }
+ else -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+ ImageDecoder.decodeBitmap(ImageDecoder.createSource(file))
+ } else {
+ checkBitmapNotNull(BitmapFactory.decodeFile(file.absolutePath), format)
+ }
}
}
@@ -45,19 +68,55 @@ object BitmapDecoderCompat {
if (format == FORMAT_AVIF) {
return decodeAvif(stream.toByteBuffer())
}
+ if (format == FORMAT_JXL) {
+ return decodeJxl(stream.readBytes(), isMutable)
+ }
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) {
+ val input = if (stream.markSupported()) stream else stream.buffered()
+ input.mark(JXL_HEADER_SIZE)
+ val header = ByteArray(JXL_HEADER_SIZE)
+ val headerSize = input.readNBytesCompat(header)
+ input.reset()
+ if (isJxl(header.toByteString(0, headerSize))) {
+ return decodeJxl(input.readBytes(), isMutable)
+ }
val opts = BitmapFactory.Options()
opts.inMutable = isMutable
- return checkBitmapNotNull(BitmapFactory.decodeStream(stream, null, opts), format)
+ return checkBitmapNotNull(BitmapFactory.decodeStream(input, null, opts), format)
}
val byteBuffer = stream.toByteBuffer()
- return if (AvifDecoder.isAvifImage(byteBuffer)) {
- decodeAvif(byteBuffer)
- } else {
- ImageDecoder.decodeBitmap(ImageDecoder.createSource(byteBuffer), DecoderConfigListener(isMutable))
+ return when {
+ AvifDecoder.isAvifImage(byteBuffer) -> decodeAvif(byteBuffer)
+ isJxl(byteBuffer) -> decodeJxl(ByteArray(byteBuffer.remaining()).also { byteBuffer.duplicate().get(it) }, isMutable)
+ else -> ImageDecoder.decodeBitmap(ImageDecoder.createSource(byteBuffer), DecoderConfigListener(isMutable))
}
}
+ /** Checks the signature without consuming it, which is what Coil's decoder factories need. */
+ fun isJxl(source: BufferedSource): Boolean =
+ source.rangeEquals(0, JXL_CONTAINER) || source.rangeEquals(0, JXL_CODESTREAM)
+
+ @Blocking
+ fun isJxl(file: File): Boolean = runCatchingCancellable {
+ file.source().buffer().use { isJxl(it) }
+ }.getOrDefault(false)
+
+ /**
+ * Free memory to ask for before decoding [file].
+ *
+ * Twice the file size is the rule for the formats this was written for. A JPEG XL is often a tenth
+ * of the PNG it decodes to, so for one that guess is read from the header instead.
+ */
+ @Blocking
+ fun estimateDecodedSize(file: File): Long {
+ val guess = file.length() * 2
+ if (!isJxl(file) || !JxlSupport.isAvailable) {
+ return guess
+ }
+ val size = runCatchingCancellable { JxlCoder.getSize(file.readBytes()) }.getOrNull() ?: return guess
+ return maxOf(guess, size.width.toLong() * size.height * 4)
+ }
+
@Blocking
fun createRegionDecoder(inoutStream: InputStream): BitmapRegionDecoder? = try {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
@@ -67,12 +126,15 @@ object BitmapDecoderCompat {
BitmapRegionDecoder.newInstance(inoutStream, false)
}
} catch (e: IOException) {
- e.printStackTraceDebug("DecoderConfigListener::createRegionDecoder")
+ e.printStackTraceDebug()
null
}
@Blocking
fun probeMimeType(file: File): MimeType? {
+ if (isJxl(file)) {
+ return MimeTypes.JXL
+ }
return MimeTypes.probeMimeType(file) ?: detectBitmapType(file)
}
@@ -106,6 +168,40 @@ object BitmapDecoderCompat {
return bitmap
}
+ private fun decodeJxl(bytes: ByteArray, isMutable: Boolean = false): Bitmap {
+ if (!JxlSupport.isAvailable) {
+ throw ImageDecodeException(null, FORMAT_JXL, "JPEG XL is not supported on this device")
+ }
+ // 8-bit RGBA whatever the source depth: a HARDWARE or F16 bitmap cannot be re-encoded to PNG
+ // by the reader's conversion fallback the same way
+ val bitmap = JxlCoder.decode(bytes, PreferredColorConfig.RGBA_8888, ScaleMode.FIT)
+ if (!isMutable || bitmap.isMutable) {
+ return bitmap
+ }
+ return bitmap.copy(Bitmap.Config.ARGB_8888, true).also { bitmap.recycle() }
+ }
+
+ private fun isJxl(header: ByteString): Boolean =
+ header.startsWith(JXL_CONTAINER) || header.startsWith(JXL_CODESTREAM)
+
+ private fun isJxl(buffer: ByteBuffer): Boolean {
+ val size = minOf(buffer.remaining(), JXL_HEADER_SIZE)
+ val header = ByteArray(size).also { buffer.duplicate().get(it) }
+ return isJxl(header.toByteString())
+ }
+
+ private fun InputStream.readNBytesCompat(buffer: ByteArray): Int {
+ var total = 0
+ while (total < buffer.size) {
+ val read = read(buffer, total, buffer.size - total)
+ if (read < 0) {
+ break
+ }
+ total += read
+ }
+ return total
+ }
+
@RequiresApi(Build.VERSION_CODES.P)
private class DecoderConfigListener(
private val isMutable: Boolean,
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/image/JxlImageDecoder.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/image/JxlImageDecoder.kt
new file mode 100644
index 0000000000..ab42b89608
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/image/JxlImageDecoder.kt
@@ -0,0 +1,95 @@
+package io.github.landwarderer.futon.core.image
+
+import coil3.ImageLoader
+import coil3.asImage
+import coil3.decode.DecodeResult
+import coil3.decode.DecodeUtils
+import coil3.decode.Decoder
+import coil3.decode.ImageSource
+import coil3.fetch.SourceFetchResult
+import coil3.request.Options
+import coil3.request.maxBitmapSize
+import coil3.util.component1
+import coil3.util.component2
+import com.awxkee.jxlcoder.JxlCoder
+import com.awxkee.jxlcoder.JxlResizeFilter
+import com.awxkee.jxlcoder.PreferredColorConfig
+import com.awxkee.jxlcoder.ScaleMode
+import com.davemorrissey.labs.subscaleview.decoder.ImageDecodeException
+import kotlinx.coroutines.runInterruptible
+import io.github.landwarderer.futon.core.util.MimeTypes
+
+/**
+ * JPEG XL for Coil, which Android cannot decode itself.
+ *
+ * Covers, thumbnails and page previews only ever need a small bitmap, so the image is decoded straight
+ * to the requested size rather than in full and scaled down - a webtoon strip can be tens of
+ * thousands of pixels tall.
+ */
+class JxlImageDecoder(
+ private val source: ImageSource,
+ private val options: Options,
+) : Decoder {
+
+ override suspend fun decode(): DecodeResult = runInterruptible {
+ val bytes = source.source().readByteArray()
+ val size = JxlCoder.getSize(bytes) ?: throw ImageDecodeException(
+ uri = source.fileOrNull()?.toString(),
+ format = FORMAT,
+ message = "Cannot read the size of a JPEG XL image",
+ )
+ val (dstWidth, dstHeight) = DecodeUtils.computeDstSize(
+ srcWidth = size.width,
+ srcHeight = size.height,
+ targetSize = options.size,
+ scale = options.scale,
+ maxSize = options.maxBitmapSize,
+ )
+ if (dstWidth < size.width || dstHeight < size.height) {
+ DecodeResult(
+ image = JxlCoder.decodeSampled(
+ bytes,
+ dstWidth,
+ dstHeight,
+ PreferredColorConfig.RGBA_8888,
+ ScaleMode.FIT,
+ JxlResizeFilter.BILINEAR,
+ ).asImage(),
+ isSampled = true,
+ )
+ } else {
+ DecodeResult(
+ image = JxlCoder.decode(bytes, PreferredColorConfig.RGBA_8888, ScaleMode.FIT).asImage(),
+ isSampled = false,
+ )
+ }
+ }
+
+ class Factory : Decoder.Factory {
+
+ override fun create(
+ result: SourceFetchResult,
+ options: Options,
+ imageLoader: ImageLoader
+ ): Decoder? = if (isApplicable(result) && JxlSupport.isAvailable) {
+ JxlImageDecoder(result.source, options)
+ } else {
+ null
+ }
+
+ override fun equals(other: Any?) = other is Factory
+
+ override fun hashCode() = javaClass.hashCode()
+
+ // By content as well as by type: page caches have no extension, and sites serve JPEG XL
+ // under the URL of the JPEG it replaced
+ private fun isApplicable(result: SourceFetchResult): Boolean {
+ return result.mimeType == MimeTypes.JXL.toString() || BitmapDecoderCompat.isJxl(result.source.source())
+ }
+ }
+
+ private companion object {
+
+ const val FORMAT = "jxl"
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/image/JxlSupport.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/image/JxlSupport.kt
new file mode 100644
index 0000000000..8eab314886
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/image/JxlSupport.kt
@@ -0,0 +1,26 @@
+package io.github.landwarderer.futon.core.image
+
+import io.github.landwarderer.futon.core.util.ext.printStackTraceDebug
+
+/**
+ * Whether JPEG XL can be decoded on this device.
+ *
+ * jxl-coder ships libraries for armeabi-v7a, arm64-v8a, x86 and x86_64. Should loading still fail - an
+ * unexpected ABI, a translation layer missing something, a stripped install - this keeps it to one image
+ * failing. It has to be asked before the first `JxlCoder` call: its class initializer loads the library,
+ * and a failure there is an Error that would take the image pipeline down rather than fail one image.
+ *
+ * Only asked once an image has been recognised as JPEG XL, so nobody else pays for loading it.
+ */
+object JxlSupport {
+
+ val isAvailable: Boolean by lazy {
+ try {
+ System.loadLibrary("jxlcoder")
+ true
+ } catch (e: LinkageError) {
+ e.printStackTraceDebug()
+ false
+ }
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/model/Manga.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/model/Manga.kt
index ac25c98273..1b32402b93 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/model/Manga.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/model/Manga.kt
@@ -125,6 +125,23 @@ fun Manga.getPreferredBranch(history: MangaHistory?): String? {
return groups.maxByOrNull { it.value.size }?.key
}
+/**
+ * Finds [previous], a chapter of an earlier load of this list, again after the source gave it a new id.
+ *
+ * Some sources derive chapter ids from data that changes between two loads of the same chapter: a mirror host
+ * in the chapter link, a scanlation group name, a re-upload. The same chapter is the one with the same link in
+ * the same branch, else the only one with the same volume and number in that branch, else the only one with the
+ * same link. Returns null rather than a guess when that is ambiguous.
+ */
+fun List.findSameChapter(previous: MangaChapter): MangaChapter? {
+ firstOrNull { it.url == previous.url && it.branch == previous.branch }?.let { return it }
+ singleOrNull {
+ it.branch == previous.branch && it.volume == previous.volume && it.number == previous.number &&
+ (previous.number > 0f || it.title == previous.title) // 0 often means "no number"
+ }?.let { return it }
+ return singleOrNull { it.url == previous.url }
+}
+
val Manga.isLocal: Boolean
get() = source == LocalMangaSource || source == LocalNovelSource
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/model/MangaSourceTraits.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/model/MangaSourceTraits.kt
new file mode 100644
index 0000000000..0cac6deb36
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/model/MangaSourceTraits.kt
@@ -0,0 +1,59 @@
+package io.github.landwarderer.futon.core.model
+
+import android.content.Context
+import io.github.landwarderer.futon.core.util.ext.getDisplayName
+import io.github.landwarderer.futon.core.util.ext.toLocaleOrNull
+import io.github.landwarderer.futon.mihon.extensions.runtime.getExternalExtensionLanguageDisplayName
+import io.github.landwarderer.futon.mihon.model.MihonMangaSource
+import org.koitharu.kotatsu.parsers.model.ContentType
+import org.koitharu.kotatsu.parsers.model.MangaParserSource
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import java.util.Locale
+import io.github.landwarderer.futon.mihon.parsers.model.ContentType as MihonContentType
+
+private val MULTI_LANGUAGE_CODES = setOf("all", "other", "multi")
+
+/**
+ * The language code as the source declares it (`en`, `pt`, `pt-BR`...), for both built-in parsers and
+ * Mihon extensions, or null when the source is multilingual or does not say.
+ */
+val MangaSource.languageCode: String?
+ get() = when (val source = unwrap()) {
+ is MangaParserSource -> source.locale
+ is MihonMangaSource -> source.language
+ else -> null
+ }?.trim()?.takeUnless { it.isEmpty() || it.lowercase(Locale.ROOT) in MULTI_LANGUAGE_CODES }
+
+/** The bare language of [languageCode], lowercased (`pt-BR` -> `pt`), for comparing sources. */
+val MangaSource.primaryLanguage: String?
+ get() = languageCode?.let(::primaryLanguageOf)
+
+fun primaryLanguageOf(code: String): String = code.substringBefore('-').substringBefore('_').lowercase(Locale.ROOT)
+
+/** The content type of a built-in parser or of a Mihon extension, mapped onto the parsers library type. */
+val MangaSource.contentTypeCompat: ContentType?
+ get() = when (val source = unwrap()) {
+ is MangaParserSource -> source.contentType
+ is MihonMangaSource -> source.contentType.toContentType()
+ else -> null
+ }
+
+fun MihonContentType.toContentType(): ContentType = when (this) {
+ MihonContentType.MANGA -> ContentType.MANGA
+ MihonContentType.MANHWA -> ContentType.MANHWA
+ MihonContentType.MANHUA -> ContentType.MANHUA
+ MihonContentType.HENTAI_MANGA, MihonContentType.HENTAI_NOVEL, MihonContentType.HENTAI_VIDEO -> ContentType.HENTAI
+ MihonContentType.COMICS -> ContentType.COMICS
+ MihonContentType.VIDEO -> ContentType.OTHER
+ MihonContentType.NOVEL -> ContentType.NOVEL
+ MihonContentType.ONE_SHOT -> ContentType.ONE_SHOT
+ MihonContentType.DOUJINSHI -> ContentType.DOUJINSHI
+ MihonContentType.IMAGE_SET -> ContentType.IMAGE_SET
+ MihonContentType.ARTIST_CG -> ContentType.ARTIST_CG
+ MihonContentType.GAME_CG -> ContentType.GAME_CG
+ MihonContentType.OTHER -> ContentType.OTHER
+}
+
+/** A display name for a source language code, covering the codes only Mihon extensions use. */
+fun getSourceLanguageDisplayName(context: Context, code: String): String =
+ code.toLocaleOrNull()?.getDisplayName(context) ?: getExternalExtensionLanguageDisplayName(code)
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/nav/AppRouter.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/nav/AppRouter.kt
index 0940c8520c..37e3d13702 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/nav/AppRouter.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/nav/AppRouter.kt
@@ -25,11 +25,13 @@ import dagger.hilt.android.EntryPointAccessors
import io.github.landwarderer.futon.BuildConfig
import io.github.landwarderer.futon.R
import io.github.landwarderer.futon.alternatives.ui.AlternativesActivity
+import io.github.landwarderer.futon.alternatives.ui.SourceReplacementActivity
import io.github.landwarderer.futon.backups.ui.backup.BackupDialogFragment
import io.github.landwarderer.futon.backups.ui.restore.RestoreDialogFragment
import io.github.landwarderer.futon.bookmarks.ui.AllBookmarksActivity
import io.github.landwarderer.futon.browser.BrowserActivity
import io.github.landwarderer.futon.browser.cloudflare.CloudFlareActivity
+import io.github.landwarderer.futon.browser.cloudflare.CloudFlareHiddenActivity
import io.github.landwarderer.futon.core.exceptions.CloudFlareProtectedException
import io.github.landwarderer.futon.core.image.CoilMemoryCacheKey
import io.github.landwarderer.futon.core.model.FavouriteCategory
@@ -178,7 +180,20 @@ class AppRouter private constructor(
fun openAlternatives(manga: Manga) {
startActivity(
Intent(contextOrNull() ?: return, AlternativesActivity::class.java)
- .putExtra(KEY_MANGA, ParcelableManga(manga)),
+ .putExtra(KEY_MANGA, ParcelableManga(manga, withDescription = false)),
+ )
+ }
+
+ fun openSourceReplacement(manga: Collection) {
+ if (manga.isEmpty()) {
+ return
+ }
+ startActivity(
+ Intent(contextOrNull() ?: return, SourceReplacementActivity::class.java)
+ .putParcelableArrayListExtra(
+ KEY_MANGA_LIST,
+ manga.mapTo(ArrayList(manga.size)) { ParcelableManga(it, withDescription = false) },
+ ),
)
}
@@ -727,14 +742,20 @@ class AppRouter private constructor(
}
}
- fun cloudFlareResolveIntent(context: Context, exception: CloudFlareProtectedException): Intent =
- Intent(context, CloudFlareActivity::class.java).apply {
+ fun cloudFlareResolveIntent(
+ context: Context,
+ exception: CloudFlareProtectedException,
+ hidden: Boolean = false,
+ ): Intent {
+ val activityClass = if (hidden) CloudFlareHiddenActivity::class.java else CloudFlareActivity::class.java
+ return Intent(context, activityClass).apply {
data = exception.url.toUri()
putExtra(KEY_SOURCE, exception.source.name)
exception.headers[CommonHeaders.USER_AGENT]?.let {
putExtra(KEY_USER_AGENT, it)
}
}
+ }
fun browserIntent(
context: Context,
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/network/CommonHeadersInterceptor.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/network/CommonHeadersInterceptor.kt
index 76cda52eae..db59aa6eab 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/network/CommonHeadersInterceptor.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/network/CommonHeadersInterceptor.kt
@@ -40,6 +40,11 @@ class CommonHeadersInterceptor @Inject constructor(
repository?.getRequestHeaders()?.let {
headersBuilder.mergeWith(it, replaceExisting = false)
}
+ // Deliberately overrides the parser's agent: a cf_clearance cookie is only honoured for the
+ // exact User-Agent it was issued to. See SourceSettings.cloudFlareUserAgent.
+ repository?.getConfig()?.cloudFlareUserAgent?.let {
+ headersBuilder.trySet(CommonHeaders.USER_AGENT, it)
+ }
if (headersBuilder[CommonHeaders.USER_AGENT] == null) {
headersBuilder[CommonHeaders.USER_AGENT] = mangaLoaderContextLazy.get().getDefaultUserAgent()
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/CaptchaContinuationClient.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/CaptchaContinuationClient.kt
deleted file mode 100644
index e2ae4a1c76..0000000000
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/CaptchaContinuationClient.kt
+++ /dev/null
@@ -1,82 +0,0 @@
-package io.github.landwarderer.futon.core.network.webview
-
-import android.graphics.Bitmap
-import android.webkit.WebResourceRequest
-import android.webkit.WebResourceResponse
-import android.webkit.WebView
-import io.github.landwarderer.futon.core.network.cookies.MutableCookieJar
-import org.koitharu.kotatsu.parsers.network.CloudFlareHelper
-import kotlin.coroutines.Continuation
-import okhttp3.OkHttpClient
-import okhttp3.Request
-import java.util.concurrent.TimeUnit
-import kotlin.toString
-
-class CaptchaContinuationClient(
- private val cookieJar: MutableCookieJar,
- private val targetUrl: String,
- continuation: Continuation,
-) : ContinuationResumeWebViewClient(continuation) {
-
- private val oldClearance = CloudFlareHelper.getClearanceCookie(cookieJar, targetUrl)
-
- override fun onPageFinished(view: WebView?, url: String?) = Unit
-
- override fun onPageStarted(view: WebView?, url: String?, favicon: Bitmap?) {
- super.onPageStarted(view, url, favicon)
- checkClearance(view)
- }
-
- override fun shouldInterceptRequest(view: WebView?, request: WebResourceRequest?): WebResourceResponse? {
- if (request == null) return null
-
- try {
- // Skip POST requests
- if (request.method == "POST") {
- return super.shouldInterceptRequest(view, request)
- }
-
- val client = OkHttpClient.Builder()
- .connectTimeout(15, TimeUnit.SECONDS)
- .readTimeout(15, TimeUnit.SECONDS)
- .build()
-
- val requestBuilder = Request.Builder()
- .url(request.url.toString())
- .method(request.method, null)
-
- val blockedHeaders = setOf(
- "sec-ch-ua",
- "sec-ch-ua-mobile",
- "sec-ch-ua-platform",
- "x-requested-with",
- )
- // Add all headers except blocked
- request.requestHeaders.forEach { (key, value) ->
- if (key.lowercase() !in blockedHeaders) {
- requestBuilder.addHeader(key, value)
- }
- }
-
- val response = client.newCall(requestBuilder.build()).execute()
-
- val contentType = response.header("Content-Type", "text/html")
- val mimeType = contentType?.split(";")?.get(0)?.trim() ?: "text/html"
- val charset = contentType?.substringAfter("charset=", "UTF-8")?.trim() ?: "UTF-8"
-
- return WebResourceResponse(mimeType, charset, response.body?.byteStream()).apply {
- val headers = mutableMapOf()
- response.headers.forEach { headers[it.first] = it.second }
- setResponseHeaders(headers)
- }
- } catch (e: Exception) {
- return null
- }
- }
- private fun checkClearance(view: WebView?) {
- val clearance = CloudFlareHelper.getClearanceCookie(cookieJar, targetUrl)
- if (clearance != null && clearance != oldClearance) {
- resumeContinuation(view)
- }
- }
-}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/CloudFlareDetection.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/CloudFlareDetection.kt
new file mode 100644
index 0000000000..350f093bb6
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/CloudFlareDetection.kt
@@ -0,0 +1,45 @@
+package io.github.landwarderer.futon.core.network.webview
+
+/**
+ * Returns one of:
+ * - "ok" — the real page is shown (no Cloudflare interstitial markers, body has content, which
+ * may be nothing but text: an ajax endpoint answering "0" is a loaded page)
+ * - "error" — hard-blocked ("Attention Required" / "Access Denied" title)
+ * - "wait" — page is empty / still loading / still showing a CF challenge
+ *
+ * Used to detect that a CloudFlare challenge has finished even when the `cf_clearance` cookie doesn't
+ * actually change (e.g. when the WebView's fingerprint passes the challenge silently while OkHttp's
+ * doesn't, so we never get an `onPageStarted` / clearance-cookie diff to signal success).
+ */
+internal const val CF_STATE_JS = """
+ (function(){
+ try {
+ var href = (document.location && document.location.href) || '';
+ if (href === '' || href === 'about:blank') return 'wait';
+ if (document.readyState !== 'interactive' && document.readyState !== 'complete') return 'wait';
+ var t = (document.title || '').toLowerCase();
+ if (t.indexOf('attention required') !== -1 || t.indexOf('access denied') !== -1) return 'error';
+ if (t.indexOf('just a moment') !== -1 || t.indexOf('un instant') !== -1 ||
+ t.indexOf('einen moment') !== -1 || t.indexOf('un momento') !== -1 ||
+ t.indexOf('один момент') !== -1) return 'wait';
+ var challengeNodes = document.querySelectorAll(
+ '#challenge-running, #challenge-stage, #cf-challenge-running, ' +
+ '.cf-browser-verification, #turnstile-wrapper, #cf-please-wait'
+ );
+ for (var i = 0; i < challengeNodes.length; i++) {
+ var node = challengeNodes[i];
+ var style = window.getComputedStyle(node);
+ if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') continue;
+ var rect = node.getBoundingClientRect();
+ if (rect.width > 0 && rect.height > 0) return 'wait';
+ }
+ var body = document.body;
+ if (!body) return 'wait';
+ // An endpoint may legitimately answer with a bare text node - WordPress admin-ajax.php
+ // replies with "0" - and children counts elements only, so an empty element list is not
+ // proof the page is still loading. Only treat it as unfinished when there is no text either.
+ if (body.children.length === 0 && (body.textContent || '').trim().length === 0) return 'wait';
+ return 'ok';
+ } catch (e) { return 'wait'; }
+ })()
+"""
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/ContinuationResumeWebViewClient.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/ContinuationResumeWebViewClient.kt
deleted file mode 100644
index b2eabc06ec..0000000000
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/ContinuationResumeWebViewClient.kt
+++ /dev/null
@@ -1,23 +0,0 @@
-package io.github.landwarderer.futon.core.network.webview
-
-import android.webkit.WebView
-import android.webkit.WebViewClient
-import kotlinx.coroutines.CancellableContinuation
-import kotlin.coroutines.Continuation
-import kotlin.coroutines.resume
-
-open class ContinuationResumeWebViewClient(
- private val continuation: Continuation,
-) : WebViewClient() {
-
- override fun onPageFinished(view: WebView?, url: String?) {
- resumeContinuation(view)
- }
-
- protected fun resumeContinuation(view: WebView?) {
- if (continuation !is CancellableContinuation || continuation.isActive) {
- view?.webViewClient = WebViewClient() // reset to default
- continuation.resume(Unit)
- }
- }
-}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/RequestInterceptorWebViewClient.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/RequestInterceptorWebViewClient.kt
index 7aa9308a82..06d0be6e7a 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/RequestInterceptorWebViewClient.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/RequestInterceptorWebViewClient.kt
@@ -1,5 +1,8 @@
package io.github.landwarderer.futon.core.network.webview
+import android.graphics.Bitmap
+import android.os.Handler
+import android.os.Looper
import android.util.Log
import android.webkit.WebResourceRequest
import android.webkit.WebResourceResponse
@@ -11,6 +14,7 @@ import kotlinx.coroutines.sync.withLock
import io.github.landwarderer.futon.browser.BrowserCallback
import io.github.landwarderer.futon.browser.BrowserClient
import io.github.landwarderer.futon.core.network.webview.adblock.AdBlock
+import java.lang.ref.WeakReference
import java.util.Collections
import java.util.concurrent.atomic.AtomicBoolean
@@ -29,7 +33,8 @@ class RequestInterceptorWebViewClient(
private val mutex = Mutex()
private val isCapturing = AtomicBoolean(true)
private val startTime = System.currentTimeMillis()
- private val scriptInjected = AtomicBoolean(false)
+ private val mainHandler = Handler(Looper.getMainLooper())
+ private val pollScheduled = AtomicBoolean(false)
@WorkerThread
override fun shouldInterceptRequest(
@@ -57,15 +62,56 @@ class RequestInterceptorWebViewClient(
return super.shouldOverrideUrlLoading(view, request)
}
+ override fun onPageStarted(view: WebView?, url: String?, favicon: Bitmap?) {
+ super.onPageStarted(view, url, favicon)
+ if (view != null) {
+ injectPageScript(view)
+ }
+ }
+
override fun onPageFinished(view: WebView, url: String) {
super.onPageFinished(view, url)
+ injectPageScript(view)
+ schedulePolling(view)
+ }
+
+ /**
+ * The script has to be injected again on every navigation, not just the first one:
+ * an interstitial (a Cloudflare challenge, a redirect) is its own document, and the page
+ * that replaces it gets a fresh JS context. Scripts are expected to be idempotent.
+ */
+ private fun injectPageScript(view: WebView) {
val script = config.pageScript
- if (!script.isNullOrBlank() && scriptInjected.compareAndSet(false, true)) {
- Log.d(TAG_VRF, "Injecting pageScript for URL: $url")
- view.evaluateJavascript(script, null)
- } else if (!script.isNullOrBlank()) {
- Log.v(TAG_VRF, "PageScript already injected, skipping for URL: $url")
+ if (script.isNullOrBlank() || !isCapturing.get() || isTimeoutReached()) {
+ return
+ }
+ view.evaluateJavascript(script, null)
+ }
+
+ /**
+ * Keeps re-running the script while a page is up, so a payload that only becomes
+ * available after some in-page work, or after a challenge clears without a navigation,
+ * is still picked up.
+ */
+ private fun schedulePolling(view: WebView) {
+ if (config.pageScript.isNullOrBlank() || !pollScheduled.compareAndSet(false, true)) {
+ return
}
+ val viewRef = WeakReference(view)
+ mainHandler.postDelayed(
+ object : Runnable {
+ override fun run() {
+ val webView = viewRef.get()
+ if (webView == null || !isCapturing.get() || isTimeoutReached()) {
+ pollScheduled.set(false)
+ return
+ }
+ injectPageScript(webView)
+ mainHandler.postDelayed(this, SCRIPT_POLL_INTERVAL_MS)
+ }
+ },
+ SCRIPT_POLL_INTERVAL_MS,
+ )
}
/**
@@ -139,4 +185,9 @@ class RequestInterceptorWebViewClient(
capturedRequests.toList()
}
}
+
+ private companion object {
+
+ const val SCRIPT_POLL_INTERVAL_MS = 250L
+ }
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/WebViewExecutor.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/WebViewExecutor.kt
index a6636d83e9..9fee4821a8 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/WebViewExecutor.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/WebViewExecutor.kt
@@ -13,33 +13,21 @@ import kotlinx.coroutines.suspendCancellableCoroutine
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withContext
-import kotlinx.coroutines.withTimeout
-import io.github.landwarderer.futon.core.exceptions.CloudFlareException
-import io.github.landwarderer.futon.core.network.CommonHeaders
-import io.github.landwarderer.futon.core.network.cookies.MutableCookieJar
import io.github.landwarderer.futon.core.network.proxy.ProxyProvider
-import io.github.landwarderer.futon.core.parser.MangaRepository
-import io.github.landwarderer.futon.core.parser.ParserMangaRepository
import io.github.landwarderer.futon.core.util.ext.configureForParser
import io.github.landwarderer.futon.core.util.ext.printStackTraceDebug
import io.github.landwarderer.futon.core.util.ext.sanitizeHeaderValue
-import org.koitharu.kotatsu.parsers.model.MangaSource
import org.koitharu.kotatsu.parsers.util.nullIfEmpty
-import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
import java.lang.ref.WeakReference
import javax.inject.Inject
-import javax.inject.Provider
import javax.inject.Singleton
import kotlin.coroutines.resume
-import kotlin.coroutines.suspendCoroutine
import kotlin.ranges.contains
@Singleton
class WebViewExecutor @Inject constructor(
@ApplicationContext private val context: Context,
private val proxyProvider: ProxyProvider,
- private val cookieJar: MutableCookieJar,
- private val mangaRepositoryFactoryProvider: Provider,
) {
private var webViewCached: WeakReference? = null
@@ -67,15 +55,19 @@ class WebViewExecutor @Inject constructor(
try {
if (baseUrl.isNullOrEmpty()) {
- return@withContext suspendCoroutine { cont ->
- webView.evaluateJavascript(script) { cont.resume(it.takeUnless { r -> r == "null" }) }
+ return@withContext suspendCancellableCoroutine { cont ->
+ webView.evaluateJavascript(script) { result ->
+ if (cont.isActive) {
+ cont.resume(result?.takeUnless { it == "null" })
+ }
+ }
}
}
val baseUri = android.net.Uri.parse(baseUrl)
val originalHost = baseUri.host
- suspendCoroutine { continuation ->
+ suspendCancellableCoroutine { continuation ->
var hasResumed = false
val resumeOnce: (String?) -> Unit = { result ->
@@ -84,10 +76,19 @@ class WebViewExecutor @Inject constructor(
handler.removeCallbacksAndMessages(null)
// Immediately stop further loading/polling
webView.stopLoading()
- continuation.resume(result)
+ if (continuation.isActive) {
+ continuation.resume(result)
+ }
}
}
+ continuation.invokeOnCancellation {
+ hasResumed = true
+ handler.removeCallbacksAndMessages(null)
+ webView.post { runCatching { webView.stopLoading() } }
+ }
+ if (!continuation.isActive) return@suspendCancellableCoroutine
+
val contentPoller = object : Runnable {
val startTime = System.currentTimeMillis()
override fun run() {
@@ -151,49 +152,35 @@ class WebViewExecutor @Inject constructor(
}, timeoutMs)
}
} finally {
- // If already resumed, stopLoading() was called; this is a safety call.
- webView.stopLoading()
+ handler.removeCallbacksAndMessages(null)
+ destroyEvaluatedWebView(webView)
}
}
}
- suspend fun tryResolveCaptcha(exception: CloudFlareException, timeout: Long): Boolean = mutex.withLock {
- runCatchingCancellable {
- withContext(Dispatchers.Main.immediate) {
- val webView = obtainWebView()
- try {
- exception.source.getUserAgent()?.let {
- webView.settings.userAgentString = it
- }
- withTimeout(timeout) {
- suspendCancellableCoroutine { cont ->
- webView.webViewClient = CaptchaContinuationClient(
- cookieJar = cookieJar,
- targetUrl = exception.url,
- continuation = cont,
- )
- webView.loadUrl(exception.url)
- }
- }
- } finally {
- webView.reset()
- }
- }
- }.onFailure { e ->
- exception.addSuppressed(e)
- e.printStackTraceDebug("WebViewExecutor::tryResolveCaptcha")
- }.isSuccess
- }
-
@MainThread
private fun obtainWebView(): WebView = webViewCached?.get() ?: WebView(context).also {
it.configureForParser(null)
webViewCached = WeakReference(it)
}
- private fun MangaSource.getUserAgent(): String? {
- val repository = mangaRepositoryFactoryProvider.get().create(this) as? ParserMangaRepository
- return repository?.getRequestHeaders()?.get(CommonHeaders.USER_AGENT)
+ /**
+ * Evaluation WebViews are intentionally one-shot. Keeping the loaded document alive after returning lets
+ * media, animation frames, workers, and page timers continue consuming power in the background.
+ */
+ @MainThread
+ private fun destroyEvaluatedWebView(webView: WebView) {
+ if (webViewCached?.get() === webView) {
+ webViewCached = null
+ }
+ runCatching { webView.stopLoading() }
+ runCatching { webView.onPause() }
+ webView.webViewClient = WebViewClient()
+ webView.webChromeClient = null
+ runCatching { webView.loadUrl("about:blank") }
+ runCatching { webView.clearHistory() }
+ runCatching { webView.removeAllViews() }
+ runCatching { webView.destroy() }
}
@MainThread
@@ -202,13 +189,4 @@ class WebViewExecutor @Inject constructor(
}.onFailure { e ->
e.printStackTraceDebug()
}.getOrNull()
-
- @MainThread
- private fun WebView.reset() {
- stopLoading()
- webViewClient = WebViewClient()
- settings.userAgentString = defaultUserAgent
- loadDataWithBaseURL(null, " ", "text/html", null, null)
- clearHistory()
- }
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/WebViewRequestInterceptorExecutor.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/WebViewRequestInterceptorExecutor.kt
index 664e6e0997..d7e644ea2f 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/WebViewRequestInterceptorExecutor.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/network/webview/WebViewRequestInterceptorExecutor.kt
@@ -7,11 +7,14 @@ import android.util.Log
import android.webkit.PermissionRequest
import android.webkit.WebChromeClient
import android.webkit.WebView
+import android.webkit.WebViewClient
import androidx.annotation.MainThread
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.CompletableDeferred
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withContext
import kotlinx.coroutines.withTimeout
import io.github.landwarderer.futon.browser.BrowserCallback
@@ -33,151 +36,137 @@ class WebViewRequestInterceptorExecutor @Inject constructor(
private var webViewCached: WeakReference? = null
private val mainHandler = Handler(Looper.getMainLooper())
- private val activeWebViews = mutableSetOf>()
+ private val mutex = Mutex()
suspend fun interceptRequests(
url: String,
config: InterceptionConfig
- ): List = withTimeout(config.timeoutMs + 5000) {
- Log.d(TAG_VRF, "interceptRequests start url=$url injectPageScript=${!config.pageScript.isNullOrBlank()} hasFilterScript=${!config.filterScript.isNullOrBlank()}")
- withContext(Dispatchers.Main) {
- suspendCancellableCoroutine { continuation ->
- val resultDeferred = CompletableDeferred>()
-
- val interceptor = object : WebViewRequestInterceptor {
- override fun shouldCaptureRequest(request: InterceptedRequest): Boolean {
- val urlOk = config.urlPattern?.containsMatchIn(request.url) ?: true
- val scriptOk = try {
- if (config.filterScript.isNullOrBlank()) true
- else evaluateFilterPredicate(config.filterScript, request.url)
- } catch (e: Throwable) {
- Log.w(TAG_VRF, "Filter error ${e.message}")
- false
+ ): List = mutex.withLock {
+ withTimeout(config.timeoutMs + 5000) {
+ Log.d(TAG_VRF, "interceptRequests start url=$url injectPageScript=${!config.pageScript.isNullOrBlank()} hasFilterScript=${!config.filterScript.isNullOrBlank()}")
+ withContext(Dispatchers.Main.immediate) {
+ suspendCancellableCoroutine { continuation ->
+ val resultDeferred = CompletableDeferred>()
+
+ val interceptor = object : WebViewRequestInterceptor {
+ override fun shouldCaptureRequest(request: InterceptedRequest): Boolean {
+ val urlOk = config.urlPattern?.containsMatchIn(request.url) ?: true
+ val scriptOk = try {
+ if (config.filterScript.isNullOrBlank()) true
+ else evaluateFilterPredicate(config.filterScript, request.url)
+ } catch (e: Throwable) {
+ Log.w(TAG_VRF, "Filter error ${e.message}")
+ false
+ }
+ val match = urlOk && scriptOk
+ Log.v(TAG_VRF, "REQ url=${request.url} method=${request.method} urlOk=$urlOk scriptOk=$scriptOk match=$match")
+ return match
}
- val match = urlOk && scriptOk
- Log.v(TAG_VRF, "REQ url=${request.url} method=${request.method} urlOk=$urlOk scriptOk=$scriptOk match=$match")
- return match
- }
- override fun onInterceptionComplete(capturedRequests: List) {
- Log.d(TAG_VRF, "Interception complete captured=${capturedRequests.size}")
- if (!resultDeferred.isCompleted) {
- resultDeferred.complete(capturedRequests)
+ override fun onInterceptionComplete(capturedRequests: List) {
+ Log.d(TAG_VRF, "Interception complete captured=${capturedRequests.size}")
+ if (!resultDeferred.isCompleted) {
+ resultDeferred.complete(capturedRequests)
+ }
}
- }
- override fun onInterceptionError(error: Throwable) {
- Log.w(TAG_VRF, "Interception error", error)
- if (!resultDeferred.isCompleted) {
- resultDeferred.completeExceptionally(error)
+ override fun onInterceptionError(error: Throwable) {
+ Log.w(TAG_VRF, "Interception error", error)
+ if (!resultDeferred.isCompleted) {
+ resultDeferred.completeExceptionally(error)
+ }
}
}
- }
- val callback = object : BrowserCallback {
- override fun onLoadingStateChanged(isLoading: Boolean) {
- Log.v(TAG_VRF, "Loading state changed isLoading=$isLoading")
- }
- override fun onTitleChanged(title: CharSequence, subtitle: CharSequence?) {
- Log.v(TAG_VRF, "Title changed title=$title subtitle=$subtitle")
- }
- override fun onHistoryChanged() {
- Log.v(TAG_VRF, "History changed")
+ val callback = object : BrowserCallback {
+ override fun onLoadingStateChanged(isLoading: Boolean) {
+ Log.v(TAG_VRF, "Loading state changed isLoading=$isLoading")
+ }
+ override fun onTitleChanged(title: CharSequence, subtitle: CharSequence?) {
+ Log.v(TAG_VRF, "Title changed title=$title subtitle=$subtitle")
+ }
+ override fun onHistoryChanged() {
+ Log.v(TAG_VRF, "History changed")
+ }
}
- }
- var webView: WebView? = null
- try {
- webView = obtainWebView()
- val client = RequestInterceptorWebViewClient(callback, adBlock, config, interceptor)
- webView.webViewClient = client
-
- webView.webChromeClient = object : WebChromeClient() {
- override fun onPermissionRequest(request: PermissionRequest?) {
- if (request?.resources?.contains(PermissionRequest.RESOURCE_PROTECTED_MEDIA_ID) == true) {
- request.grant(request.resources)
- } else {
- super.onPermissionRequest(request)
+ var webView: WebView? = null
+ try {
+ webView = obtainWebView()
+ val client = RequestInterceptorWebViewClient(callback, adBlock, config, interceptor)
+ webView.webViewClient = client
+
+ webView.webChromeClient = object : WebChromeClient() {
+ override fun onPermissionRequest(request: PermissionRequest?) {
+ if (request?.resources?.contains(PermissionRequest.RESOURCE_PROTECTED_MEDIA_ID) == true) {
+ request.grant(request.resources)
+ } else {
+ super.onPermissionRequest(request)
+ }
}
}
- }
-
- webView.loadUrl(url)
- val timeoutRunnable = Runnable {
- Log.w(TAG_VRF, "Timeout, stopping capture")
- client.stopCapturing()
- }
- mainHandler.postDelayed(timeoutRunnable, config.timeoutMs)
+ webView.loadUrl(url)
- resultDeferred.invokeOnCompletion { ex ->
- mainHandler.removeCallbacks(timeoutRunnable)
- // Clean up WebView after operation completes - must run on main thread
- webView?.let { wv ->
- Log.d(TAG_VRF, "Cleaning up WebView after operation")
- if (Thread.currentThread() == Looper.getMainLooper().thread) {
- // Already on main thread, destroy immediately
- wv.stopLoading()
- wv.destroy()
- removeWebViewFromTracking(wv)
- if (ex != null) continuation.resumeWithException(ex)
- else continuation.resume(resultDeferred.getCompleted())
- } else {
- // Must post to main thread, but wait for completion
- mainHandler.post {
- wv.stopLoading()
- wv.destroy()
- removeWebViewFromTracking(wv)
+ val timeoutRunnable = Runnable {
+ Log.w(TAG_VRF, "Timeout, stopping capture")
+ client.stopCapturing()
+ }
+ mainHandler.postDelayed(timeoutRunnable, config.timeoutMs)
+
+ resultDeferred.invokeOnCompletion { ex ->
+ mainHandler.removeCallbacks(timeoutRunnable)
+ // Clean up WebView after operation completes - must run on main thread
+ webView?.let { wv ->
+ Log.d(TAG_VRF, "Cleaning up WebView after operation")
+ if (Thread.currentThread() == Looper.getMainLooper().thread) {
+ releaseWebView(wv)
if (ex != null) continuation.resumeWithException(ex)
else continuation.resume(resultDeferred.getCompleted())
+ } else {
+ mainHandler.post {
+ releaseWebView(wv)
+ if (ex != null) continuation.resumeWithException(ex)
+ else continuation.resume(resultDeferred.getCompleted())
+ }
}
+ } ?: run {
+ // No WebView to clean up, resume immediately
+ if (ex != null) continuation.resumeWithException(ex)
+ else continuation.resume(resultDeferred.getCompleted())
}
- } ?: run {
- // No WebView to clean up, resume immediately
- if (ex != null) continuation.resumeWithException(ex)
- else continuation.resume(resultDeferred.getCompleted())
}
- }
- continuation.invokeOnCancellation {
- client.stopCapturing()
- mainHandler.removeCallbacks(timeoutRunnable)
- // Clean up WebView on cancellation - must run on main thread
+ continuation.invokeOnCancellation {
+ client.stopCapturing()
+ mainHandler.removeCallbacks(timeoutRunnable)
+ // Clean up WebView on cancellation - must run on main thread
+ webView?.let { wv ->
+ Log.d(TAG_VRF, "Cleaning up WebView on cancellation")
+ if (Thread.currentThread() == Looper.getMainLooper().thread) {
+ releaseWebView(wv)
+ } else {
+ mainHandler.post {
+ releaseWebView(wv)
+ }
+ }
+ }
+ if (!resultDeferred.isCompleted) resultDeferred.cancel()
+ }
+ } catch (e: Exception) {
+ // Clean up WebView on exception - must run on main thread
webView?.let { wv ->
- Log.d(TAG_VRF, "Cleaning up WebView on cancellation")
+ Log.d(TAG_VRF, "Cleaning up WebView on exception")
if (Thread.currentThread() == Looper.getMainLooper().thread) {
- // Already on main thread, destroy immediately
- wv.stopLoading()
- wv.destroy()
- removeWebViewFromTracking(wv)
+ releaseWebView(wv)
+ continuation.resumeWithException(e)
} else {
- // Must post to main thread for cleanup
mainHandler.post {
- wv.stopLoading()
- wv.destroy()
- removeWebViewFromTracking(wv)
+ releaseWebView(wv)
+ continuation.resumeWithException(e)
}
}
- }
- if (!resultDeferred.isCompleted) resultDeferred.cancel()
+ } ?: continuation.resumeWithException(e)
}
- } catch (e: Exception) {
- // Clean up WebView on exception - must run on main thread
- webView?.let { wv ->
- Log.d(TAG_VRF, "Cleaning up WebView on exception")
- if (Thread.currentThread() == Looper.getMainLooper().thread) {
- // Already on main thread, destroy immediately
- wv.destroy()
- removeWebViewFromTracking(wv)
- continuation.resumeWithException(e)
- } else {
- // Must post to main thread, then resume with exception
- mainHandler.post {
- wv.destroy()
- removeWebViewFromTracking(wv)
- continuation.resumeWithException(e)
- }
- }
- } ?: continuation.resumeWithException(e)
}
}
}
@@ -199,57 +188,23 @@ class WebViewRequestInterceptorExecutor @Inject constructor(
}
@MainThread
- private fun obtainWebView(): WebView {
- // Clean up any previous WebView instances
- cleanupOldWebViews()
-
- val wv = WebView(context).apply {
- configureForParser(null)
- // Clear any existing state
- clearHistory()
- clearCache(true)
- }
- Log.d(TAG_VRF, "Created fresh WebView instance")
-
- // Track this WebView
- val webViewRef = WeakReference(wv)
- webViewCached = webViewRef
- synchronized(activeWebViews) {
- activeWebViews.add(webViewRef)
- }
-
- return wv
- }
-
- @MainThread
- private fun cleanupOldWebViews() {
- synchronized(activeWebViews) {
- val iterator = activeWebViews.iterator()
- while (iterator.hasNext()) {
- val ref = iterator.next()
- val webView = ref.get()
- if (webView == null) {
- // WebView was garbage collected
- iterator.remove()
- } else {
- // Destroy still-active WebView
- Log.d(TAG_VRF, "Destroying previous WebView instance")
- webView.destroy()
- iterator.remove()
- }
- }
- }
- webViewCached = null
+ private fun obtainWebView(): WebView = webViewCached?.get() ?: WebView(context).also { webView ->
+ webView.configureForParser(null)
+ webView.clearHistory()
+ webView.clearCache(true)
+ webViewCached = WeakReference(webView)
}
+ /**
+ * The WebView is reused by the next (serialized) capture, which replaces the document with loadUrl().
+ * stopLoading() and destroy() can block the main thread for seconds while Chromium tears down,
+ * so only detach the callbacks and ask the page to stop asynchronously.
+ */
@MainThread
- private fun removeWebViewFromTracking(webView: WebView) {
- synchronized(activeWebViews) {
- activeWebViews.removeAll { it.get() == webView || it.get() == null }
- }
- if (webViewCached?.get() == webView) {
- webViewCached = null
- }
+ private fun releaseWebView(webView: WebView) {
+ runCatching { webView.evaluateJavascript("window.stop(); void 0", null) }
+ webView.webViewClient = WebViewClient()
+ webView.webChromeClient = WebChromeClient()
}
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/os/AppShortcutManager.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/os/AppShortcutManager.kt
index 54b5e30f00..1f0858c2e8 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/os/AppShortcutManager.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/os/AppShortcutManager.kt
@@ -19,6 +19,7 @@ import io.github.landwarderer.futon.R
import io.github.landwarderer.futon.core.LocalizedAppContext
import io.github.landwarderer.futon.core.db.TABLE_HISTORY
import io.github.landwarderer.futon.core.model.getTitle
+import io.github.landwarderer.futon.core.model.isNsfw
import io.github.landwarderer.futon.core.nav.AppRouter
import io.github.landwarderer.futon.core.nav.ReaderIntent
import io.github.landwarderer.futon.core.parser.MangaDataRepository
@@ -72,12 +73,19 @@ class AppShortcutManager @Inject constructor(
}
override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences?, key: String?) {
- if (key == AppSettings.KEY_SHORTCUTS) {
- if (settings.isDynamicShortcutsEnabled) {
+ when (key) {
+ AppSettings.KEY_SHORTCUTS -> if (settings.isDynamicShortcutsEnabled) {
onInvalidated(emptySet())
} else {
clearShortcuts()
}
+
+ // Rebuild straight away, so turning the filter on removes what is already on the home screen
+ // instead of waiting for the next history change.
+ AppSettings.KEY_SHORTCUTS_NO_NSFW,
+ AppSettings.KEY_DISABLE_NSFW -> if (settings.isDynamicShortcutsEnabled) {
+ onInvalidated(emptySet())
+ }
}
}
@@ -119,8 +127,13 @@ class AppShortcutManager @Inject constructor(
private suspend fun updateShortcutsImpl() = runCatchingCancellable {
val maxShortcuts = ShortcutManagerCompat.getMaxShortcutCountPerActivity(context).coerceAtLeast(5)
- val shortcuts = historyRepository.getList(0, maxShortcuts)
- .filter { x -> x.title.isNotEmpty() }
+ val skipNsfw = settings.isShortcutsNsfwDisabled || settings.isNsfwContentDisabled
+ // Over-fetch when filtering, so a run of adult titles at the top of the history does not leave
+ // the launcher with only one or two shortcuts.
+ val limit = if (skipNsfw) maxShortcuts * HISTORY_OVERFETCH else maxShortcuts
+ val shortcuts = historyRepository.getList(0, limit)
+ .filter { x -> x.title.isNotEmpty() && (!skipNsfw || !x.isNsfw()) }
+ .take(maxShortcuts)
.map { buildShortcutInfo(it) }
ShortcutManagerCompat.setDynamicShortcuts(context, shortcuts)
}.onFailure {
@@ -191,4 +204,10 @@ class AppShortcutManager @Inject constructor(
.setIntent(AppRouter.listIntent(context, source, null, null))
.build()
}
+
+ private companion object {
+
+ /** How much extra history to read when adult titles are being filtered out. */
+ const val HISTORY_OVERFETCH = 4
+ }
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/parser/MangaDataRepository.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/parser/MangaDataRepository.kt
index 3c94bc2d31..3592ac85d5 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/parser/MangaDataRepository.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/parser/MangaDataRepository.kt
@@ -17,9 +17,11 @@ import io.github.landwarderer.futon.core.db.entity.MangaPrefsEntity
import io.github.landwarderer.futon.core.db.entity.toEntities
import io.github.landwarderer.futon.core.db.entity.toEntity
import io.github.landwarderer.futon.core.db.entity.toManga
+import io.github.landwarderer.futon.core.db.entity.toMangaChapter
import io.github.landwarderer.futon.core.db.entity.toMangaChapters
import io.github.landwarderer.futon.core.db.entity.toMangaTags
import io.github.landwarderer.futon.core.model.LocalMangaSource
+import io.github.landwarderer.futon.core.model.findSameChapter
import io.github.landwarderer.futon.core.model.isLocal
import io.github.landwarderer.futon.core.nav.MangaIntent
import io.github.landwarderer.futon.core.os.AppShortcutManager
@@ -27,8 +29,10 @@ import io.github.landwarderer.futon.core.prefs.ReaderMode
import io.github.landwarderer.futon.core.ui.model.MangaOverride
import io.github.landwarderer.futon.core.util.ext.toFileOrNull
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.parsers.model.MangaTag
+import org.koitharu.kotatsu.parsers.util.findById
import org.koitharu.kotatsu.parsers.util.nullIfEmpty
import io.github.landwarderer.futon.reader.domain.ReaderColorFilter
import javax.inject.Inject
@@ -123,6 +127,15 @@ class MangaDataRepository @Inject constructor(
return db.getMangaDao().findByPublicUrl(publicUrl)?.toManga()
}
+ /** Titles of [source] that are in the user's favourites or reading history. */
+ suspend fun findLibraryMangaBySource(source: MangaSource): List {
+ return db.getMangaDao().findLibraryBySource(source.name).map { it.toManga() }
+ }
+
+ suspend fun findAllMangaBySource(source: MangaSource): List {
+ return db.getMangaDao().findAllBySource(source.name).map { it.toManga() }
+ }
+
suspend fun resolveIntent(intent: MangaIntent, withChapters: Boolean): Manga? = when {
intent.manga != null -> intent.manga.withCachedChaptersIfNeeded(withChapters)
intent.mangaId != 0L -> findMangaById(intent.mangaId, withChapters)
@@ -147,6 +160,7 @@ class MangaDataRepository @Inject constructor(
db.getMangaDao().upsert(manga.toEntity(), tags)
if (!manga.isLocal) {
manga.chapters?.let { chapters ->
+ keepHistoryChapter(manga.id, chapters)
db.getChaptersDao().replaceAll(manga.id, chapters.withIndex().toEntities(manga.id))
}
}
@@ -157,8 +171,35 @@ class MangaDataRepository @Inject constructor(
suspend fun updateChapters(manga: Manga) {
val chapters = manga.chapters
if (!chapters.isNullOrEmpty() && manga.id in db.getMangaDao()) {
- db.getChaptersDao().replaceAll(manga.id, chapters.withIndex().toEntities(manga.id))
+ db.withTransaction {
+ keepHistoryChapter(manga.id, chapters)
+ db.getChaptersDao().replaceAll(manga.id, chapters.withIndex().toEntities(manga.id))
+ }
+ }
+ }
+
+ /**
+ * The chapter as it was in the chapter list last stored for [mangaId], which may hold ids that a fresher load
+ * of the source no longer has.
+ */
+ suspend fun findCachedChapter(mangaId: Long, chapterId: Long): MangaChapter? {
+ return db.getChaptersDao().find(mangaId, chapterId)?.toMangaChapter()
+ }
+
+ /**
+ * History only keeps a chapter id. When the source gives the history chapter a new id, the stored list is the
+ * last place that still says which chapter it was, so move the history onto that chapter of [newChapters]
+ * before the list is replaced. Otherwise the reading position is later guessed from a percentage, possibly
+ * in another branch.
+ */
+ private suspend fun keepHistoryChapter(mangaId: Long, newChapters: List) {
+ val history = db.getHistoryDao().find(mangaId) ?: return
+ if (newChapters.findById(history.chapterId) != null) {
+ return
}
+ val previous = findCachedChapter(mangaId, history.chapterId) ?: return
+ val same = newChapters.findSameChapter(previous) ?: return
+ db.getHistoryDao().update(history.copy(chapterId = same.id))
}
suspend fun gcChaptersCache() {
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/prefs/AppSettings.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/prefs/AppSettings.kt
index 32273027e5..ddb4fc7fbc 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/prefs/AppSettings.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/prefs/AppSettings.kt
@@ -198,9 +198,13 @@ class AppSettings internal constructor(
get() = prefs.getBoolean(KEY_READER_DOUBLE_FOLDABLE, false)
set(value) = prefs.edit { putBoolean(KEY_READER_DOUBLE_FOLDABLE, value) }
+ var isReaderDoubleCoverPage: Boolean
+ get() = prefs.getBoolean(KEY_READER_DOUBLE_COVER_PAGE, false)
+ set(value) = prefs.edit { putBoolean(KEY_READER_DOUBLE_COVER_PAGE, value) }
+
@get:FloatRange(0.0, 1.0)
var readerDoublePagesSensitivity: Float
- get() = prefs.getFloat(KEY_READER_DOUBLE_PAGES_SENSITIVITY, 0.5f)
+ get() = getFloatCompat(KEY_READER_DOUBLE_PAGES_SENSITIVITY, 0.5f)
set(@FloatRange(0.0, 1.0) value) = prefs.edit { putFloat(KEY_READER_DOUBLE_PAGES_SENSITIVITY, value) }
val readerScreenOrientation: Int
@@ -225,6 +229,18 @@ class AppSettings internal constructor(
val isReaderOptimizationEnabled: Boolean
get() = prefs.getBoolean(KEY_READER_OPTIMIZE, false)
+ val isEInkFlashEnabled: Boolean
+ get() = prefs.getBoolean(KEY_EINK_FLASH, false)
+
+ val eInkFlashDuration: Int
+ get() = prefs.getInt(KEY_EINK_FLASH_DURATION, 300).coerceIn(100, 1000)
+
+ val eInkFlashEvery: Int
+ get() = prefs.getInt(KEY_EINK_FLASH_EVERY, 1).coerceAtLeast(1)
+
+ val eInkFlashColor: EInkFlashColor
+ get() = prefs.getEnumValue(KEY_EINK_FLASH_COLOR, EInkFlashColor.WHITE)
+
val readerControls: Set
get() = prefs.getStringSet(KEY_READER_CONTROLS, null)?.mapNotNullTo(EnumSet.noneOf(ReaderControl::class.java)) {
ReaderControl.entries.find(it)
@@ -255,6 +271,17 @@ class AppSettings internal constructor(
val trackerDownloadStrategy: TrackerDownloadStrategy
get() = prefs.getEnumValue(KEY_TRACKER_DOWNLOAD, TrackerDownloadStrategy.DISABLED)
+ val isTrackerCaptchaRecheckEnabled: Boolean
+ get() = prefs.getBoolean(KEY_TRACKER_CAPTCHA_RECHECK, true)
+
+ var isTrackerUnstuckMigrationDone: Boolean
+ get() = prefs.getBoolean(KEY_TRACKER_UNSTUCK_MIGRATION, false)
+ set(value) = prefs.edit { putBoolean(KEY_TRACKER_UNSTUCK_MIGRATION, value) }
+
+ var isTrackerProgressRefreshDone: Boolean
+ get() = prefs.getBoolean(KEY_TRACKER_PROGRESS_REFRESH, false)
+ set(value) = prefs.edit { putBoolean(KEY_TRACKER_PROGRESS_REFRESH, value) }
+
var notificationSound: Uri
get() = prefs.getString(KEY_NOTIFICATIONS_SOUND, null)?.toUriOrNull()
?: Settings.System.DEFAULT_NOTIFICATION_URI
@@ -348,6 +375,14 @@ class AppSettings internal constructor(
val isDynamicShortcutsEnabled: Boolean
get() = prefs.getBoolean(KEY_SHORTCUTS, true)
+ /**
+ * Keep adult manga out of the launcher's long-press shortcuts.
+ *
+ * Defaults to `true`: the home screen is visible to anyone holding the phone.
+ */
+ val isShortcutsNsfwDisabled: Boolean
+ get() = prefs.getBoolean(KEY_SHORTCUTS_NO_NSFW, true)
+
val isUnstableUpdatesAllowed: Boolean
get() = prefs.getBoolean(KEY_UPDATES_UNSTABLE, false)
@@ -404,6 +439,11 @@ class AppSettings internal constructor(
get() = prefs.getBoolean(KEY_SOURCES_ENABLED_ALL, false)
set(value) = prefs.edit { putBoolean(KEY_SOURCES_ENABLED_ALL, value) }
+ /** Id of the active source preset, or 0 when the regular enabled sources are used. */
+ var activeSourcePresetId: Long
+ get() = getLongCompat(KEY_ACTIVE_SOURCE_PRESET, 0L)
+ set(value) = prefs.edit { putLong(KEY_ACTIVE_SOURCE_PRESET, value) }
+
val isPagesNumbersEnabled: Boolean
get() = prefs.getBoolean(KEY_PAGES_NUMBERS, false)
@@ -413,6 +453,9 @@ class AppSettings internal constructor(
val isAdBlockEnabled: Boolean
get() = prefs.getBoolean(KEY_ADBLOCK, false)
+ val isCaptchaAutoSolveEnabled: Boolean
+ get() = prefs.getBoolean(KEY_CAPTCHA_AUTO_SOLVE, false)
+
var userSpecifiedMangaDirectories: Set
get() {
val set = prefs.getStringSet(KEY_LOCAL_MANGA_DIRS, emptySet()).orEmpty()
@@ -506,8 +549,8 @@ class AppSettings internal constructor(
var readerColorFilter: ReaderColorFilter?
get() = runCatching {
ReaderColorFilter(
- brightness = prefs.getFloat(KEY_CF_BRIGHTNESS, ReaderColorFilter.EMPTY.brightness),
- contrast = prefs.getFloat(KEY_CF_CONTRAST, ReaderColorFilter.EMPTY.contrast),
+ brightness = getFloatCompat(KEY_CF_BRIGHTNESS, ReaderColorFilter.EMPTY.brightness),
+ contrast = getFloatCompat(KEY_CF_CONTRAST, ReaderColorFilter.EMPTY.contrast),
isInverted = prefs.getBoolean(KEY_CF_INVERTED, ReaderColorFilter.EMPTY.isInverted),
isGrayscale = prefs.getBoolean(KEY_CF_GRAYSCALE, ReaderColorFilter.EMPTY.isGrayscale),
isBookBackground = prefs.getBoolean(KEY_CF_BOOK, ReaderColorFilter.EMPTY.isBookBackground),
@@ -594,7 +637,7 @@ class AppSettings internal constructor(
@get:FloatRange(from = 0.0, to = 1.0)
var readerAutoscrollSpeed: Float
- get() = prefs.getFloat(KEY_READER_AUTOSCROLL_SPEED, 0f)
+ get() = getFloatCompat(KEY_READER_AUTOSCROLL_SPEED, 0f)
set(@FloatRange(from = 0.0, to = 1.0) value) = prefs.edit {
putFloat(
KEY_READER_AUTOSCROLL_SPEED,
@@ -786,7 +829,7 @@ class AppSettings internal constructor(
if (!isMerge) {
clear()
}
- putAll(m)
+ putAll(normalizeImportedPreferences(m))
}
private fun isBackgroundNetworkRestricted(): Boolean {
@@ -797,6 +840,54 @@ class AppSettings internal constructor(
}
}
+ // Long preferences restored from a JSON backup come back as Integer (or String)
+ private fun getLongCompat(key: String, defaultValue: Long): Long = try {
+ prefs.getLong(key, defaultValue)
+ } catch (_: ClassCastException) {
+ val fixedValue = when (val rawValue = prefs.all[key]) {
+ is Number -> rawValue.toLong()
+ is String -> rawValue.toLongOrNull()
+ else -> null
+ }
+ if (fixedValue == null) {
+ prefs.edit { remove(key) }
+ defaultValue
+ } else {
+ prefs.edit { putLong(key, fixedValue) }
+ fixedValue
+ }
+ }
+
+ private fun normalizeImportedPreferences(values: Map): Map {
+ val fixedValue = when (val rawValue = values[KEY_ACTIVE_SOURCE_PRESET] ?: return values) {
+ is Long -> return values
+ is Number -> rawValue.toLong()
+ is String -> rawValue.toLongOrNull() ?: return values
+ else -> return values
+ }
+ return HashMap(values).apply {
+ put(KEY_ACTIVE_SOURCE_PRESET, fixedValue)
+ }
+ }
+
+ // Float preferences restored from a JSON backup may come back as another type
+ private fun getFloatCompat(key: String, defaultValue: Float): Float = try {
+ prefs.getFloat(key, defaultValue)
+ } catch (_: ClassCastException) {
+ val fixedValue = when (val rawValue = prefs.all[key]) {
+ is Number -> rawValue.toFloat()
+ is String -> rawValue.toFloatOrNull()
+ else -> null
+ }
+ if (fixedValue == null || !fixedValue.isFinite()) {
+ prefs.edit { remove(key) }
+ defaultValue
+ } else {
+ prefs.edit { putFloat(key, fixedValue) }
+ fixedValue
+ }
+ }
+
companion object {
@Volatile
@@ -806,6 +897,7 @@ class AppSettings internal constructor(
const val TRACK_FAVOURITES = "favourites"
const val KEY_ADBLOCK = "adblock"
+ const val KEY_CAPTCHA_AUTO_SOLVE = "captcha_auto_solve"
const val KEY_LIST_MODE = "list_mode_2"
const val KEY_LIST_MODE_HISTORY = "list_mode_history"
const val KEY_LIST_MODE_FAVORITES = "list_mode_favorites"
@@ -831,6 +923,7 @@ class AppSettings internal constructor(
const val KEY_READER_DOUBLE_PAGES = "reader_double_pages"
const val KEY_READER_DOUBLE_PAGES_SENSITIVITY = "reader_double_pages_sensitivity_2"
const val KEY_READER_DOUBLE_FOLDABLE = "reader_double_foldable"
+ const val KEY_READER_DOUBLE_COVER_PAGE = "reader_double_cover_page"
const val KEY_READER_ZOOM_BUTTONS = "reader_zoom_buttons"
const val KEY_READER_CONTROL_LTR = "reader_taps_ltr"
const val KEY_READER_NAVIGATION_INVERTED = "reader_navigation_inverted"
@@ -846,6 +939,9 @@ class AppSettings internal constructor(
const val KEY_TRACKER_NOTIFICATIONS = "tracker_notifications"
const val KEY_TRACKER_NO_NSFW = "tracker_no_nsfw"
const val KEY_TRACKER_DOWNLOAD = "tracker_download"
+ const val KEY_TRACKER_CAPTCHA_RECHECK = "tracker_captcha_recheck"
+ const val KEY_TRACKER_UNSTUCK_MIGRATION = "tracker_unstuck_migration"
+ const val KEY_TRACKER_PROGRESS_REFRESH = "tracker_progress_refresh"
const val KEY_NOTIFICATIONS_SETTINGS = "notifications_settings"
const val KEY_NOTIFICATIONS_SOUND = "notifications_sound"
const val KEY_NOTIFICATIONS_VIBRATE = "notifications_vibrate"
@@ -909,8 +1005,13 @@ class AppSettings internal constructor(
const val KEY_READER_BACKGROUND = "reader_background"
const val KEY_READER_SCREEN_ON = "reader_screen_on"
const val KEY_SHORTCUTS = "dynamic_shortcuts"
+ const val KEY_SHORTCUTS_NO_NSFW = "shortcuts_no_nsfw"
const val KEY_READER_TAP_ACTIONS = "reader_tap_actions"
const val KEY_READER_OPTIMIZE = "reader_optimize"
+ const val KEY_EINK_FLASH = "eink_flash"
+ const val KEY_EINK_FLASH_DURATION = "eink_flash_duration"
+ const val KEY_EINK_FLASH_EVERY = "eink_flash_every"
+ const val KEY_EINK_FLASH_COLOR = "eink_flash_color"
const val KEY_LOCAL_LIST_ORDER = "local_order"
const val KEY_HISTORY_ORDER = "history_order"
const val KEY_FAVORITES_ORDER = "fav_order"
@@ -969,6 +1070,7 @@ class AppSettings internal constructor(
const val KEY_MODE_SWITCHER_SPOTLIGHT_SHOWN = "mode_switcher_spotlight_shown"
const val KEY_ABOUT_ONBOARDING = "about_onboarding"
const val KEY_SOURCES_ENABLED_ALL = "sources_enabled_all"
+ const val KEY_ACTIVE_SOURCE_PRESET = "active_source_preset"
const val KEY_QUICK_FILTER = "quick_filter"
const val KEY_COLLAPSE_DESCRIPTION = "description_collapse"
const val KEY_BACKUP_TG_ENABLED = "backup_periodic_tg_enabled"
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/prefs/EInkFlashColor.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/prefs/EInkFlashColor.kt
new file mode 100644
index 0000000000..040a050c2c
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/prefs/EInkFlashColor.kt
@@ -0,0 +1,11 @@
+package io.github.landwarderer.futon.core.prefs
+
+import android.graphics.Color
+import androidx.annotation.ColorInt
+import androidx.annotation.Keep
+
+@Keep
+enum class EInkFlashColor(@ColorInt val colorInt: Int) {
+ WHITE(Color.WHITE),
+ BLACK(Color.BLACK),
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/prefs/SourceSettings.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/prefs/SourceSettings.kt
index 5539b02bc3..ec038bb763 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/prefs/SourceSettings.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/prefs/SourceSettings.kt
@@ -3,6 +3,7 @@ package io.github.landwarderer.futon.core.prefs
import android.content.Context
import android.content.SharedPreferences.OnSharedPreferenceChangeListener
import androidx.core.content.edit
+import androidx.preference.PreferenceManager
import io.github.landwarderer.futon.core.util.ext.getEnumValue
import io.github.landwarderer.futon.core.util.ext.putEnumValue
import io.github.landwarderer.futon.core.util.ext.sanitizeHeaderValue
@@ -17,6 +18,8 @@ import java.io.File
class SourceSettings(context: Context, source: MangaSource) : MangaSourceConfig {
+ private val appContext = context.applicationContext
+
private val prefs = context.getSharedPreferences(
source.name.replace(File.separatorChar, '$'),
Context.MODE_PRIVATE,
@@ -32,6 +35,38 @@ class SourceSettings(context: Context, source: MangaSource) : MangaSourceConfig
val isCaptchaNotificationsDisabled: Boolean
get() = prefs.getBoolean(KEY_NO_CAPTCHA, false)
+ /**
+ * Automatic solving is experimental and opt-in: it stays off unless it is enabled globally,
+ * and can still be turned off for a single source.
+ */
+ val isCaptchaAutoResolveDisabled: Boolean
+ get() = !PreferenceManager.getDefaultSharedPreferences(appContext)
+ .getBoolean(AppSettings.KEY_CAPTCHA_AUTO_SOLVE, false) ||
+ prefs.getBoolean(KEY_NO_AUTO_CAPTCHA, false)
+
+ /**
+ * The User-Agent that earned this source's current `cf_clearance` cookie.
+ *
+ * Cloudflare only honours a clearance for the exact agent it was issued to, and the challenge can
+ * only be solved by a WebView presenting an agent consistent with its own engine. Parsers that pin
+ * an inconsistent (e.g. hard-coded desktop) agent in `getRequestHeaders()` would otherwise stay
+ * blocked no matter how many times the challenge is solved. Set by the solver, applied by
+ * `CommonHeadersInterceptor`; null means the parser's own agent is fine.
+ *
+ * Recorded together with the user's own User-Agent setting at that moment: once the user changes
+ * that setting, their choice wins again and the stored agent is ignored until the next solve.
+ */
+ var cloudFlareUserAgent: String?
+ get() {
+ val value = prefs.getString(KEY_CF_USER_AGENT, null)?.nullIfEmpty() ?: return null
+ val base = prefs.getString(KEY_CF_USER_AGENT_BASE, null).orEmpty()
+ return value.takeIf { base == prefs.getString(KEY_USER_AGENT, null).orEmpty() }
+ }
+ set(value) = prefs.edit {
+ putString(KEY_CF_USER_AGENT, value?.sanitizeHeaderValue())
+ putString(KEY_CF_USER_AGENT_BASE, prefs.getString(KEY_USER_AGENT, null).orEmpty())
+ }
+
@Suppress("UNCHECKED_CAST")
override fun get(key: ConfigKey): T {
return when (key) {
@@ -78,7 +113,11 @@ class SourceSettings(context: Context, source: MangaSource) : MangaSourceConfig
const val KEY_DOMAIN = "domain"
const val KEY_NO_CAPTCHA = "no_captcha"
+ const val KEY_NO_AUTO_CAPTCHA = "no_auto_captcha"
const val KEY_SLOWDOWN = "slowdown"
const val KEY_SORT_ORDER = "sort_order"
+ const val KEY_CF_USER_AGENT = "cf_user_agent"
+ const val KEY_CF_USER_AGENT_BASE = "cf_user_agent_base"
+ private const val KEY_USER_AGENT = "user_agent" // ConfigKey.UserAgent
}
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/prefs/TrackerDownloadStrategy.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/prefs/TrackerDownloadStrategy.kt
index 6ac27fcb5c..2dfbb46cb1 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/prefs/TrackerDownloadStrategy.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/prefs/TrackerDownloadStrategy.kt
@@ -5,5 +5,39 @@ import androidx.annotation.Keep
@Keep
enum class TrackerDownloadStrategy {
- DISABLED, DOWNLOADED;
+ /** Never download new chapters automatically. */
+ DISABLED,
+
+ /**
+ * Only for manga that already has chapters saved locally.
+ *
+ * Note this keys off downloaded files, not reading: a series read online never qualifies, and one
+ * whose read chapters were cleaned up silently stops qualifying.
+ */
+ DOWNLOADED,
+
+ /**
+ * For manga opened within [RECENT_READ_WINDOW_DAYS], whether or not anything is saved locally.
+ *
+ * "Have I read this lately" is the honest proxy for "do I still care about this", so a short break
+ * from a series keeps working while one abandoned months ago stops downloading on its own.
+ */
+ RECENTLY_READ,
+
+ ;
+
+ companion object {
+
+ /** How recently a manga must have been read to count for [RECENTLY_READ]. */
+ const val RECENT_READ_WINDOW_DAYS = 30L
+
+ /**
+ * Newest chapters downloaded per manga per run. A dormant series that suddenly backfills its
+ * archive would otherwise fill the device in a single tick.
+ */
+ const val MAX_CHAPTERS_PER_RUN = 5
+
+ /** Auto-download is skipped below this much free space. */
+ const val MIN_FREE_SPACE_BYTES = 2L * 1024 * 1024 * 1024
+ }
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/ui/BaseActivity.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/ui/BaseActivity.kt
index bfaa72c7ae..8e331865bd 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/ui/BaseActivity.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/ui/BaseActivity.kt
@@ -60,36 +60,46 @@ abstract class BaseActivity :
super.attachBaseContext(newBase)
}
+ /**
+ * If true (default), apply the app's color-scheme theme overlay on top of the manifest theme.
+ * Override to false for activities whose manifest theme must be preserved as-is.
+ */
+ protected open val applyColorSchemeTheme: Boolean = true
+
override fun onCreate(savedInstanceState: Bundle?) {
val settings = entryPoint.settings
isAmoledTheme = settings.isAmoledTheme
- val importedTheme = settings.selectedCustomTheme.takeIf {
- settings.colorScheme == ColorScheme.CUSTOM && DynamicColors.isDynamicColorAvailable()
- }
- val colorScheme = when {
- importedTheme == null && settings.colorScheme == ColorScheme.CUSTOM -> ColorScheme.default
- else -> settings.colorScheme
- }
- setTheme(colorScheme.styleResId)
- if (importedTheme != null) {
- val isNightMode = (resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES
- setTheme(
- if (isNightMode) R.style.ThemeOverlay_Futon_Custom_Dark
- else R.style.ThemeOverlay_Futon_Custom_Light,
- )
- DynamicColors.applyToActivityIfAvailable(
- this,
- DynamicColorsOptions.Builder()
- .setContentBasedSource(importedTheme.primaryColor)
- .build(),
- )
- }
- if (isAmoledTheme) {
- setTheme(R.style.ThemeOverlay_Futon_Amoled)
+ if (applyColorSchemeTheme) {
+ val importedTheme = settings.selectedCustomTheme.takeIf {
+ settings.colorScheme == ColorScheme.CUSTOM && DynamicColors.isDynamicColorAvailable()
+ }
+ val colorScheme = when {
+ importedTheme == null && settings.colorScheme == ColorScheme.CUSTOM -> ColorScheme.default
+ else -> settings.colorScheme
+ }
+ setTheme(colorScheme.styleResId)
+ if (importedTheme != null) {
+ val isNightMode = (resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES
+ setTheme(
+ if (isNightMode) R.style.ThemeOverlay_Futon_Custom_Dark
+ else R.style.ThemeOverlay_Futon_Custom_Light,
+ )
+ DynamicColors.applyToActivityIfAvailable(
+ this,
+ DynamicColorsOptions.Builder()
+ .setContentBasedSource(importedTheme.primaryColor)
+ .build(),
+ )
+ }
+ if (isAmoledTheme) {
+ setTheme(R.style.ThemeOverlay_Futon_Amoled)
+ }
}
putDataToExtras(intent)
exceptionResolver = entryPoint.exceptionResolverFactory.create(this)
- enableEdgeToEdge()
+ if (applyColorSchemeTheme) {
+ enableEdgeToEdge()
+ }
super.onCreate(savedInstanceState)
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/ui/util/ForegroundActivityHolder.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/ui/util/ForegroundActivityHolder.kt
new file mode 100644
index 0000000000..c11f5b2b26
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/ui/util/ForegroundActivityHolder.kt
@@ -0,0 +1,31 @@
+package io.github.landwarderer.futon.core.ui.util
+
+import android.app.Activity
+import io.github.landwarderer.futon.core.ui.DefaultActivityLifecycleCallbacks
+import java.lang.ref.WeakReference
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Tracks the currently resumed Activity, so the automatic CloudFlare solver can be started on top of
+ * the screen the user is looking at instead of in a new task.
+ */
+@Singleton
+class ForegroundActivityHolder @Inject constructor() : DefaultActivityLifecycleCallbacks {
+
+ @Volatile
+ private var activityRef: WeakReference? = null
+
+ val current: Activity?
+ get() = activityRef?.get()?.takeUnless { it.isFinishing || it.isDestroyed }
+
+ override fun onActivityResumed(activity: Activity) {
+ activityRef = WeakReference(activity)
+ }
+
+ override fun onActivityPaused(activity: Activity) {
+ if (activityRef?.get() === activity) {
+ activityRef = null
+ }
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/util/MimeTypes.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/util/MimeTypes.kt
index e3060dd1c7..74b179d60a 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/util/MimeTypes.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/util/MimeTypes.kt
@@ -14,16 +14,31 @@ import coil3.util.MimeTypeMap as CoilMimeTypeMap
object MimeTypes {
+ // Neither Coil's table nor the platform's knows JPEG XL. Without this, .jxl pages are not
+ // recognised as images in local archives, and downloaded ones are saved without an extension.
+ private const val EXTENSION_JXL = "jxl"
+ val JXL = MimeType("image/jxl")
+
fun getMimeTypeFromExtension(fileName: String): MimeType? {
- return CoilMimeTypeMap.getMimeTypeFromExtension(getNormalizedExtension(fileName) ?: return null)
- ?.toMimeTypeOrNull()
+ val extension = getNormalizedExtension(fileName) ?: return null
+ if (extension == EXTENSION_JXL) {
+ return JXL
+ }
+ return CoilMimeTypeMap.getMimeTypeFromExtension(extension)?.toMimeTypeOrNull()
}
fun getMimeTypeFromUrl(url: String): MimeType? {
+ val fileName = url.substringBefore('#').substringBefore('?').substringAfterLast('/')
+ if (getNormalizedExtension(fileName) == EXTENSION_JXL) {
+ return JXL
+ }
return CoilMimeTypeMap.getMimeTypeFromUrl(url)?.toMimeTypeOrNull()
}
fun getExtension(mimeType: MimeType?): String? {
+ if (mimeType == JXL) {
+ return EXTENSION_JXL
+ }
return MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType?.toString() ?: return null)?.nullIfEmpty()
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/util/ext/Preferences.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/util/ext/Preferences.kt
index 2fc4164a64..a59ccb55f4 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/util/ext/Preferences.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/util/ext/Preferences.kt
@@ -63,6 +63,7 @@ fun SharedPreferences.Editor.putAll(values: Map) {
is Int -> putInt(e.key, v)
is Long -> putLong(e.key, v)
is Float -> putFloat(e.key, v)
+ is Double -> putFloat(e.key, v.toFloat())
is String -> putString(e.key, v)
is JSONArray -> putStringSet(e.key, v.toStringSet())
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/core/util/ext/Throwable.kt b/app/src/main/kotlin/io/github/landwarderer/futon/core/util/ext/Throwable.kt
index 20b2b7e36e..89ab64e0a2 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/core/util/ext/Throwable.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/core/util/ext/Throwable.kt
@@ -21,6 +21,7 @@ import io.github.landwarderer.futon.R
import io.github.landwarderer.futon.core.exceptions.BadBackupFormatException
import io.github.landwarderer.futon.core.exceptions.CaughtException
import io.github.landwarderer.futon.core.exceptions.CloudFlareBlockedException
+import io.github.landwarderer.futon.core.exceptions.CloudFlareException
import io.github.landwarderer.futon.core.exceptions.CloudFlareProtectedException
import io.github.landwarderer.futon.core.exceptions.EmptyHistoryException
import io.github.landwarderer.futon.core.exceptions.EmptyMangaException
@@ -159,6 +160,31 @@ fun Throwable.getDisplayIcon(): Int = when (this) {
else -> R.drawable.ic_error_large
}
+/**
+ * Whether this error (or any of its causes) means the manga itself is missing from its source.
+ * Deliberately narrower than [getDisplayMessage]'s 404 mapping, so callers can offer to look for
+ * the title on another source.
+ */
+fun Throwable.isContentNotFound(): Boolean = generateSequence(this) { it.cause?.takeIf { c -> c !== it } }
+ .take(32)
+ .any { e ->
+ when (e) {
+ is NotFoundException,
+ is ContentUnavailableException -> true
+
+ is HttpException -> e.response.code == HttpURLConnection.HTTP_NOT_FOUND
+ is HttpStatusException -> e.statusCode == HttpURLConnection.HTTP_NOT_FOUND
+ is eu.kanade.tachiyomi.network.HttpException -> e.code == HttpURLConnection.HTTP_NOT_FOUND
+ else -> false
+ }
+ }
+
+/** Walks the exception cause chain and returns the first [CloudFlareException] found, or `null`. */
+fun Throwable.findCloudFlareException(): CloudFlareException? =
+ generateSequence(this) { it.cause?.takeIf { c -> c !== it } }
+ .filterIsInstance()
+ .firstOrNull()
+
fun Throwable.getCauseUrl(): String? = when (this) {
is ParseException -> url
is NotFoundException -> url
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/details/domain/ProgressUpdateUseCase.kt b/app/src/main/kotlin/io/github/landwarderer/futon/details/domain/ProgressUpdateUseCase.kt
index c4b1893322..b7dfb800a0 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/details/domain/ProgressUpdateUseCase.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/details/domain/ProgressUpdateUseCase.kt
@@ -2,9 +2,12 @@ package io.github.landwarderer.futon.details.domain
import androidx.room.withTransaction
import io.github.landwarderer.futon.core.db.MangaDatabase
+import io.github.landwarderer.futon.core.model.getPreferredBranch
import io.github.landwarderer.futon.core.model.isLocal
import io.github.landwarderer.futon.core.os.NetworkState
import io.github.landwarderer.futon.core.parser.MangaRepository
+import io.github.landwarderer.futon.history.data.HistoryEntity
+import io.github.landwarderer.futon.list.domain.ReadingProgress
import io.github.landwarderer.futon.list.domain.ReadingProgress.Companion.PROGRESS_NONE
import io.github.landwarderer.futon.local.data.LocalMangaRepository
import org.koitharu.kotatsu.parsers.model.Manga
@@ -33,7 +36,8 @@ class ProgressUpdateUseCase @Inject constructor(
} else {
seed
}
- val chapter = details.findChapterById(history.chapterId) ?: return PROGRESS_NONE
+ val chapter = details.findChapterById(history.chapterId)
+ ?: return estimateFromCounts(manga, details, history)
val chapters = details.getChapters(chapter.branch)
val chapterRepo = if (repo.source == chapter.source) {
repo
@@ -52,19 +56,62 @@ class ProgressUpdateUseCase @Inject constructor(
val pagePercent = (history.page + 1) / pagesCount.toFloat()
val ppc = 1f / chaptersCount
val result = ppc * chapterIndex + ppc * pagePercent
+ // history.chaptersCount is the chapter count at the reader's last save: smart resume relies on it
+ // to tell that the saved chapter was the latest one, so only the reader may change it.
if (result != history.percent) {
- database.withTransaction {
- // Loading metadata may outlive a newer reader save. Never restore that stale snapshot.
- if (database.getHistoryDao().find(manga.id) == history) {
- database.getHistoryDao().update(
- history.copy(
- chapterId = chapter.id,
- percent = result,
- ),
- )
- }
- }
+ updateIfUnchanged(
+ manga = manga,
+ history = history,
+ newHistory = history.copy(
+ chapterId = chapter.id,
+ percent = result,
+ ),
+ )
}
return result
}
+
+ /**
+ * Fallback when the stored history chapter id is no longer present in the fresh details
+ * (e.g. the source rotated chapter URLs, which changes derived ids). We can't pinpoint the
+ * reading position anymore, so we estimate it from the previously stored counts: roughly
+ * `percent * oldTotal` chapters were read, rescaled to the new total. The read position
+ * itself is not touched.
+ *
+ * The rescale may only ever move progress *down*: the stored count and the new total are not
+ * guaranteed to describe the same branch, and with only a few chapters in the new total almost
+ * any stored percent would clamp to 1.0 and mark the manga completed. A guess must never claim
+ * a completion the user never reached.
+ */
+ private suspend fun estimateFromCounts(manga: Manga, details: Manga, history: HistoryEntity): Float {
+ val newTotal = details.getChapters(details.getPreferredBranch(null)).size
+ .takeIf { it > 0 } ?: details.chapters?.size ?: 0
+ if (newTotal == 0 || history.chaptersCount <= 0 || !ReadingProgress.isValid(history.percent)) {
+ return PROGRESS_NONE
+ }
+ val estimated = if (ReadingProgress.isCompleted(history.percent)) {
+ // Genuinely finished before the ids rotated: stay finished.
+ history.percent
+ } else {
+ // Gaining chapters legitimately lowers progress; losing them may not raise it.
+ (history.percent * history.chaptersCount / newTotal).coerceIn(0f, history.percent)
+ }
+ if (estimated != history.percent || history.chaptersCount != newTotal) {
+ updateIfUnchanged(
+ manga = manga,
+ history = history,
+ newHistory = history.copy(percent = estimated, chaptersCount = newTotal),
+ )
+ }
+ return estimated
+ }
+
+ private suspend fun updateIfUnchanged(manga: Manga, history: HistoryEntity, newHistory: HistoryEntity) {
+ database.withTransaction {
+ // Loading metadata may outlive a newer reader save. Never restore that stale snapshot.
+ if (database.getHistoryDao().find(manga.id) == history) {
+ database.getHistoryDao().update(newHistory)
+ }
+ }
+ }
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/details/domain/RelatedMangaUseCase.kt b/app/src/main/kotlin/io/github/landwarderer/futon/details/domain/RelatedMangaUseCase.kt
index 46c33d3d8f..868adcb61a 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/details/domain/RelatedMangaUseCase.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/details/domain/RelatedMangaUseCase.kt
@@ -1,18 +1,156 @@
package io.github.landwarderer.futon.details.domain
+import io.github.landwarderer.futon.core.model.isNsfw
+import io.github.landwarderer.futon.core.parser.MangaDataRepository
import io.github.landwarderer.futon.core.parser.MangaRepository
+import io.github.landwarderer.futon.core.prefs.AppSettings
import io.github.landwarderer.futon.core.util.ext.printStackTraceDebug
+import io.github.landwarderer.futon.mihon.MihonMangaRepository
+import io.github.landwarderer.futon.suggestions.domain.SuggestionRanking
+import io.github.landwarderer.futon.suggestions.domain.SuggestionRepository
+import io.github.landwarderer.futon.suggestions.domain.TagStatistics
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaListFilter
+import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.parsers.model.SortOrder
import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
import javax.inject.Inject
+/**
+ * What to read next, given this manga - for every manga, not only the ones the source links.
+ *
+ * The source's own related list comes first. Plenty of parsers link nothing, so when it comes up
+ * short the row is filled from this manga's tags: first the reader's own stored suggestions that
+ * share them, which costs nothing, then one search of this manga's source for its least common tags.
+ */
class RelatedMangaUseCase @Inject constructor(
private val mangaRepositoryFactory: MangaRepository.Factory,
+ private val suggestionRepository: SuggestionRepository,
+ private val dataRepository: MangaDataRepository,
+ private val tagStatistics: TagStatistics,
+ private val settings: AppSettings,
) {
- suspend operator fun invoke(seed: Manga) = runCatchingCancellable {
+ suspend operator fun invoke(seed: Manga): List? = coroutineScope {
+ val excludeNsfw = settings.isNsfwContentDisabled
+ val blacklist = settings.tagsBlacklist.mapTo(HashSet(), SuggestionRanking::normalizeTag)
+ val sourceJob = async { sourceRelated(seed) }
+ val stored = runCatchingCancellable { suggestionRepository.getTopList(MAX_STORED) }
+ .onFailure { it.printStackTraceDebug("RelatedMangaUseCase::stored") }
+ .getOrDefault(emptyList())
+
+ val picked = LinkedHashMap()
+ fun add(list: List) = list.forEach {
+ if (it.id != seed.id && !(excludeNsfw && it.isNsfw()) && !it.isBlacklisted(blacklist)) {
+ picked.putIfAbsent(it.id, it)
+ }
+ }
+ add(sourceJob.await().orEmpty())
+ if (picked.size >= MIN_RESULTS) {
+ return@coroutineScope picked.values.take(LIMIT)
+ }
+ // The details may not have loaded - a source behind a challenge, offline - and then the manga
+ // carries no tags; the ones stored when it last loaded are just as good for this.
+ val tagged = if (seed.tags.isEmpty()) {
+ runCatchingCancellable { dataRepository.findMangaById(seed.id, withChapters = false) }
+ .getOrNull()?.takeIf { it.tags.isNotEmpty() } ?: seed
+ } else {
+ seed
+ }
+ // Blacklisted tags say nothing the reader wants more of, so they are never matched on.
+ val seedTags = tagged.tags.filterNot { SuggestionRanking.normalizeTag(it.title) in blacklist }
+ if (seedTags.isEmpty()) {
+ return@coroutineScope picked.values.take(LIMIT).ifEmpty { null }
+ }
+ val rarity = runCatchingCancellable { tagStatistics.snapshot() }.getOrNull()
+ ?.let { snapshot -> { title: String -> snapshot.rarity(title) } }
+ ?: { _: String -> 1.0 }
+ add(likeByTags(seedTags, stored, rarity))
+ if (picked.size < MIN_RESULTS) {
+ add(sourceByTags(tagged, seedTags, rarity))
+ }
+ picked.values.take(LIMIT).ifEmpty { null }
+ }
+
+ private suspend fun sourceRelated(seed: Manga): List? = runCatchingCancellable {
mangaRepositoryFactory.create(seed.source).getRelated(seed)
- }.onFailure {
- it.printStackTraceDebug("RelatedMangaUseCase::invoke")
- }.getOrNull()
+ }.onFailure { it.printStackTraceDebug("RelatedMangaUseCase::sourceRelated") }.getOrNull()
+
+ /**
+ * The reader's stored suggestions that share this manga's tags, closest first - already
+ * resolved and on the device, so no request at all. Closeness weighs each shared tag by how
+ * rare it is, so sharing `villainess` beats sharing `action`.
+ */
+ private fun likeByTags(seedTags: Collection, stored: List, rarity: (String) -> Double): List {
+ val seedTitles = seedTags.titles()
+ // One shared tag is a coincidence unless the manga has hardly any
+ val minShared = if (seedTitles.size <= 2) 1 else 2
+ return stored.mapNotNull { manga ->
+ val tags = manga.tags.titles()
+ if (tags.count { it in seedTitles } < minShared) {
+ null
+ } else {
+ manga to SuggestionRanking.weightedOverlap(seedTitles, tags, rarity)
+ }
+ }.sortedByDescending { it.second }
+ .map { it.first }
+ .take(LIMIT)
+ }
+
+ /**
+ * One search of this manga's own source for its rarest tags.
+ *
+ * Tags are matched against the source's own filter tags by title, so this also works for sources
+ * whose details tags are not usable as filters (extension sources), and never searches with no
+ * tag at all - that would be the source's whole catalogue. Never sorted by popularity first.
+ */
+ private suspend fun sourceByTags(
+ seed: Manga,
+ seedTags: Collection,
+ rarity: (String) -> Double,
+ ): List = runCatchingCancellable {
+ val repository = mangaRepositoryFactory.create(seed.source)
+ if (repository is MihonMangaRepository) {
+ // Its list paging is stateful and the instance is shared, so a background search here
+ // would make the source list the reader came from skip or repeat a page.
+ return@runCatchingCancellable emptyList()
+ }
+ val available = repository.getFilterOptions().availableTags
+ .associateBy { SuggestionRanking.normalizeTag(it.title) }
+ val byRarity = seedTags.sortedByDescending { rarity(it.title) }
+ .mapNotNull { available[SuggestionRanking.normalizeTag(it.title)] }
+ .distinct()
+ val first = byRarity.firstOrNull() ?: return@runCatchingCancellable emptyList()
+ val order = PREFERRED_ORDERS.firstOrNull { it in repository.sortOrders }
+ val seedTitles = seedTags.titles()
+ val tagCount = if (repository.filterCapabilities.isMultipleTagsSupported) 2 else 1
+ var found = repository.getList(0, order, MangaListFilter(tags = byRarity.take(tagCount).toSet()))
+ if (found.none { it.id != seed.id } && byRarity.size > 1 && tagCount > 1) {
+ // Two rare tags together can match nothing but the manga itself
+ found = repository.getList(0, order, MangaListFilter(tags = setOf(first)))
+ }
+ found.filter { it.id != seed.id }
+ .sortedByDescending { SuggestionRanking.weightedOverlap(seedTitles, it.tags.titles(), rarity) }
+ .take(LIMIT)
+ }.onFailure { it.printStackTraceDebug("RelatedMangaUseCase::sourceByTags") }.getOrDefault(emptyList())
+
+ private fun Collection.titles(): Set = mapTo(HashSet()) { SuggestionRanking.normalizeTag(it.title) }
+
+ private fun Manga.isBlacklisted(blacklist: Set): Boolean =
+ blacklist.isNotEmpty() && tags.any { SuggestionRanking.normalizeTag(it.title) in blacklist }
+
+ private companion object {
+ const val LIMIT = 20
+
+ /** Fewer than this and the row looks empty, so the next source of answers is asked too. */
+ const val MIN_RESULTS = 4
+
+ /** The reader's suggestions to match tags against; they are stored best first. */
+ const val MAX_STORED = 200
+
+ /** Anything but popularity, which would hand back the same best-sellers for every manga. */
+ val PREFERRED_ORDERS = listOf(SortOrder.UPDATED, SortOrder.NEWEST, SortOrder.RATING, SortOrder.POPULARITY)
+ }
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/DetailsErrorObserver.kt b/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/DetailsErrorObserver.kt
index 6da34dacfa..925378328e 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/DetailsErrorObserver.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/DetailsErrorObserver.kt
@@ -1,20 +1,30 @@
package io.github.landwarderer.futon.details.ui
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
import com.google.android.material.snackbar.Snackbar
import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.alternatives.ui.MangaUnavailableDialog
+import io.github.landwarderer.futon.core.exceptions.CloudFlareProtectedException
import io.github.landwarderer.futon.core.exceptions.UnsupportedSourceException
import io.github.landwarderer.futon.core.exceptions.resolve.ErrorObserver
import io.github.landwarderer.futon.core.exceptions.resolve.ExceptionResolver
+import io.github.landwarderer.futon.core.model.isLocal
+import io.github.landwarderer.futon.core.nav.router
+import io.github.landwarderer.futon.core.prefs.SourceSettings
+import io.github.landwarderer.futon.core.util.ext.findCloudFlareException
import io.github.landwarderer.futon.core.util.ext.getDisplayMessage
+import io.github.landwarderer.futon.core.util.ext.isContentNotFound
import io.github.landwarderer.futon.core.util.ext.isNetworkError
import io.github.landwarderer.futon.core.util.ext.isSerializable
import org.koitharu.kotatsu.parsers.exception.NotFoundException
import org.koitharu.kotatsu.parsers.exception.ParseException
+import org.koitharu.kotatsu.parsers.model.Manga
class DetailsErrorObserver(
override val activity: DetailsActivity,
private val viewModel: DetailsViewModel,
- resolver: ExceptionResolver?,
+ private val resolver: ExceptionResolver?,
) : ErrorObserver(
activity.viewBinding.scrollView, null, resolver,
{ isResolved ->
@@ -24,7 +34,44 @@ class DetailsErrorObserver(
},
) {
+ private var unavailableDialog: MangaUnavailableDialog? = null
+
+ init {
+ // The prompt is an activity-hosted dialog, so it has to go down with the activity.
+ activity.lifecycle.addObserver(
+ object : DefaultLifecycleObserver {
+ override fun onDestroy(owner: LifecycleOwner) {
+ unavailableDialog?.dismiss()
+ unavailableDialog = null
+ }
+ },
+ )
+ }
+
+ private var isAutoResolveAttempted = false
+
override suspend fun emit(value: Throwable) {
+ // A title that is gone from its source is a dead end, so ask up front whether
+ // to go looking for it on another source.
+ val missingManga = viewModel.getMangaOrNull()?.takeIf { !it.isLocal && value.isContentNotFound() }
+ if (missingManga != null && showUnavailableDialog(missingManga)) {
+ return
+ }
+ // Opening a manga is an explicit user action, so a silent captcha solve is appropriate. Only once per
+ // screen: if the source is still protected after that, the snackbar with the manual "Solve" follows.
+ val cf = value.findCloudFlareException()
+ if (
+ cf is CloudFlareProtectedException &&
+ resolver != null &&
+ !isAutoResolveAttempted &&
+ !SourceSettings(host.context, cf.source).isCaptchaAutoResolveDisabled
+ ) {
+ isAutoResolveAttempted = true
+ if (resolver.resolve(cf, tryAutoResolve = true)) {
+ viewModel.reload()
+ return
+ }
+ }
val snackbar = Snackbar.make(host, value.getDisplayMessage(host.context.resources), Snackbar.LENGTH_SHORT)
snackbar.setAnchorView(activity.viewBinding.containerBottomSheet)
if (value is NotFoundException || value is UnsupportedSourceException) {
@@ -54,4 +101,23 @@ class DetailsErrorObserver(
}
snackbar.show()
}
+
+ /**
+ * @return `true` if the prompt is on screen and the caller should not show anything else.
+ * A dialog that is already up is left alone: reloads re-emit the same error.
+ */
+ private fun showUnavailableDialog(manga: Manga): Boolean {
+ if (unavailableDialog?.isShowing == true) {
+ return true
+ }
+ if (activity.isDestroyed || activity.isFinishing) {
+ return false
+ }
+ val router = activity.router
+ unavailableDialog = MangaUnavailableDialog.Builder(activity, manga)
+ .setOnAlternativesClickListener { router.openAlternatives(manga) }
+ .create()
+ .also { it.show() }
+ return true
+ }
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/DetailsMenuProvider.kt b/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/DetailsMenuProvider.kt
index bf5ecf08cf..91562a25aa 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/DetailsMenuProvider.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/DetailsMenuProvider.kt
@@ -49,6 +49,7 @@ class DetailsMenuProvider(
menu.findItem(R.id.action_delete).isVisible = mangaDetails?.local != null
menu.findItem(R.id.action_browser).isVisible = manga?.publicUrl?.isHttpUrl() == true
menu.findItem(R.id.action_alternatives).isVisible = manga?.source != LocalMangaSource
+ menu.findItem(R.id.action_replace_source).isVisible = manga?.source != LocalMangaSource
menu.findItem(R.id.action_shortcut).isVisible = ShortcutManagerCompat.isRequestPinShortcutSupported(activity)
menu.findItem(R.id.action_scrobbling).isVisible = viewModel.isScrobblingAvailable
menu.findItem(R.id.action_online).isVisible = viewModel.remoteManga.value != null
@@ -91,6 +92,10 @@ class DetailsMenuProvider(
router.openAlternatives(manga)
}
+ R.id.action_replace_source -> {
+ router.openSourceReplacement(listOf(manga))
+ }
+
R.id.action_stats -> {
router.showStatisticSheet(manga)
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/DetailsViewModel.kt b/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/DetailsViewModel.kt
index 161ca9482b..03dc2af224 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/DetailsViewModel.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/DetailsViewModel.kt
@@ -6,6 +6,7 @@ import dagger.hilt.android.lifecycle.HiltViewModel
import io.github.landwarderer.futon.R
import io.github.landwarderer.futon.bookmarks.domain.BookmarksRepository
import io.github.landwarderer.futon.core.model.getPreferredBranch
+import io.github.landwarderer.futon.core.model.isNsfw
import io.github.landwarderer.futon.core.nav.MangaIntent
import io.github.landwarderer.futon.core.prefs.AppSettings
import io.github.landwarderer.futon.core.prefs.ListMode
@@ -13,7 +14,6 @@ import io.github.landwarderer.futon.core.prefs.TriStateOption
import io.github.landwarderer.futon.core.ui.util.ReversibleAction
import io.github.landwarderer.futon.core.util.ext.call
import io.github.landwarderer.futon.core.util.ext.computeSize
-import io.github.landwarderer.futon.core.util.ext.onEachWhile
import io.github.landwarderer.futon.details.data.MangaDetails
import io.github.landwarderer.futon.details.domain.BranchComparator
import io.github.landwarderer.futon.details.domain.DetailsInteractor
@@ -154,8 +154,15 @@ class DetailsViewModel @Inject constructor(
val relatedManga: StateFlow> = manga.mapLatest {
if (it != null && settings.isRelatedMangaEnabled) {
+ val related = relatedMangaUseCase(it).orEmpty().let { list ->
+ if (settings.isNsfwContentDisabled) {
+ list.filterNot { manga -> manga.isNsfw() }
+ } else {
+ list
+ }
+ }
mangaListMapper.toListModelList(
- manga = relatedMangaUseCase(it).orEmpty(),
+ manga = related,
mode = ListMode.GRID,
)
} else {
@@ -239,22 +246,34 @@ class DetailsViewModel @Inject constructor(
}
private fun doLoad(force: Boolean) = launchLoadingJob(Dispatchers.IO) {
+ var defaultBranch: DefaultBranch? = null
detailsLoadUseCase.invoke(intent, force)
- .onEachWhile {
- if (it.allChapters.isNotEmpty()) {
+ .onEach {
+ if (it.allChapters.isEmpty()) {
+ return@onEach
+ }
+ // The first list is usually the stored one, then comes the one just loaded from the source. Pick the
+ // default branch again when the one picked from the stored list is not in the new one (the source
+ // renamed its branches), or when it was not picked from the history and the user has kept it.
+ val picked = defaultBranch
+ val current = selectedBranch.value
+ if (picked == null || current !in it.chapters || (current == picked.name && !picked.isFromHistory)) {
val manga = it.toManga()
- // find default branch
val hist = historyRepository.getOne(manga)
- selectedBranch.value = manga.getPreferredBranch(hist)
- true
- } else {
- false
+ val branch = manga.getPreferredBranch(hist)
+ selectedBranch.value = branch
+ defaultBranch = DefaultBranch(
+ name = branch,
+ isFromHistory = hist != null && manga.findChapterById(hist.chapterId) != null,
+ )
}
}.collect {
mangaDetails.value = it
}
}
+ private class DefaultBranch(val name: String?, val isFromHistory: Boolean)
+
private fun getScrobbler(index: Int): Scrobbler? {
val info = scrobblingInfo.value.getOrNull(index)
val scrobbler = if (info != null) {
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/pager/bookmarks/BookmarksViewModel.kt b/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/pager/bookmarks/BookmarksViewModel.kt
index 4ebd2ce81c..da9701534d 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/pager/bookmarks/BookmarksViewModel.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/pager/bookmarks/BookmarksViewModel.kt
@@ -51,7 +51,7 @@ class BookmarksViewModel @Inject constructor(
.map { mapList(m, it) }
}.withErrorHandling()
.filterNotNull()
- .stateIn(viewModelScope + Dispatchers.IO, SharingStarted.Lazily, listOf(LoadingState))
+ .stateIn(viewModelScope + Dispatchers.IO, SharingStarted.Lazily, listOf(LoadingState()))
override suspend fun emit(value: MangaDetails?) {
manga.value = value?.toManga()
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/related/RelatedListViewModel.kt b/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/related/RelatedListViewModel.kt
index 5ce22c9f47..9042afd9c0 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/related/RelatedListViewModel.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/details/ui/related/RelatedListViewModel.kt
@@ -7,11 +7,11 @@ import io.github.landwarderer.futon.R
import io.github.landwarderer.futon.core.model.parcelable.ParcelableManga
import io.github.landwarderer.futon.core.nav.AppRouter
import io.github.landwarderer.futon.core.parser.MangaDataRepository
-import io.github.landwarderer.futon.core.parser.MangaRepository
import io.github.landwarderer.futon.core.prefs.AppSettings
import io.github.landwarderer.futon.core.util.ext.call
import io.github.landwarderer.futon.core.util.ext.printStackTraceDebug
import io.github.landwarderer.futon.core.util.ext.require
+import io.github.landwarderer.futon.details.domain.RelatedMangaUseCase
import io.github.landwarderer.futon.list.domain.MangaListMapper
import io.github.landwarderer.futon.list.ui.MangaListViewModel
import io.github.landwarderer.futon.list.ui.model.EmptyState
@@ -34,15 +34,14 @@ import javax.inject.Inject
@HiltViewModel
class RelatedListViewModel @Inject constructor(
savedStateHandle: SavedStateHandle,
- mangaRepositoryFactory: MangaRepository.Factory,
settings: AppSettings,
+ private val relatedMangaUseCase: RelatedMangaUseCase,
private val mangaListMapper: MangaListMapper,
mangaDataRepository: MangaDataRepository,
@LocalStorageChanges localStorageChanges: SharedFlow,
) : MangaListViewModel(settings, mangaDataRepository, localStorageChanges) {
private val seed = savedStateHandle.require(AppRouter.KEY_MANGA).manga
- private val repository = mangaRepositoryFactory.create(seed.source)
private val mangaList = MutableStateFlow?>(null)
private val listError = MutableStateFlow(null)
private var loadingJob: Job? = null
@@ -54,11 +53,11 @@ class RelatedListViewModel @Inject constructor(
) { list, mode, error ->
when {
list.isNullOrEmpty() && error != null -> listOf(error.toErrorState(canRetry = true))
- list == null -> listOf(LoadingState)
+ list == null -> listOf(LoadingState())
list.isEmpty() -> listOf(createEmptyState())
else -> mangaListMapper.toListModelList(list, mode)
}
- }.stateIn(viewModelScope + Dispatchers.IO, SharingStarted.Eagerly, listOf(LoadingState))
+ }.stateIn(viewModelScope + Dispatchers.IO, SharingStarted.Eagerly, listOf(LoadingState()))
init {
loadList()
@@ -79,7 +78,8 @@ class RelatedListViewModel @Inject constructor(
return launchLoadingJob(Dispatchers.IO) {
try {
listError.value = null
- mangaList.value = repository.getRelated(seed)
+ // Same path as the details screen row: the source's own related list, then tag matches.
+ mangaList.value = relatedMangaUseCase(seed).orEmpty()
} catch (e: CancellationException) {
throw e
} catch (e: Throwable) {
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/download/ui/list/DownloadsViewModel.kt b/app/src/main/kotlin/io/github/landwarderer/futon/download/ui/list/DownloadsViewModel.kt
index 1ce9471ee8..4b2cbe1bdf 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/download/ui/list/DownloadsViewModel.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/download/ui/list/DownloadsViewModel.kt
@@ -80,8 +80,8 @@ class DownloadsViewModel @Inject constructor(
val onActionDone = MutableEventFlow()
val items = works.map {
- it?.toUiList() ?: listOf(LoadingState)
- }.stateIn(viewModelScope + Dispatchers.IO, SharingStarted.Eagerly, listOf(LoadingState))
+ it?.toUiList() ?: listOf(LoadingState())
+ }.stateIn(viewModelScope + Dispatchers.IO, SharingStarted.Eagerly, listOf(LoadingState()))
val hasPausedWorks = works.map {
it?.any { x -> x.canResume } == true
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/download/ui/worker/DownloadSchedulerWorker.kt b/app/src/main/kotlin/io/github/landwarderer/futon/download/ui/worker/DownloadSchedulerWorker.kt
index 4112919aef..1ae9a829b7 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/download/ui/worker/DownloadSchedulerWorker.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/download/ui/worker/DownloadSchedulerWorker.kt
@@ -12,10 +12,12 @@ import androidx.work.OneTimeWorkRequestBuilder
import androidx.work.WorkInfo
import androidx.work.WorkManager
import androidx.work.WorkerParameters
+import androidx.work.await
import dagger.assisted.Assisted
import dagger.assisted.AssistedInject
import io.github.landwarderer.futon.core.parser.MangaDataRepository
import io.github.landwarderer.futon.core.prefs.AppSettings
+import io.github.landwarderer.futon.core.util.ext.awaitUniqueWorkInfoByName
import io.github.landwarderer.futon.core.util.ext.awaitWorkInfosByTag
import io.github.landwarderer.futon.core.util.ext.printStackTraceDebug
import io.github.landwarderer.futon.download.data.repository.DownloadQueueRepository
@@ -54,7 +56,18 @@ class DownloadSchedulerWorker @AssistedInject constructor(
return@runCatchingCancellable Result.success()
}
+ // A manga whose previous queued download has not finished yet (e.g. still waiting for its
+ // network or charging constraints) must wait: its work is unique per manga and enqueued with
+ // KEEP, so a second request would be silently discarded together with its chapters.
+ val busyMangaIds = queue.mapTo(HashSet()) { it.mangaId }.filterTo(HashSet()) { mangaId ->
+ workManager.awaitUniqueWorkInfoByName(uniqueWorkName(mangaId)).any { !it.state.isFinished }
+ }
+ if (busyMangaIds.isNotEmpty()) {
+ Log.d("DownloadScheduler", "Waiting for unfinished downloads of manga $busyMangaIds")
+ }
+
val nextItem = queue.firstOrNull {
+ if (it.mangaId in busyMangaIds) return@firstOrNull false
if (it.isPaused && !force) return@firstOrNull false
if (force) return@firstOrNull true
@@ -78,6 +91,10 @@ class DownloadSchedulerWorker @AssistedInject constructor(
if (nextItem == null) {
scheduleAlarmCheck()
+ if (queue.any { it.mangaId in busyMangaIds }) {
+ // after the alarm check, which may replace the pending check with a longer delay
+ scheduleNextCheck(30, TimeUnit.SECONDS)
+ }
return@runCatchingCancellable Result.success()
}
@@ -113,11 +130,12 @@ class DownloadSchedulerWorker @AssistedInject constructor(
Log.d("DownloadScheduler", "Enqueuing download for manga ${nextItem.mangaId}")
workManager.enqueueUniqueWork(
- "download_${nextItem.mangaId}",
+ uniqueWorkName(nextItem.mangaId),
ExistingWorkPolicy.KEEP,
downloadRequest
- )
+ ).await()
+ // Only once the work is safely stored, or the chapters would be lost
downloadQueueRepository.removeFromQueue(nextItem.id)
// Schedule next check to process the rest of the queue
@@ -220,6 +238,8 @@ class DownloadSchedulerWorker @AssistedInject constructor(
const val WORK_NAME_SCHEDULER = "download_scheduler_periodic"
const val KEY_FORCE = "force"
+ private fun uniqueWorkName(mangaId: Long) = "download_$mangaId"
+
fun enqueue(workManager: WorkManager, delay: Long = 0, force: Boolean = false) {
Log.d("DownloadScheduler", "Enqueuing scheduler with delay: $delay ms, force=$force")
val request = OneTimeWorkRequestBuilder()
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/download/ui/worker/DownloadWorker.kt b/app/src/main/kotlin/io/github/landwarderer/futon/download/ui/worker/DownloadWorker.kt
index 8227b2ac33..4f07ae0edc 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/download/ui/worker/DownloadWorker.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/download/ui/worker/DownloadWorker.kt
@@ -62,7 +62,6 @@ import io.github.landwarderer.futon.local.data.LocalMangaRepository
import io.github.landwarderer.futon.local.data.LocalStorageCache
import io.github.landwarderer.futon.local.data.LocalStorageChanges
import io.github.landwarderer.futon.local.data.PageCache
-import io.github.landwarderer.futon.local.data.TempFileFilter
import io.github.landwarderer.futon.local.data.input.LocalMangaParser
import io.github.landwarderer.futon.local.data.output.LocalMangaOutput
import io.github.landwarderer.futon.local.domain.DeleteReadChaptersUseCase
@@ -98,6 +97,7 @@ import org.koitharu.kotatsu.parsers.util.requireBody
import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
import java.io.File
import java.util.UUID
+import java.util.concurrent.ConcurrentLinkedQueue
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicInteger
import javax.inject.Inject
@@ -210,6 +210,7 @@ class DownloadWorker @AssistedInject constructor(
)
val destination = localMangaRepository.getOutputDir(manga, task.destination)
checkNotNull(destination) { applicationContext.getString(R.string.cannot_find_available_storage) }
+ val tempFiles = ConcurrentLinkedQueue()
var output: LocalMangaOutput? = null
try {
if (manga.isLocal) {
@@ -225,7 +226,7 @@ class DownloadWorker @AssistedInject constructor(
)
val coverUrl = mangaDetails.largeCoverUrl.ifNullOrEmpty { mangaDetails.coverUrl }
if (!coverUrl.isNullOrEmpty()) {
- downloadFile(coverUrl, destination, repo.source).let { file ->
+ downloadFile(coverUrl, destination, repo.source, tempFiles).let { file ->
output.addCover(file, getMediaType(coverUrl, file))
file.deleteAwait()
}
@@ -250,7 +251,7 @@ class DownloadWorker @AssistedInject constructor(
runFailsafe {
val url = repo.getPageUrl(page)
val file = cache[url]
- ?: downloadFile(url, destination, repo.source)
+ ?: downloadFile(url, destination, repo.source, tempFiles)
output.addPage(
chapter = chapter,
file = file,
@@ -330,9 +331,7 @@ class DownloadWorker @AssistedInject constructor(
applicationContext.unregisterReceiver(pausingReceiver)
output?.closeQuietly()
output?.cleanup()
- destination.listFiles(TempFileFilter())?.forEach {
- it.deleteAwait()
- }
+ tempFiles.forEach { it.deleteAwait() }
}
}
}
@@ -407,6 +406,7 @@ class DownloadWorker @AssistedInject constructor(
url: String,
destination: File,
source: MangaSource,
+ tempFiles: MutableCollection,
): File {
if (url.startsWith("content:", ignoreCase = true) || url.startsWith("file:", ignoreCase = true)) {
val uri = url.toUri()
@@ -415,6 +415,7 @@ class DownloadWorker @AssistedInject constructor(
MimeTypes.getNormalizedExtension(it.name)
} ?: cr.getType(uri)?.toMimeTypeOrNull()?.let { MimeTypes.getExtension(it) }
val file = destination.createTempFile(ext)
+ tempFiles += file
try {
cr.openSource(uri).use { input ->
file.sink(append = false).buffer().use {
@@ -437,7 +438,7 @@ class DownloadWorker @AssistedInject constructor(
response.requireBody().use { body ->
file = destination.createTempFile(
ext = MimeTypes.getExtension(body.contentType()?.toMimeType())
- )
+ ).also { tempFiles += it }
file.sink(append = false).buffer().use {
it.writeAllCancellable(body.source(), bandwidthLimiter)
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/MangaSourcesRepository.kt b/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/MangaSourcesRepository.kt
index 0d8bde41c5..698d73b2b8 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/MangaSourcesRepository.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/MangaSourcesRepository.kt
@@ -17,6 +17,7 @@ import io.github.landwarderer.futon.core.model.getTitle
import io.github.landwarderer.futon.core.model.updateMihonTitle
import io.github.landwarderer.futon.core.model.isBroken
import io.github.landwarderer.futon.core.model.isNsfw
+import io.github.landwarderer.futon.core.model.languageCode
import io.github.landwarderer.futon.core.parser.external.ExternalMangaSource
import io.github.landwarderer.futon.core.prefs.AppSettings
import io.github.landwarderer.futon.core.prefs.observeAsFlow
@@ -36,6 +37,7 @@ import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.conflate
import kotlinx.coroutines.flow.distinctUntilChanged
import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.onEach
@@ -254,6 +256,72 @@ class MangaSourcesRepository @Inject constructor(
list
}
+ /**
+ * The sources a preset refers to that can still be used: built-in parsers, installed Mihon extensions
+ * and external plugins, minus broken and (when hidden) NSFW ones, in the same order as the sources list.
+ * Names of sources that have since been removed or uninstalled are skipped, not reported.
+ */
+ suspend fun getPresetSources(preset: SourcePreset): List {
+ if (preset.sources.isEmpty()) {
+ return emptyList()
+ }
+ assimilateNewSources()
+ val order = settings.sourcesSortOrder
+ val entities = dao.findAll(enabledOnly = false, order = order)
+ return mergePresetSources(
+ preset = preset,
+ fromDb = entities.filter { it.source in preset.sources }.toSources(settings.isNsfwContentDisabled, order),
+ external = getExternalSources(),
+ )
+ }
+
+ fun observePresetSources(preset: SourcePreset): Flow> = if (preset.sources.isEmpty()) {
+ flowOf(emptyList())
+ } else {
+ combine(
+ observeIsNsfwDisabled(),
+ observeSortOrder(),
+ ) { skipNsfw, order ->
+ dao.observeAll(enabledOnly = false, order = order).map { entities ->
+ entities.filter { it.source in preset.sources }.toSources(skipNsfw, order)
+ }
+ }.flattenLatest()
+ .onStart { assimilateNewSources() }
+ .combine(observeExternalSources()) { fromDb, external ->
+ mergePresetSources(preset, fromDb, external)
+ }
+ }
+
+ /** Every language code a source can declare, built-in parsers and installed Mihon extensions alike. */
+ fun getAllSourceLanguages(): Set = buildSet {
+ allMangaSources.mapNotNullTo(this) { it.languageCode }
+ getMihonSources().mapNotNullTo(this) { it.languageCode }
+ }
+
+ /** Names of the usable sources in [languages], as the starting point of a new preset. */
+ fun getSourceNamesForLanguages(languages: Set): Set {
+ if (languages.isEmpty()) {
+ return emptySet()
+ }
+ val skipNsfw = settings.isNsfwContentDisabled
+ return (allMangaSources.asSequence() + getMihonSources().asSequence())
+ .filter { it.languageCode in languages && (!skipNsfw || !it.isNsfw()) }
+ .mapTo(LinkedHashSet()) { it.name }
+ }
+
+ private fun mergePresetSources(
+ preset: SourcePreset,
+ fromDb: List,
+ external: List,
+ ): List {
+ val dbNames = fromDb.mapToSet { it.name }
+ val result = ArrayList(fromDb.size)
+ external.filter { it.name in preset.sources && it.name !in dbNames }
+ .mapTo(result) { MangaSourceInfo(it, isEnabled = true, isPinned = false) }
+ fromDb.mapTo(result) { it.copy(isEnabled = true) }
+ return result
+ }
+
fun observeAll(): Flow>> = dao.observeAll().map { entities ->
val result = ArrayList>(entities.size)
for (entity in entities) {
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/SourcePreset.kt b/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/SourcePreset.kt
new file mode 100644
index 0000000000..1e03881673
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/SourcePreset.kt
@@ -0,0 +1,43 @@
+package io.github.landwarderer.futon.explore.data
+
+import android.os.Parcelable
+import io.github.landwarderer.futon.list.ui.model.ListModel
+import kotlinx.parcelize.Parcelize
+
+@Parcelize
+data class SourcePreset(
+ val id: Long,
+ val title: String,
+ val languages: Set,
+ val sources: Set,
+ val createdAt: Long,
+ val sortKey: Int,
+) : Parcelable, ListModel {
+
+ override fun areItemsTheSame(other: ListModel): Boolean {
+ return other is SourcePreset && id == other.id
+ }
+}
+
+fun SourcePresetEntity.toSourcePreset() = SourcePreset(
+ id = presetId,
+ title = title,
+ languages = languages.splitPresetValues(),
+ sources = sources.splitPresetValues(),
+ createdAt = createdAt,
+ sortKey = sortKey,
+)
+
+internal fun Collection.joinPresetValues(): String = asSequence()
+ .map { it.trim() }
+ .filter { it.isNotEmpty() }
+ .distinct()
+ .joinToString(",")
+
+internal fun String.splitPresetValues(): Set = if (isBlank()) {
+ emptySet()
+} else {
+ splitToSequence(',')
+ .map { it.trim() }
+ .filterTo(LinkedHashSet()) { it.isNotEmpty() }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/SourcePresetEntity.kt b/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/SourcePresetEntity.kt
new file mode 100644
index 0000000000..846c90806b
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/SourcePresetEntity.kt
@@ -0,0 +1,18 @@
+package io.github.landwarderer.futon.explore.data
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import io.github.landwarderer.futon.core.db.TABLE_SOURCE_PRESETS
+
+@Entity(tableName = TABLE_SOURCE_PRESETS)
+data class SourcePresetEntity(
+ @PrimaryKey(autoGenerate = true)
+ @ColumnInfo(name = "preset_id") val presetId: Long,
+ @ColumnInfo(name = "title") val title: String,
+ @ColumnInfo(name = "languages") val languages: String,
+ @ColumnInfo(name = "sources") val sources: String,
+ @ColumnInfo(name = "created_at") val createdAt: Long,
+ @ColumnInfo(name = "sort_key") val sortKey: Int,
+ @ColumnInfo(name = "deleted_at", defaultValue = "0") val deletedAt: Long,
+)
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/SourcePresetsDao.kt b/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/SourcePresetsDao.kt
new file mode 100644
index 0000000000..4e55a8cfe6
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/SourcePresetsDao.kt
@@ -0,0 +1,50 @@
+package io.github.landwarderer.futon.explore.data
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+abstract class SourcePresetsDao {
+
+ @Query("SELECT * FROM source_presets WHERE deleted_at = 0 ORDER BY sort_key")
+ abstract suspend fun findAll(): List
+
+ @Query("SELECT * FROM source_presets WHERE deleted_at = 0 ORDER BY sort_key")
+ abstract fun observeAll(): Flow>
+
+ @Query("SELECT * FROM source_presets WHERE preset_id = :id AND deleted_at = 0")
+ abstract suspend fun find(id: Long): SourcePresetEntity?
+
+ @Query("SELECT * FROM source_presets WHERE preset_id = :id AND deleted_at = 0")
+ abstract fun observe(id: Long): Flow
+
+ @Insert(onConflict = OnConflictStrategy.ABORT)
+ abstract suspend fun insert(entity: SourcePresetEntity): Long
+
+ @Query("UPDATE source_presets SET title = :title, languages = :languages WHERE preset_id = :id")
+ abstract suspend fun update(id: Long, title: String, languages: String)
+
+ @Query("UPDATE source_presets SET sources = :sources WHERE preset_id = :id")
+ abstract suspend fun updateSources(id: Long, sources: String)
+
+ @Query("UPDATE source_presets SET sort_key = :sortKey WHERE preset_id = :id")
+ abstract suspend fun updateSortKey(id: Long, sortKey: Int)
+
+ suspend fun delete(id: Long) = setDeletedAt(id, System.currentTimeMillis())
+
+ @Query("DELETE FROM source_presets WHERE deleted_at != 0 AND deleted_at < :maxDeletionTime")
+ abstract suspend fun gc(maxDeletionTime: Long)
+
+ @Query("SELECT MAX(sort_key) FROM source_presets WHERE deleted_at = 0")
+ protected abstract suspend fun getMaxSortKey(): Int?
+
+ suspend fun getNextSortKey(): Int {
+ return (getMaxSortKey() ?: 0) + 1
+ }
+
+ @Query("UPDATE source_presets SET deleted_at = :deletedAt WHERE preset_id = :id")
+ protected abstract suspend fun setDeletedAt(id: Long, deletedAt: Long)
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/SourcePresetsRepository.kt b/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/SourcePresetsRepository.kt
new file mode 100644
index 0000000000..0035d8e74e
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/explore/data/SourcePresetsRepository.kt
@@ -0,0 +1,67 @@
+package io.github.landwarderer.futon.explore.data
+
+import dagger.Reusable
+import io.github.landwarderer.futon.core.db.MangaDatabase
+import io.github.landwarderer.futon.core.util.ext.mapItems
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import javax.inject.Inject
+
+@Reusable
+class SourcePresetsRepository @Inject constructor(
+ private val db: MangaDatabase,
+) {
+
+ private val dao: SourcePresetsDao
+ get() = db.getSourcePresetsDao()
+
+ fun observeAll(): Flow> {
+ return dao.observeAll().mapItems { it.toSourcePreset() }
+ }
+
+ fun observe(id: Long): Flow {
+ return dao.observe(id).map { it?.toSourcePreset() }
+ }
+
+ suspend fun getAll(): List {
+ return dao.findAll().map { it.toSourcePreset() }
+ }
+
+ suspend fun getById(id: Long): SourcePreset? {
+ if (id == NO_PRESET) {
+ return null
+ }
+ return dao.find(id)?.toSourcePreset()
+ }
+
+ suspend fun createPreset(title: String, languages: Set, sources: Set): SourcePreset {
+ val entity = SourcePresetEntity(
+ presetId = 0,
+ title = title,
+ languages = languages.joinPresetValues(),
+ sources = sources.joinPresetValues(),
+ createdAt = System.currentTimeMillis(),
+ sortKey = dao.getNextSortKey(),
+ deletedAt = 0L,
+ )
+ val id = dao.insert(entity)
+ return entity.copy(presetId = id).toSourcePreset()
+ }
+
+ suspend fun updatePreset(id: Long, title: String, languages: Set) {
+ dao.update(id, title, languages.joinPresetValues())
+ }
+
+ suspend fun updatePresetSources(id: Long, sources: Set) {
+ dao.updateSources(id, sources.joinPresetValues())
+ }
+
+ suspend fun deletePreset(id: Long) {
+ dao.delete(id)
+ }
+
+ companion object {
+
+ const val NO_PRESET = 0L
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/ExploreFragment.kt b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/ExploreFragment.kt
index ce9eed0b7f..fc8a116e62 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/ExploreFragment.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/ExploreFragment.kt
@@ -11,6 +11,7 @@ import android.view.MenuInflater
import android.view.MenuItem
import android.view.View
import android.view.ViewGroup
+import android.widget.PopupMenu
import androidx.appcompat.view.ActionMode
import androidx.core.view.WindowInsetsCompat
import androidx.fragment.app.viewModels
@@ -42,6 +43,7 @@ import io.github.landwarderer.futon.databinding.FragmentExploreBinding
import io.github.landwarderer.futon.explore.ui.adapter.ExploreAdapter
import io.github.landwarderer.futon.explore.ui.adapter.ExploreListEventListener
import io.github.landwarderer.futon.explore.ui.model.MangaSourceItem
+import io.github.landwarderer.futon.explore.ui.preset.SourcePresetListActivity
import io.github.landwarderer.futon.list.ui.adapter.TypedListSpacingDecoration
import io.github.landwarderer.futon.list.ui.model.ListHeader
import org.koitharu.kotatsu.parsers.model.Manga
@@ -83,7 +85,7 @@ class ExploreFragment :
addItemDecoration(TypedListSpacingDecoration(context, false))
checkNotNull(sourceSelectionController).attachToRecyclerView(this)
}
- addMenuProvider(ExploreMenuProvider(router))
+ addMenuProvider(ExploreMenuProvider(binding.root.context, router))
viewModel.content.observe(viewLifecycleOwner, checkNotNull(exploreAdapter))
viewModel.onError.observeEvent(viewLifecycleOwner, SnackbarErrorObserver(binding.recyclerView, this))
viewModel.onOpenManga.observeEvent(viewLifecycleOwner, ::onOpenManga)
@@ -115,6 +117,9 @@ class ExploreFragment :
override fun onListHeaderClick(item: ListHeader, view: View) {
if (item.payload == R.id.nav_suggestions) {
router.openSuggestions()
+ } else if (viewModel.isPresetActive) {
+ // A preset's sources are picked in the catalog, which switches to preset mode.
+ router.openSourcesCatalog()
} else if (viewModel.isAllSourcesEnabled.value) {
router.openManageSources()
} else {
@@ -129,7 +134,28 @@ class ExploreFragment :
R.id.button_more -> router.openSuggestions()
R.id.button_downloads -> router.openDownloads()
R.id.button_random -> viewModel.openRandom()
+ R.id.button_presets -> startActivity(SourcePresetListActivity.newIntent(v.context))
+ R.id.button_presets_dropdown -> showPresetsPopup(v)
+ }
+ }
+
+ private fun showPresetsPopup(anchor: View) {
+ val presets = viewModel.presets.value
+ val activeId = viewModel.activePresetId
+ val popup = PopupMenu(anchor.context, anchor)
+ popup.menu.add(Menu.NONE, 0, 0, R.string.default_sources).isChecked = presets.none { it.id == activeId }
+ presets.forEachIndexed { index, preset ->
+ popup.menu.add(Menu.NONE, index + 1, index + 1, preset.title).isChecked = preset.id == activeId
+ }
+ popup.menu.setGroupCheckable(Menu.NONE, true, true)
+ popup.setOnMenuItemClickListener { menuItem ->
+ val preset = presets.getOrNull(menuItem.itemId - 1)
+ viewModel.setActivePreset(
+ if (preset == null || preset.id == activeId) 0L else preset.id,
+ )
+ true
}
+ popup.show()
}
override fun onItemClick(item: MangaSourceItem, view: View) {
@@ -171,8 +197,8 @@ class ExploreFragment :
menu.findItem(R.id.action_shortcut).isVisible = isSingleSelection
menu.findItem(R.id.action_pin).isVisible = selectedSources.all { !it.isPinned }
menu.findItem(R.id.action_unpin).isVisible = selectedSources.all { it.isPinned }
- menu.findItem(R.id.action_disable)?.isVisible = !viewModel.isAllSourcesEnabled.value &&
- selectedSources.all { it.mangaSource is MangaParserSource }
+ menu.findItem(R.id.action_disable)?.isVisible = viewModel.isPresetActive ||
+ (!viewModel.isAllSourcesEnabled.value && selectedSources.all { it.mangaSource is MangaParserSource })
menu.findItem(R.id.action_delete)?.isVisible = selectedSources.all { it.mangaSource is ExternalMangaSource }
return super.onPrepareActionMode(controller, mode, menu)
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/ExploreMenuProvider.kt b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/ExploreMenuProvider.kt
index 6ab504fdf5..da71722778 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/ExploreMenuProvider.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/ExploreMenuProvider.kt
@@ -1,13 +1,16 @@
package io.github.landwarderer.futon.explore.ui
+import android.content.Context
import android.view.Menu
import android.view.MenuInflater
import android.view.MenuItem
import androidx.core.view.MenuProvider
import io.github.landwarderer.futon.R
import io.github.landwarderer.futon.core.nav.AppRouter
+import io.github.landwarderer.futon.explore.ui.preset.SourcePresetListActivity
class ExploreMenuProvider(
+ private val context: Context,
private val router: AppRouter,
) : MenuProvider {
@@ -22,6 +25,11 @@ class ExploreMenuProvider(
true
}
+ R.id.action_presets -> {
+ context.startActivity(SourcePresetListActivity.newIntent(context))
+ true
+ }
+
else -> false
}
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/ExploreViewModel.kt b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/ExploreViewModel.kt
index a2ba0bc24b..e711345edb 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/ExploreViewModel.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/ExploreViewModel.kt
@@ -16,6 +16,8 @@ import io.github.landwarderer.futon.core.util.ext.MutableEventFlow
import io.github.landwarderer.futon.core.util.ext.call
import io.github.landwarderer.futon.core.util.ext.combine
import io.github.landwarderer.futon.explore.data.MangaSourcesRepository
+import io.github.landwarderer.futon.explore.data.SourcePreset
+import io.github.landwarderer.futon.explore.data.SourcePresetsRepository
import io.github.landwarderer.futon.explore.domain.ExploreRepository
import io.github.landwarderer.futon.explore.ui.model.ExploreButtons
import io.github.landwarderer.futon.explore.ui.model.MangaSourceItem
@@ -48,6 +50,7 @@ class ExploreViewModel @Inject constructor(
private val suggestionRepository: SuggestionRepository,
private val exploreRepository: ExploreRepository,
private val sourcesRepository: MangaSourcesRepository,
+ private val presetsRepository: SourcePresetsRepository,
private val shortcutManager: AppShortcutManager,
) : BaseViewModel() {
@@ -74,6 +77,23 @@ class ExploreViewModel @Inject constructor(
valueProducer = { isSuggestionsEnabled },
)
+ /** The active preset, or null when there is none or it no longer exists (deleted, not restored...). */
+ private val activePresetFlow: StateFlow = settings.observeAsFlow(
+ key = AppSettings.KEY_ACTIVE_SOURCE_PRESET,
+ valueProducer = { activeSourcePresetId },
+ ).flatMapLatest { id ->
+ if (id == SourcePresetsRepository.NO_PRESET) flowOf(null) else presetsRepository.observe(id)
+ }.stateIn(viewModelScope + Dispatchers.IO, SharingStarted.Eagerly, null)
+
+ val presets: StateFlow> = presetsRepository.observeAll()
+ .stateIn(viewModelScope + Dispatchers.IO, SharingStarted.Eagerly, emptyList())
+
+ val activePresetId: Long
+ get() = activePresetFlow.value?.id ?: SourcePresetsRepository.NO_PRESET
+
+ val isPresetActive: Boolean
+ get() = activePresetFlow.value != null
+
val onOpenManga = MutableEventFlow()
val onActionDone = MutableEventFlow()
val onShowSuggestionsTip = MutableEventFlow()
@@ -110,11 +130,23 @@ class ExploreViewModel @Inject constructor(
}
}
+ fun setActivePreset(presetId: Long) {
+ settings.activeSourcePresetId = presetId
+ }
+
fun disableSources(sources: Collection) {
launchJob(Dispatchers.IO) {
- val rollback = sourcesRepository.setSourcesEnabled(sources, isEnabled = false)
val message = if (sources.size == 1) R.string.source_disabled else R.string.sources_disabled
- onActionDone.call(ReversibleAction(message, rollback))
+ val preset = activePresetFlow.value
+ if (preset != null) {
+ // With a preset active, "disable" takes the sources out of the preset, not out of the app.
+ val removed = sources.mapTo(HashSet(sources.size)) { it.name }
+ presetsRepository.updatePresetSources(preset.id, preset.sources - removed)
+ onActionDone.call(ReversibleAction(message, null))
+ } else {
+ val rollback = sourcesRepository.setSourcesEnabled(sources, isEnabled = false)
+ onActionDone.call(ReversibleAction(message, rollback))
+ }
}
}
@@ -147,8 +179,17 @@ class ExploreViewModel @Inject constructor(
}
}
+ private fun observeSourcesForDisplay(): Flow> = activePresetFlow.flatMapLatest { preset ->
+ if (preset != null) {
+ sourcesRepository.observePresetSources(preset)
+ } else {
+ sourcesRepository.observeEnabledSources()
+ }
+ }
+
+ /** The active preset (or the enabled sources) narrowed to the current manga / novel mode */
private fun observeFilteredSources(): Flow> = combineFlows(
- sourcesRepository.observeEnabledSources(),
+ observeSourcesForDisplay(),
appMode,
) { sources, mode ->
val isNovel = mode.isNovel
@@ -162,8 +203,9 @@ class ExploreViewModel @Inject constructor(
isRandomLoading,
isAllSourcesEnabled,
sourcesRepository.observeHasNewSourcesForBadge(),
- ) { sources, suggestions, grid, randomLoading, allSourcesEnabled, newSources ->
- buildList(sources, suggestions, grid, randomLoading, allSourcesEnabled, newSources)
+ activePresetFlow,
+ ) { content, suggestions, grid, randomLoading, allSourcesEnabled, newSources, activePreset ->
+ buildList(content, suggestions, grid, randomLoading, allSourcesEnabled, newSources, activePreset)
}.withErrorHandling()
private fun buildList(
@@ -173,9 +215,10 @@ class ExploreViewModel @Inject constructor(
randomLoading: Boolean,
allSourcesEnabled: Boolean,
hasNewSources: Boolean,
+ activePreset: SourcePreset?,
): List {
val result = ArrayList(sources.size + 3)
- result += ExploreButtons(randomLoading)
+ result += ExploreButtons(randomLoading, activePreset?.title)
if (recommendation.isNotEmpty()) {
result += ListHeader(R.string.suggestions, R.string.more, R.id.nav_suggestions)
result += RecommendationsItem(recommendation.toRecommendationList())
@@ -183,8 +226,8 @@ class ExploreViewModel @Inject constructor(
if (sources.isNotEmpty()) {
result += ListHeader(
textRes = R.string.remote_sources,
- buttonTextRes = if (allSourcesEnabled) R.string.manage else R.string.catalog,
- badge = if (!allSourcesEnabled && hasNewSources) "" else null,
+ buttonTextRes = if (allSourcesEnabled && activePreset == null) R.string.manage else R.string.catalog,
+ badge = if (!allSourcesEnabled && activePreset == null && hasNewSources) "" else null,
)
sources.mapTo(result) { MangaSourceItem(it, isGrid) }
} else {
@@ -199,8 +242,8 @@ class ExploreViewModel @Inject constructor(
}
private fun getLoadingStateList() = listOf(
- ExploreButtons(isRandomLoading.value),
- LoadingState,
+ ExploreButtons(isRandomLoading.value, activePresetFlow.value?.title),
+ LoadingState(),
)
private fun getSuggestionFlow() = isSuggestionsEnabled.mapLatest { isEnabled ->
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/adapter/ExploreAdapterDelegates.kt b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/adapter/ExploreAdapterDelegates.kt
index 23aca97250..f6c2fffeab 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/adapter/ExploreAdapterDelegates.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/adapter/ExploreAdapterDelegates.kt
@@ -39,6 +39,8 @@ fun exploreButtonsAD(
binding.buttonDownloads.setOnClickListener(clickListener)
binding.buttonLocal.setOnClickListener(clickListener)
binding.buttonRandom.setOnClickListener(clickListener)
+ binding.buttonPresets.setOnClickListener(clickListener)
+ binding.buttonPresetsDropdown.setOnClickListener(clickListener)
bind {
if (item.isRandomLoading) {
@@ -47,6 +49,12 @@ fun exploreButtonsAD(
binding.buttonRandom.setIconResource(R.drawable.ic_dice)
}
binding.buttonRandom.isClickable = !item.isRandomLoading
+ val presetName = item.activePresetName
+ if (presetName != null) {
+ binding.buttonPresets.text = presetName
+ } else {
+ binding.buttonPresets.setText(R.string.source_presets)
+ }
}
}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/model/ExploreButtons.kt b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/model/ExploreButtons.kt
index f5b5ee6a7e..7057d28253 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/model/ExploreButtons.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/model/ExploreButtons.kt
@@ -4,6 +4,7 @@ import io.github.landwarderer.futon.list.ui.model.ListModel
data class ExploreButtons(
val isRandomLoading: Boolean,
+ val activePresetName: String? = null,
) : ListModel {
override fun areItemsTheSame(other: ListModel): Boolean {
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/preset/SourcePresetAdapter.kt b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/preset/SourcePresetAdapter.kt
new file mode 100644
index 0000000000..d5572e38ff
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/preset/SourcePresetAdapter.kt
@@ -0,0 +1,84 @@
+package io.github.landwarderer.futon.explore.ui.preset
+
+import android.annotation.SuppressLint
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.recyclerview.widget.DiffUtil
+import androidx.recyclerview.widget.ListAdapter
+import androidx.recyclerview.widget.RecyclerView
+import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.core.model.getSourceLanguageDisplayName
+import io.github.landwarderer.futon.databinding.ItemPresetBinding
+import io.github.landwarderer.futon.explore.data.SourcePreset
+
+class SourcePresetAdapter(
+ private val listener: SourcePresetListener,
+) : ListAdapter(PresetDiffCallback) {
+
+ var activePresetId: Long = 0L
+ @SuppressLint("NotifyDataSetChanged")
+ set(value) {
+ if (field != value) {
+ field = value
+ notifyDataSetChanged()
+ }
+ }
+
+ override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PresetViewHolder {
+ val binding = ItemPresetBinding.inflate(LayoutInflater.from(parent.context), parent, false)
+ return PresetViewHolder(binding)
+ }
+
+ override fun onBindViewHolder(holder: PresetViewHolder, position: Int) {
+ holder.bind(getItem(position))
+ }
+
+ inner class PresetViewHolder(
+ private val binding: ItemPresetBinding,
+ ) : RecyclerView.ViewHolder(binding.root), View.OnClickListener {
+
+ private var boundItem: SourcePreset? = null
+
+ init {
+ binding.root.setOnClickListener(this)
+ binding.buttonEdit.setOnClickListener(this)
+ binding.buttonDelete.setOnClickListener(this)
+ }
+
+ fun bind(item: SourcePreset) {
+ boundItem = item
+ binding.textViewTitle.text = item.title
+ val context = binding.root.context
+ val langNames = item.languages.map { getSourceLanguageDisplayName(context, it) }
+ val count = item.sources.size
+ val countText = context.resources.getQuantityString(R.plurals.sources_count, count, count)
+ binding.textViewSubtitle.text = if (langNames.isNotEmpty()) {
+ "${langNames.joinToString()} — $countText"
+ } else {
+ countText
+ }
+ binding.radio.isChecked = item.id == activePresetId
+ }
+
+ override fun onClick(v: View) {
+ val item = boundItem ?: return
+ when (v) {
+ binding.buttonEdit -> listener.onEditPreset(item)
+ binding.buttonDelete -> listener.onDeletePreset(item)
+ else -> listener.onPresetClick(item)
+ }
+ }
+ }
+
+ private object PresetDiffCallback : DiffUtil.ItemCallback() {
+ override fun areItemsTheSame(oldItem: SourcePreset, newItem: SourcePreset) = oldItem.id == newItem.id
+ override fun areContentsTheSame(oldItem: SourcePreset, newItem: SourcePreset) = oldItem == newItem
+ }
+}
+
+interface SourcePresetListener {
+ fun onPresetClick(preset: SourcePreset)
+ fun onEditPreset(preset: SourcePreset)
+ fun onDeletePreset(preset: SourcePreset)
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/preset/SourcePresetEditActivity.kt b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/preset/SourcePresetEditActivity.kt
new file mode 100644
index 0000000000..249cdac00e
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/preset/SourcePresetEditActivity.kt
@@ -0,0 +1,137 @@
+package io.github.landwarderer.futon.explore.ui.preset
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.text.Editable
+import android.view.View
+import androidx.activity.viewModels
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.isVisible
+import com.google.android.material.chip.Chip
+import dagger.hilt.android.AndroidEntryPoint
+import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.core.model.getSourceLanguageDisplayName
+import io.github.landwarderer.futon.core.nav.AppRouter
+import io.github.landwarderer.futon.core.ui.BaseActivity
+import io.github.landwarderer.futon.core.ui.util.DefaultTextWatcher
+import io.github.landwarderer.futon.core.util.ext.consumeAllSystemBarsInsets
+import io.github.landwarderer.futon.core.util.ext.getDisplayMessage
+import io.github.landwarderer.futon.core.util.ext.observe
+import io.github.landwarderer.futon.core.util.ext.observeEvent
+import io.github.landwarderer.futon.core.util.ext.systemBarsInsets
+import io.github.landwarderer.futon.databinding.ActivityPresetEditBinding
+import io.github.landwarderer.futon.explore.data.SourcePreset
+
+@AndroidEntryPoint
+class SourcePresetEditActivity :
+ BaseActivity(),
+ View.OnClickListener,
+ DefaultTextWatcher {
+
+ private val viewModel by viewModels()
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ setContentView(ActivityPresetEditBinding.inflate(layoutInflater))
+ setDisplayHomeAsUp(isEnabled = true, showUpAsClose = true)
+ viewBinding.buttonDone.setOnClickListener(this)
+ viewBinding.editName.addTextChangedListener(this)
+ afterTextChanged(viewBinding.editName.text)
+
+ initLanguageChips()
+
+ viewModel.onSaved.observeEvent(this) { finishAfterTransition() }
+ viewModel.preset.observe(this, ::onPresetChanged)
+ viewModel.isLoading.observe(this, ::onLoadingStateChanged)
+ viewModel.onError.observeEvent(this, ::onError)
+ }
+
+ override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
+ val barsInsets = insets.systemBarsInsets
+ viewBinding.root.setPadding(
+ barsInsets.left,
+ barsInsets.top,
+ barsInsets.right,
+ barsInsets.bottom,
+ )
+ return insets.consumeAllSystemBarsInsets()
+ }
+
+ override fun onClick(v: View) {
+ when (v.id) {
+ R.id.button_done -> viewModel.save(
+ title = viewBinding.editName.text?.toString()?.trim().orEmpty(),
+ selectedLanguages = getSelectedLanguages(),
+ )
+ }
+ }
+
+ override fun afterTextChanged(s: Editable?) {
+ viewBinding.buttonDone.isEnabled = !s.isNullOrBlank() && !viewModel.isLoading.value
+ }
+
+ private fun initLanguageChips() {
+ val chipGroup = viewBinding.chipGroupLanguages
+ chipGroup.removeAllViews()
+ val locales = viewModel.allLocales
+ .map { it to getSourceLanguageDisplayName(this, it) }
+ .sortedBy { it.second }
+ for ((locale, title) in locales) {
+ val chip = Chip(this).apply {
+ text = title
+ isCheckable = true
+ tag = locale
+ }
+ chipGroup.addView(chip)
+ }
+ }
+
+ private fun onPresetChanged(preset: SourcePreset?) {
+ setTitle(if (preset == null) R.string.create_preset else R.string.edit_preset)
+ if (preset == null) return
+ if (viewBinding.editName.text.isNullOrEmpty()) {
+ viewBinding.editName.setText(preset.title)
+ }
+ val chipGroup = viewBinding.chipGroupLanguages
+ for (i in 0 until chipGroup.childCount) {
+ val chip = chipGroup.getChildAt(i) as? Chip ?: continue
+ chip.isChecked = chip.tag as? String in preset.languages
+ }
+ }
+
+ private fun getSelectedLanguages(): Set {
+ val chipGroup = viewBinding.chipGroupLanguages
+ val result = LinkedHashSet()
+ for (i in 0 until chipGroup.childCount) {
+ val chip = chipGroup.getChildAt(i) as? Chip ?: continue
+ if (chip.isChecked) {
+ (chip.tag as? String)?.let { result.add(it) }
+ }
+ }
+ // Keep languages whose sources are not installed right now, so editing a preset does not drop them.
+ viewModel.preset.value?.languages?.filterTo(result) { it !in viewModel.allLocales }
+ return result
+ }
+
+ private fun onError(e: Throwable) {
+ viewBinding.textViewError.text = e.getDisplayMessage(resources)
+ viewBinding.textViewError.isVisible = true
+ }
+
+ private fun onLoadingStateChanged(isLoading: Boolean) {
+ viewBinding.buttonDone.isEnabled = !isLoading && !viewBinding.editName.text.isNullOrBlank()
+ viewBinding.editName.isEnabled = !isLoading
+ if (isLoading) {
+ viewBinding.textViewError.isVisible = false
+ }
+ }
+
+ companion object {
+
+ fun newIntent(context: Context, presetId: Long = SourcePresetEditViewModel.NO_ID): Intent {
+ return Intent(context, SourcePresetEditActivity::class.java)
+ .putExtra(AppRouter.KEY_ID, presetId)
+ }
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/preset/SourcePresetEditViewModel.kt b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/preset/SourcePresetEditViewModel.kt
new file mode 100644
index 0000000000..e86fc18af3
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/preset/SourcePresetEditViewModel.kt
@@ -0,0 +1,56 @@
+package io.github.landwarderer.futon.explore.ui.preset
+
+import androidx.lifecycle.SavedStateHandle
+import dagger.hilt.android.lifecycle.HiltViewModel
+import io.github.landwarderer.futon.core.nav.AppRouter
+import io.github.landwarderer.futon.core.ui.BaseViewModel
+import io.github.landwarderer.futon.core.util.ext.MutableEventFlow
+import io.github.landwarderer.futon.core.util.ext.call
+import io.github.landwarderer.futon.explore.data.MangaSourcesRepository
+import io.github.landwarderer.futon.explore.data.SourcePreset
+import io.github.landwarderer.futon.explore.data.SourcePresetsRepository
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import javax.inject.Inject
+
+@HiltViewModel
+class SourcePresetEditViewModel @Inject constructor(
+ savedStateHandle: SavedStateHandle,
+ private val presetsRepository: SourcePresetsRepository,
+ private val sourcesRepository: MangaSourcesRepository,
+) : BaseViewModel() {
+
+ private val presetId = savedStateHandle[AppRouter.KEY_ID] ?: NO_ID
+
+ val onSaved = MutableEventFlow()
+ val preset = MutableStateFlow(null)
+
+ val allLocales: Set = sourcesRepository.getAllSourceLanguages()
+
+ init {
+ launchLoadingJob(Dispatchers.IO) {
+ preset.value = if (presetId != NO_ID) {
+ presetsRepository.getById(presetId)
+ } else {
+ null
+ }
+ }
+ }
+
+ fun save(title: String, selectedLanguages: Set) {
+ launchLoadingJob(Dispatchers.IO) {
+ check(title.isNotEmpty())
+ if (presetId == NO_ID) {
+ val initialSources = sourcesRepository.getSourceNamesForLanguages(selectedLanguages)
+ presetsRepository.createPreset(title, selectedLanguages, initialSources)
+ } else {
+ presetsRepository.updatePreset(presetId, title, selectedLanguages)
+ }
+ onSaved.call(Unit)
+ }
+ }
+
+ companion object {
+ const val NO_ID = -1L
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/preset/SourcePresetListActivity.kt b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/preset/SourcePresetListActivity.kt
new file mode 100644
index 0000000000..6c6ed0baea
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/preset/SourcePresetListActivity.kt
@@ -0,0 +1,116 @@
+package io.github.landwarderer.futon.explore.ui.preset
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.view.View
+import android.view.ViewGroup.MarginLayoutParams
+import androidx.activity.viewModels
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.isVisible
+import androidx.core.view.updateLayoutParams
+import androidx.core.view.updatePadding
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.google.android.material.snackbar.Snackbar
+import dagger.hilt.android.AndroidEntryPoint
+import io.github.landwarderer.futon.R
+import io.github.landwarderer.futon.core.exceptions.resolve.SnackbarErrorObserver
+import io.github.landwarderer.futon.core.ui.BaseActivity
+import io.github.landwarderer.futon.core.util.ext.consumeAllSystemBarsInsets
+import io.github.landwarderer.futon.core.util.ext.end
+import io.github.landwarderer.futon.core.util.ext.observe
+import io.github.landwarderer.futon.core.util.ext.observeEvent
+import io.github.landwarderer.futon.core.util.ext.systemBarsInsets
+import io.github.landwarderer.futon.databinding.ActivityPresetListBinding
+import io.github.landwarderer.futon.explore.data.SourcePreset
+import io.github.landwarderer.futon.explore.data.SourcePresetsRepository
+import io.github.landwarderer.futon.list.ui.adapter.TypedListSpacingDecoration
+
+@AndroidEntryPoint
+class SourcePresetListActivity :
+ BaseActivity(),
+ View.OnClickListener,
+ SourcePresetListener {
+
+ private val viewModel by viewModels()
+ private lateinit var adapter: SourcePresetAdapter
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ setContentView(ActivityPresetListBinding.inflate(layoutInflater))
+ setDisplayHomeAsUp(isEnabled = true, showUpAsClose = false)
+
+ adapter = SourcePresetAdapter(this)
+ adapter.activePresetId = viewModel.activePresetId
+ viewBinding.recyclerView.adapter = adapter
+ viewBinding.recyclerView.setHasFixedSize(true)
+ viewBinding.recyclerView.addItemDecoration(TypedListSpacingDecoration(this, false))
+ viewBinding.fabAdd.setOnClickListener(this)
+
+ viewModel.presets.observe(this) { presets ->
+ adapter.submitList(presets)
+ viewBinding.textViewEmpty.isVisible = presets.isEmpty()
+ }
+ viewModel.onError.observeEvent(this, SnackbarErrorObserver(viewBinding.recyclerView, null))
+ viewModel.onPresetDeleted.observeEvent(this) {
+ adapter.activePresetId = viewModel.activePresetId
+ Snackbar.make(viewBinding.recyclerView, R.string.preset_deleted, Snackbar.LENGTH_SHORT).show()
+ }
+ }
+
+ override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
+ val barsInsets = insets.systemBarsInsets
+ viewBinding.recyclerView.updatePadding(
+ left = barsInsets.left,
+ right = barsInsets.right,
+ bottom = barsInsets.bottom,
+ )
+ viewBinding.appbar.updatePadding(
+ left = barsInsets.left,
+ right = barsInsets.right,
+ top = barsInsets.top,
+ )
+ viewBinding.fabAdd.updateLayoutParams {
+ marginEnd = topMargin + barsInsets.end(v)
+ bottomMargin = topMargin + barsInsets.bottom
+ }
+ return insets.consumeAllSystemBarsInsets()
+ }
+
+ override fun onClick(v: View) {
+ when (v.id) {
+ R.id.fab_add -> startActivity(SourcePresetEditActivity.newIntent(this))
+ }
+ }
+
+ override fun onPresetClick(preset: SourcePreset) {
+ val newId = if (preset.id == viewModel.activePresetId) SourcePresetsRepository.NO_PRESET else preset.id
+ viewModel.setActivePreset(newId)
+ adapter.activePresetId = newId
+ val message = if (newId != SourcePresetsRepository.NO_PRESET) {
+ R.string.preset_activated
+ } else {
+ R.string.preset_deactivated
+ }
+ Snackbar.make(viewBinding.recyclerView, message, Snackbar.LENGTH_SHORT).show()
+ }
+
+ override fun onEditPreset(preset: SourcePreset) {
+ startActivity(SourcePresetEditActivity.newIntent(this, preset.id))
+ }
+
+ override fun onDeletePreset(preset: SourcePreset) {
+ MaterialAlertDialogBuilder(this)
+ .setTitle(preset.title)
+ .setNegativeButton(android.R.string.cancel, null)
+ .setPositiveButton(R.string.remove) { _, _ ->
+ viewModel.deletePreset(preset.id)
+ }
+ .show()
+ }
+
+ companion object {
+
+ fun newIntent(context: Context) = Intent(context, SourcePresetListActivity::class.java)
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/preset/SourcePresetListViewModel.kt b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/preset/SourcePresetListViewModel.kt
new file mode 100644
index 0000000000..3e77821d69
--- /dev/null
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/explore/ui/preset/SourcePresetListViewModel.kt
@@ -0,0 +1,45 @@
+package io.github.landwarderer.futon.explore.ui.preset
+
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import io.github.landwarderer.futon.core.prefs.AppSettings
+import io.github.landwarderer.futon.core.ui.BaseViewModel
+import io.github.landwarderer.futon.core.util.ext.MutableEventFlow
+import io.github.landwarderer.futon.core.util.ext.call
+import io.github.landwarderer.futon.explore.data.SourcePreset
+import io.github.landwarderer.futon.explore.data.SourcePresetsRepository
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.plus
+import javax.inject.Inject
+
+@HiltViewModel
+class SourcePresetListViewModel @Inject constructor(
+ private val presetsRepository: SourcePresetsRepository,
+ private val settings: AppSettings,
+) : BaseViewModel() {
+
+ val presets: StateFlow> = presetsRepository.observeAll()
+ .stateIn(viewModelScope + Dispatchers.IO, SharingStarted.Eagerly, emptyList())
+
+ val onPresetDeleted = MutableEventFlow()
+
+ val activePresetId: Long
+ get() = settings.activeSourcePresetId
+
+ fun setActivePreset(presetId: Long) {
+ settings.activeSourcePresetId = presetId
+ }
+
+ fun deletePreset(presetId: Long) {
+ launchJob(Dispatchers.IO) {
+ if (settings.activeSourcePresetId == presetId) {
+ settings.activeSourcePresetId = SourcePresetsRepository.NO_PRESET
+ }
+ presetsRepository.deletePreset(presetId)
+ onPresetDeleted.call(Unit)
+ }
+ }
+}
diff --git a/app/src/main/kotlin/io/github/landwarderer/futon/favourites/data/FavouritesDao.kt b/app/src/main/kotlin/io/github/landwarderer/futon/favourites/data/FavouritesDao.kt
index 41e949bf0c..08f195d9cf 100644
--- a/app/src/main/kotlin/io/github/landwarderer/futon/favourites/data/FavouritesDao.kt
+++ b/app/src/main/kotlin/io/github/landwarderer/futon/favourites/data/FavouritesDao.kt
@@ -15,8 +15,12 @@ import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.isActive
import org.intellij.lang.annotations.Language
+import io.github.landwarderer.futon.core.db.LibrarySearchQuery
import io.github.landwarderer.futon.core.db.MangaQueryBuilder
+import io.github.landwarderer.futon.core.db.SqlCondition
import io.github.landwarderer.futon.core.db.TABLE_FAVOURITES
+import io.github.landwarderer.futon.core.db.contentTypeCondition
+import io.github.landwarderer.futon.core.db.librarySearchCondition
import io.github.landwarderer.futon.core.db.entity.MangaWithTags
import io.github.landwarderer.futon.favourites.domain.model.Cover
import io.github.landwarderer.futon.list.domain.ListFilterOption
@@ -40,6 +44,23 @@ abstract class FavouritesDao : MangaQueryBuilder.ConditionCallback {
@Query("SELECT manga.* FROM favourites LEFT JOIN manga ON manga.manga_id = favourites.manga_id WHERE favourites.deleted_at = 0 AND (manga.title LIKE :query OR manga.alt_title LIKE :query) LIMIT :limit")
abstract suspend fun searchByTitle(query: String, limit: Int): List
+ /**
+ * Free-text match over everything that identifies an entry on the Favourites screen: its title, the
+ * source it came from, and the category (list) it is filed under. [pattern] must be escaped for
+ * `ESCAPE '\'`.
+ */
+ @Transaction
+ @Query(
+ "SELECT manga.* FROM favourites LEFT JOIN manga ON manga.manga_id = favourites.manga_id " +
+ "WHERE favourites.deleted_at = 0 AND (" +
+ "manga.title LIKE :pattern ESCAPE '\\' OR manga.alt_title LIKE :pattern ESCAPE '\\' " +
+ "OR manga.source IN (:sourceNames) " +
+ "OR EXISTS(SELECT 1 FROM favourite_categories c WHERE c.category_id = favourites.category_id " +
+ "AND c.deleted_at = 0 AND c.title LIKE :pattern ESCAPE '\\')" +
+ ") GROUP BY favourites.manga_id ORDER BY favourites.created_at DESC LIMIT :limit",
+ )
+ abstract suspend fun filter(pattern: String, sourceNames: List, limit: Int): List
+
@Transaction
@Query("SELECT manga.* FROM favourites LEFT JOIN manga ON manga.manga_id = favourites.manga_id WHERE favourites.deleted_at = 0 AND (manga.author LIKE :query) LIMIT :limit")
abstract suspend fun searchByAuthor(query: String, limit: Int): List
@@ -51,8 +72,9 @@ abstract class FavouritesDao : MangaQueryBuilder.ConditionCallback {
fun observeAll(
order: ListSortOrder,
filterOptions: Set