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
@@ -23,19 +23,12 @@ class GetExtensionsByType(
extensionManager.notLoadedExtensionsFlow, extensionManager.notLoadedExtensionsFlow,
extensionManager.availableExtensionsFlow, extensionManager.availableExtensionsFlow,
) { enabledLanguages, _loaded, _notLoaded, _available -> ) { enabledLanguages, _loaded, _notLoaded, _available ->
val (loadedUpdates, loaded) = _loaded val byName = compareBy<Extension, String>(String.CASE_INSENSITIVE_ORDER) { it.name }
.sortedWith(
compareBy<Extension.Loaded> { !it.isObsolete }
.thenBy(String.CASE_INSENSITIVE_ORDER) { it.name },
)
.partition { it.hasUpdate }
val (notLoadedUpdates, notLoaded) = _notLoaded val (loadedUpdates, loaded) = _loaded.partition { it.hasUpdate }
.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.name }) val (notLoadedUpdates, notLoaded) = _notLoaded.partition { it.hasUpdate }
.partition { it.hasUpdate }
val updates = (loadedUpdates + notLoadedUpdates) val updates = (loadedUpdates + notLoadedUpdates).sortedWith(byName)
.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.name })
val available = _available val available = _available
.filter { extension -> .filter { extension ->
@@ -54,9 +47,14 @@ class GetExtensionsByType(
) )
} }
} }
.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.name }) .sortedWith(byName)
Extensions(updates, loaded, available, notLoaded) Extensions(
updates = updates,
loaded = loaded.sortedWith(compareBy<Extension.Loaded> { !it.isObsolete }.then(byName)),
available = available,
notLoaded = notLoaded.sortedWith(byName),
)
} }
} }
} }
@@ -7,7 +7,6 @@ import dev.zacsweers.metro.Inject
import dev.zacsweers.metro.SingleIn import dev.zacsweers.metro.SingleIn
import eu.kanade.domain.extension.interactor.TrustExtension import eu.kanade.domain.extension.interactor.TrustExtension
import eu.kanade.domain.source.service.SourcePreferences 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.api.ExtensionUpdateNotifier
import eu.kanade.tachiyomi.extension.model.Extension import eu.kanade.tachiyomi.extension.model.Extension
import eu.kanade.tachiyomi.extension.model.InstallStep import eu.kanade.tachiyomi.extension.model.InstallStep
@@ -33,6 +32,9 @@ import kotlinx.coroutines.flow.onStart
import kotlinx.coroutines.flow.stateIn import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch import kotlinx.coroutines.launch
import logcat.LogPriority 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.lang.withUIContext
import tachiyomi.core.common.util.system.logcat import tachiyomi.core.common.util.system.logcat
import tachiyomi.domain.source.model.StubSource import tachiyomi.domain.source.model.StubSource
@@ -52,7 +54,8 @@ class ExtensionManager(
private val context: Context, private val context: Context,
private val preferences: SourcePreferences, private val preferences: SourcePreferences,
private val trustExtension: TrustExtension, private val trustExtension: TrustExtension,
private val api: ExtensionApi, private val extensionStoreRepository: ExtensionStoreRepository,
private val updateExtensionStores: UpdateExtensionStores,
private val installer: ExtensionInstaller, private val installer: ExtensionInstaller,
private val extensionUpdateNotifier: ExtensionUpdateNotifier, private val extensionUpdateNotifier: ExtensionUpdateNotifier,
) { ) {
@@ -156,7 +159,7 @@ class ExtensionManager(
.associateBy { it.pkgName } .associateBy { it.pkgName }
// Newly loaded extensions have no status derived from the store index yet // Newly loaded extensions have no status derived from the store index yet
updatedInstalledExtensionsStatuses(availableExtensionListFlow.value) refreshStatuses()
} catch (e: Throwable) { } catch (e: Throwable) {
logcat(LogPriority.ERROR, e) { "Failed to load extensions" } logcat(LogPriority.ERROR, e) { "Failed to load extensions" }
} finally { } 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() { suspend fun findAvailableExtensions() {
val extensions: List<Extension.Available> = try { val extensions: List<Extension.Available> = try {
api.findExtensions() fetchExtensions()
} catch (e: Exception) { } catch (e: Exception) {
logcat(LogPriority.ERROR, e) logcat(LogPriority.ERROR, e)
withUIContext { context.toast(MR.strings.extension_api_error) } withUIContext { context.toast(MR.strings.extension_api_error) }
return 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) enableAdditionalSubLanguages(extensions)
availableExtensionListFlow.value = extensions availableExtensionListFlow.value = extensions
updatedInstalledExtensionsStatuses(extensions) refreshStatuses()
setupAvailableExtensionsSourcesDataMap(extensions) setupAvailableExtensionsSourcesDataMap(extensions)
} }
@@ -214,26 +249,6 @@ class ExtensionManager(
subLanguagesEnabledOnFirstRun = true 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 * 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 * 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 { private inner class InstallationListener : ExtensionInstallReceiver.Listener {
override fun onExtensionLoaded(extension: Extension.Loaded) { override fun onExtensionLoaded(extension: Extension.Loaded) {
registerExtension(extension.withStatus(availableExtensionListFlow.value)) registerExtension(extension)
notLoadedExtensionMapFlow.value -= extension.pkgName notLoadedExtensionMapFlow.value -= extension.pkgName
updatePendingUpdatesCount() refreshStatuses()
} }
override fun onExtensionNotLoaded(extension: Extension.NotLoaded) { override fun onExtensionNotLoaded(extension: Extension.NotLoaded) {
loadedExtensionMapFlow.value -= extension.pkgName loadedExtensionMapFlow.value -= extension.pkgName
notLoadedExtensionMapFlow.value += extension.withStatus(availableExtensionListFlow.value) notLoadedExtensionMapFlow.value += extension
updatePendingUpdatesCount() refreshStatuses()
} }
override fun onPackageUninstalled(pkgName: String) { 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 * Derives what the store listings say about every installed extension, loaded or not. Without any
* nothing to derive from, so it's left as is rather than being marked obsolete. * 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 { private fun refreshStatuses() {
if (availableExtensions.isEmpty()) return this val available = availableExtensionListFlow.value
val listing = findListing(availableExtensions) if (available.isNotEmpty()) {
return copy( loadedExtensionMapFlow.value = loadedExtensionMapFlow.value.mapValues { (_, extension) ->
hasUpdate = findUpdate(availableExtensions) != null, val listing = extension.findListing(available)
isObsolete = listing == null, extension.copy(
) hasUpdate = extension.findUpdate(available) != null,
} isObsolete = listing == null,
)
/** }
* An extension that isn't loaded can still be updated, which is often what gets it loaded again. notLoadedExtensionMapFlow.value = notLoadedExtensionMapFlow.value.mapValues { (_, extension) ->
*/ extension.copy(hasUpdate = extension.findUpdate(available) != null)
private fun Extension.NotLoaded.withStatus(availableExtensions: List<Extension.Available>): Extension.NotLoaded { }
if (availableExtensions.isEmpty()) return this }
return copy(hasUpdate = findUpdate(availableExtensions) != null) updatePendingUpdatesCount()
} }
private fun updatePendingUpdatesCount() { private fun updatePendingUpdatesCount() {
val pendingUpdateCount = loadedExtensionMapFlow.value.values.count { it.hasUpdate } + val pendingUpdateCount = (loadedExtensionMapFlow.value.values + notLoadedExtensionMapFlow.value.values)
notLoadedExtensionMapFlow.value.values.count { it.hasUpdate } .count { it.hasUpdate }
preferences.extensionUpdatesCount.set(pendingUpdateCount) preferences.extensionUpdatesCount.set(pendingUpdateCount)
if (pendingUpdateCount == 0) { if (pendingUpdateCount == 0) {
extensionUpdateNotifier.dismiss() extensionUpdateNotifier.dismiss()
@@ -1,39 +0,0 @@
package eu.kanade.tachiyomi.extension.api
import dev.zacsweers.metro.AppScope
import dev.zacsweers.metro.Inject
import dev.zacsweers.metro.SingleIn
import eu.kanade.tachiyomi.extension.model.Extension
import mihon.domain.extension.interactor.UpdateExtensionStores
import mihon.domain.extension.repository.ExtensionStoreRepository
import tachiyomi.core.common.util.lang.withIOContext
@Inject
@SingleIn(AppScope::class)
class ExtensionApi(
private val repository: ExtensionStoreRepository,
private val updateExtensionStores: UpdateExtensionStores,
private val extensionUpdateNotifier: ExtensionUpdateNotifier,
) {
suspend fun findExtensions(): List<Extension.Available> {
return withIOContext { repository.fetchExtensions() }
}
/**
* @param installedExtensions Extensions already read by [eu.kanade.tachiyomi.extension.ExtensionManager],
* loaded or not. Only their versions and signatures are read, so there's nothing to gain from reading them
* a second time.
*/
suspend fun checkForUpdates(installedExtensions: List<Extension.Installed>) {
updateExtensionStores()
val extensions = findExtensions()
val extensionsWithUpdate = installedExtensions.filter { it.findUpdate(extensions) != null }
if (extensionsWithUpdate.isNotEmpty()) {
extensionUpdateNotifier.promptUpdates(extensionsWithUpdate.map { it.name })
}
}
}
@@ -80,7 +80,6 @@ import eu.kanade.tachiyomi.data.cache.ChapterCache
import eu.kanade.tachiyomi.data.download.DownloadCache import eu.kanade.tachiyomi.data.download.DownloadCache
import eu.kanade.tachiyomi.data.notification.NotificationReceiver import eu.kanade.tachiyomi.data.notification.NotificationReceiver
import eu.kanade.tachiyomi.extension.ExtensionManager import eu.kanade.tachiyomi.extension.ExtensionManager
import eu.kanade.tachiyomi.extension.api.ExtensionApi
import eu.kanade.tachiyomi.ui.base.activity.BaseActivity import eu.kanade.tachiyomi.ui.base.activity.BaseActivity
import eu.kanade.tachiyomi.ui.browse.source.browse.BrowseSourceScreen import eu.kanade.tachiyomi.ui.browse.source.browse.BrowseSourceScreen
import eu.kanade.tachiyomi.ui.browse.source.globalsearch.GlobalSearchScreen import eu.kanade.tachiyomi.ui.browse.source.globalsearch.GlobalSearchScreen
@@ -141,8 +140,6 @@ class MainActivity : BaseActivity() {
@Inject private lateinit var getIncognitoState: GetIncognitoState @Inject private lateinit var getIncognitoState: GetIncognitoState
@Inject private lateinit var extensionApi: ExtensionApi
@Inject private lateinit var extensionManager: ExtensionManager @Inject private lateinit var extensionManager: ExtensionManager
// To be checked by splash screen. If true then splash screen will be removed. // To be checked by splash screen. If true then splash screen will be removed.
@@ -342,9 +339,7 @@ class MainActivity : BaseActivity() {
// Extensions updates // Extensions updates
LaunchedEffect(Unit) { LaunchedEffect(Unit) {
try { try {
extensionApi.checkForUpdates( extensionManager.checkForUpdates()
extensionManager.getLoadedExtensions() + extensionManager.getNotLoadedExtensions(),
)
} catch (e: Exception) { } catch (e: Exception) {
logcat(LogPriority.ERROR, e) logcat(LogPriority.ERROR, e)
} }