Clean up extension update checking

ExtensionApi only wrapped the store repository and the launch check, which matched updates again on its own. The manager now fetches listings and checks for updates itself with the statuses it already keeps, so the check covers not-loaded extensions and keeps the Extensions tab current from launch. Statuses are derived in one place, and the extension list is split before it's sorted instead of sorted twice.
This commit is contained in:
AntsyLich
2026-09-27 23:59:53 +06:00
parent 2d86a70ce2
commit 4f33486aa4
4 changed files with 76 additions and 107 deletions
@@ -7,7 +7,6 @@ import dev.zacsweers.metro.Inject
import dev.zacsweers.metro.SingleIn
import eu.kanade.domain.extension.interactor.TrustExtension
import eu.kanade.domain.source.service.SourcePreferences
import eu.kanade.tachiyomi.extension.api.ExtensionApi
import eu.kanade.tachiyomi.extension.api.ExtensionUpdateNotifier
import eu.kanade.tachiyomi.extension.model.Extension
import eu.kanade.tachiyomi.extension.model.InstallStep
@@ -33,6 +32,9 @@ import kotlinx.coroutines.flow.onStart
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
import logcat.LogPriority
import mihon.domain.extension.interactor.UpdateExtensionStores
import mihon.domain.extension.repository.ExtensionStoreRepository
import tachiyomi.core.common.util.lang.withIOContext
import tachiyomi.core.common.util.lang.withUIContext
import tachiyomi.core.common.util.system.logcat
import tachiyomi.domain.source.model.StubSource
@@ -52,7 +54,8 @@ class ExtensionManager(
private val context: Context,
private val preferences: SourcePreferences,
private val trustExtension: TrustExtension,
private val api: ExtensionApi,
private val extensionStoreRepository: ExtensionStoreRepository,
private val updateExtensionStores: UpdateExtensionStores,
private val installer: ExtensionInstaller,
private val extensionUpdateNotifier: ExtensionUpdateNotifier,
) {
@@ -156,7 +159,7 @@ class ExtensionManager(
.associateBy { it.pkgName }
// Newly loaded extensions have no status derived from the store index yet
updatedInstalledExtensionsStatuses(availableExtensionListFlow.value)
refreshStatuses()
} catch (e: Throwable) {
logcat(LogPriority.ERROR, e) { "Failed to load extensions" }
} finally {
@@ -166,21 +169,53 @@ class ExtensionManager(
}
/**
* Finds the available extensions in the [api] and updates [availableExtensionListFlow].
* Finds the available extensions in the stores and updates [availableExtensionListFlow].
*/
suspend fun findAvailableExtensions() {
val extensions: List<Extension.Available> = try {
api.findExtensions()
fetchExtensions()
} catch (e: Exception) {
logcat(LogPriority.ERROR, e)
withUIContext { context.toast(MR.strings.extension_api_error) }
return
}
setAvailableExtensions(extensions)
}
/**
* Refreshes the stores and their listings like [findAvailableExtensions], then notifies about the
* installed extensions that have an update. Stays silent when the stores can't be reached.
*/
suspend fun checkForUpdates() {
val extensions = try {
updateExtensionStores()
fetchExtensions()
} catch (e: Exception) {
logcat(LogPriority.ERROR, e)
return
}
initialized.await()
setAvailableExtensions(extensions)
val names = (loadedExtensionMapFlow.value.values + notLoadedExtensionMapFlow.value.values)
.filter { it.hasUpdate }
.map { it.name }
if (names.isNotEmpty()) {
extensionUpdateNotifier.promptUpdates(names)
}
}
private suspend fun fetchExtensions(): List<Extension.Available> {
return withIOContext { extensionStoreRepository.fetchExtensions() }
}
private fun setAvailableExtensions(extensions: List<Extension.Available>) {
enableAdditionalSubLanguages(extensions)
availableExtensionListFlow.value = extensions
updatedInstalledExtensionsStatuses(extensions)
refreshStatuses()
setupAvailableExtensionsSourcesDataMap(extensions)
}
@@ -214,26 +249,6 @@ class ExtensionManager(
subLanguagesEnabledOnFirstRun = true
}
/**
* Sets the update fields of the installed extensions, loaded or not, with the given [availableExtensions].
*
* @param availableExtensions The list of extensions given by the [api].
*/
private fun updatedInstalledExtensionsStatuses(availableExtensions: List<Extension.Available>) {
if (availableExtensions.isEmpty()) {
preferences.extensionUpdatesCount.set(0)
return
}
loadedExtensionMapFlow.value = loadedExtensionMapFlow.value.mapValues { (_, extension) ->
extension.withStatus(availableExtensions)
}
notLoadedExtensionMapFlow.value = notLoadedExtensionMapFlow.value.mapValues { (_, extension) ->
extension.withStatus(availableExtensions)
}
updatePendingUpdatesCount()
}
/**
* Returns a flow of the installation process for the given extension. It will complete
* once the extension is installed or throws an error. The process will be canceled if
@@ -324,15 +339,15 @@ class ExtensionManager(
private inner class InstallationListener : ExtensionInstallReceiver.Listener {
override fun onExtensionLoaded(extension: Extension.Loaded) {
registerExtension(extension.withStatus(availableExtensionListFlow.value))
registerExtension(extension)
notLoadedExtensionMapFlow.value -= extension.pkgName
updatePendingUpdatesCount()
refreshStatuses()
}
override fun onExtensionNotLoaded(extension: Extension.NotLoaded) {
loadedExtensionMapFlow.value -= extension.pkgName
notLoadedExtensionMapFlow.value += extension.withStatus(availableExtensionListFlow.value)
updatePendingUpdatesCount()
notLoadedExtensionMapFlow.value += extension
refreshStatuses()
}
override fun onPackageUninstalled(pkgName: String) {
@@ -343,29 +358,29 @@ class ExtensionManager(
}
/**
* Derives what the store listings say about an installed extension. Without any listing there's
* nothing to derive from, so it's left as is rather than being marked obsolete.
* Derives what the store listings say about every installed extension, loaded or not. Without any
* listing there's nothing to derive from, so they're left as they are rather than marked obsolete.
*/
private fun Extension.Loaded.withStatus(availableExtensions: List<Extension.Available>): Extension.Loaded {
if (availableExtensions.isEmpty()) return this
val listing = findListing(availableExtensions)
return copy(
hasUpdate = findUpdate(availableExtensions) != null,
isObsolete = listing == null,
)
}
/**
* An extension that isn't loaded can still be updated, which is often what gets it loaded again.
*/
private fun Extension.NotLoaded.withStatus(availableExtensions: List<Extension.Available>): Extension.NotLoaded {
if (availableExtensions.isEmpty()) return this
return copy(hasUpdate = findUpdate(availableExtensions) != null)
private fun refreshStatuses() {
val available = availableExtensionListFlow.value
if (available.isNotEmpty()) {
loadedExtensionMapFlow.value = loadedExtensionMapFlow.value.mapValues { (_, extension) ->
val listing = extension.findListing(available)
extension.copy(
hasUpdate = extension.findUpdate(available) != null,
isObsolete = listing == null,
)
}
notLoadedExtensionMapFlow.value = notLoadedExtensionMapFlow.value.mapValues { (_, extension) ->
extension.copy(hasUpdate = extension.findUpdate(available) != null)
}
}
updatePendingUpdatesCount()
}
private fun updatePendingUpdatesCount() {
val pendingUpdateCount = loadedExtensionMapFlow.value.values.count { it.hasUpdate } +
notLoadedExtensionMapFlow.value.values.count { it.hasUpdate }
val pendingUpdateCount = (loadedExtensionMapFlow.value.values + notLoadedExtensionMapFlow.value.values)
.count { it.hasUpdate }
preferences.extensionUpdatesCount.set(pendingUpdateCount)
if (pendingUpdateCount == 0) {
extensionUpdateNotifier.dismiss()