Address firebase ktx module deprecation

- Extension being marked as not installed instead of untrusted after updating with private installer
- Extension update counter not updating due to extension being marked as untrusted
- Minimize `Key "extension-XXX-YYY" was already used` crash

app/src/main/java/eu/kanade/domain/DomainModule.kt

@@ -179,7 +179,7 @@ class DomainModule : InjektModule {
         addFactory { ToggleLanguage(get()) }
         addFactory { ToggleSource(get()) }
         addFactory { ToggleSourcePin(get()) }
-        addFactory { TrustExtension(get()) }
+        addFactory { TrustExtension(get(), get()) }
 
         addSingletonFactory<ExtensionRepoRepository> { ExtensionRepoRepositoryImpl(get()) }
         addFactory { ExtensionRepoService(get(), get()) }

app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensionsByType.kt

@@ -20,7 +20,7 @@ class GetExtensionsByType(
             extensionManager.installedExtensionsFlow,
             extensionManager.untrustedExtensionsFlow,
             extensionManager.availableExtensionsFlow,
-        ) { _activeLanguages, _installed, _untrusted, _available ->
+        ) { enabledLanguages, _installed, _untrusted, _available ->
             val (updates, installed) = _installed
                 .filter { (showNsfwSources || !it.isNsfw) }
                 .sortedWith(
@@ -40,9 +40,9 @@ class GetExtensionsByType(
                 }
                 .flatMap { ext ->
                     if (ext.sources.isEmpty()) {
-                        return@flatMap if (ext.lang in _activeLanguages) listOf(ext) else emptyList()
+                        return@flatMap if (ext.lang in enabledLanguages) listOf(ext) else emptyList()
                     }
-                    ext.sources.filter { it.lang in _activeLanguages }
+                    ext.sources.filter { it.lang in enabledLanguages }
                         .map {
                             ext.copy(
                                 name = it.name,

app/src/main/java/eu/kanade/domain/extension/interactor/TrustExtension.kt

@@ -3,15 +3,18 @@ package eu.kanade.domain.extension.interactor
 import android.content.pm.PackageInfo
 import androidx.core.content.pm.PackageInfoCompat
 import eu.kanade.domain.source.service.SourcePreferences
+import mihon.domain.extensionrepo.repository.ExtensionRepoRepository
 import tachiyomi.core.common.preference.getAndSet
 
 class TrustExtension(
+    private val extensionRepoRepository: ExtensionRepoRepository,
     private val preferences: SourcePreferences,
 ) {
 
-    fun isTrusted(pkgInfo: PackageInfo, signatureHash: String): Boolean {
-        val key = "${pkgInfo.packageName}:${PackageInfoCompat.getLongVersionCode(pkgInfo)}:$signatureHash"
-        return key in preferences.trustedExtensions().get()
+    suspend fun isTrusted(pkgInfo: PackageInfo, fingerprints: List<String>): Boolean {
+        val trustedFingerprints = extensionRepoRepository.getAll().map { it.signingKeyFingerprint }.toHashSet()
+        val key = "${pkgInfo.packageName}:${PackageInfoCompat.getLongVersionCode(pkgInfo)}:${fingerprints.last()}"
+        return trustedFingerprints.any { fingerprints.contains(it) } || key in preferences.trustedExtensions().get()
     }
 
     fun trust(pkgName: String, versionCode: Long, signatureHash: String) {
@@ -19,9 +22,7 @@ class TrustExtension(
             // Remove previously trusted versions
             val removed = exts.filterNot { it.startsWith("$pkgName:") }.toMutableSet()
 
-            removed.also {
-                it += "$pkgName:$versionCode:$signatureHash"
-            }
+            removed.also { it += "$pkgName:$versionCode:$signatureHash" }
         }
     }
 

app/src/main/java/eu/kanade/tachiyomi/extension/ExtensionManager.kt

@@ -13,14 +13,17 @@ import eu.kanade.tachiyomi.extension.util.ExtensionInstallReceiver
 import eu.kanade.tachiyomi.extension.util.ExtensionInstaller
 import eu.kanade.tachiyomi.extension.util.ExtensionLoader
 import eu.kanade.tachiyomi.util.system.toast
-import kotlinx.coroutines.async
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
 import logcat.LogPriority
-import tachiyomi.core.common.util.lang.launchNow
 import tachiyomi.core.common.util.lang.withUIContext
 import tachiyomi.core.common.util.system.logcat
 import tachiyomi.domain.source.model.StubSource
@@ -42,6 +45,8 @@ class ExtensionManager(
     private val trustExtension: TrustExtension = Injekt.get(),
 ) {
 
+    val scope = CoroutineScope(SupervisorJob())
+
     private val _isInitialized = MutableStateFlow(false)
     val isInitialized: StateFlow<Boolean> = _isInitialized.asStateFlow()
 
@@ -57,24 +62,35 @@ class ExtensionManager(
 
     private val iconMap = mutableMapOf<String, Drawable>()
 
-    private val _installedExtensionsFlow = MutableStateFlow(emptyList<Extension.Installed>())
-    val installedExtensionsFlow = _installedExtensionsFlow.asStateFlow()
+    private val _installedExtensionsMapFlow = MutableStateFlow(emptyMap<String, Extension.Installed>())
+    val installedExtensionsFlow = _installedExtensionsMapFlow.mapExtensions(scope)
+
+    private val _availableExtensionsMapFlow = MutableStateFlow(emptyMap<String, Extension.Available>())
+    val availableExtensionsFlow = _availableExtensionsMapFlow.mapExtensions(scope)
+
+    private val _untrustedExtensionsMapFlow = MutableStateFlow(emptyMap<String, Extension.Untrusted>())
+    val untrustedExtensionsFlow = _untrustedExtensionsMapFlow.mapExtensions(scope)
+
+    init {
+        initExtensions()
+        ExtensionInstallReceiver(InstallationListener()).register(context)
+    }
 
     private var subLanguagesEnabledOnFirstRun = preferences.enabledLanguages().isSet()
 
     fun getAppIconForSource(sourceId: Long): Drawable? {
-        val pkgName = _installedExtensionsFlow.value.find { ext -> ext.sources.any { it.id == sourceId } }?.pkgName
-        if (pkgName != null) {
-            return iconMap[pkgName] ?: iconMap.getOrPut(pkgName) {
-                ExtensionLoader.getExtensionPackageInfoFromPkgName(context, pkgName)!!.applicationInfo
-                    .loadIcon(context.packageManager)
+        val pkgName = _installedExtensionsMapFlow.value.values
+            .find { ext ->
+                ext.sources.any { it.id == sourceId }
             }
-        }
-        return null
-    }
+            ?.pkgName
+            ?: return null
 
-    private val _availableExtensionsFlow = MutableStateFlow(emptyList<Extension.Available>())
-    val availableExtensionsFlow = _availableExtensionsFlow.asStateFlow()
+        return iconMap[pkgName] ?: iconMap.getOrPut(pkgName) {
+            ExtensionLoader.getExtensionPackageInfoFromPkgName(context, pkgName)!!.applicationInfo
+                .loadIcon(context.packageManager)
+        }
+    }
 
     private var availableExtensionsSourcesData: Map<Long, StubSource> = emptyMap()
 
@@ -87,33 +103,25 @@ class ExtensionManager(
 
     fun getSourceData(id: Long) = availableExtensionsSourcesData[id]
 
-    private val _untrustedExtensionsFlow = MutableStateFlow(emptyList<Extension.Untrusted>())
-    val untrustedExtensionsFlow = _untrustedExtensionsFlow.asStateFlow()
-
-    init {
-        initExtensions()
-        ExtensionInstallReceiver(InstallationListener()).register(context)
-    }
-
     /**
      * Loads and registers the installed extensions.
      */
     private fun initExtensions() {
         val extensions = ExtensionLoader.loadExtensions(context)
 
-        _installedExtensionsFlow.value = extensions
+        _installedExtensionsMapFlow.value = extensions
             .filterIsInstance<LoadResult.Success>()
-            .map { it.extension }
+            .associate { it.extension.pkgName to it.extension }
 
-        _untrustedExtensionsFlow.value = extensions
+        _untrustedExtensionsMapFlow.value = extensions
             .filterIsInstance<LoadResult.Untrusted>()
-            .map { it.extension }
+            .associate { it.extension.pkgName to it.extension }
 
         _isInitialized.value = true
     }
 
     /**
-     * Finds the available extensions in the [api] and updates [availableExtensions].
+     * Finds the available extensions in the [api] and updates [_availableExtensionsMapFlow].
      */
     suspend fun findAvailableExtensions() {
         val extensions: List<Extension.Available> = try {
@@ -126,7 +134,7 @@ class ExtensionManager(
 
         enableAdditionalSubLanguages(extensions)
 
-        _availableExtensionsFlow.value = extensions
+        _availableExtensionsMapFlow.value = extensions.associateBy { it.pkgName }
         updatedInstalledExtensionsStatuses(extensions)
         setupAvailableExtensionsSourcesDataMap(extensions)
     }
@@ -172,35 +180,31 @@ class ExtensionManager(
             return
         }
 
-        val mutInstalledExtensions = _installedExtensionsFlow.value.toMutableList()
+        val installedExtensionsMap = _installedExtensionsMapFlow.value.toMutableMap()
         var changed = false
-
-        for ((index, installedExt) in mutInstalledExtensions.withIndex()) {
-            val pkgName = installedExt.pkgName
+        for ((pkgName, extension) in installedExtensionsMap) {
             val availableExt = availableExtensions.find { it.pkgName == pkgName }
 
-            if (availableExt == null && !installedExt.isObsolete) {
-                mutInstalledExtensions[index] = installedExt.copy(isObsolete = true)
+            if (availableExt == null && !extension.isObsolete) {
+                installedExtensionsMap[pkgName] = extension.copy(isObsolete = true)
                 changed = true
             } else if (availableExt != null) {
-                val hasUpdate = installedExt.updateExists(availableExt)
-
-                if (installedExt.hasUpdate != hasUpdate) {
-                    mutInstalledExtensions[index] = installedExt.copy(
+                val hasUpdate = extension.updateExists(availableExt)
+                if (extension.hasUpdate != hasUpdate) {
+                    installedExtensionsMap[pkgName] = extension.copy(
                         hasUpdate = hasUpdate,
                         repoUrl = availableExt.repoUrl,
                     )
-                    changed = true
                 } else {
-                    mutInstalledExtensions[index] = installedExt.copy(
+                    installedExtensionsMap[pkgName] = extension.copy(
                         repoUrl = availableExt.repoUrl,
                     )
-                    changed = true
                 }
+                changed = true
             }
         }
         if (changed) {
-            _installedExtensionsFlow.value = mutInstalledExtensions
+            _installedExtensionsMapFlow.value = installedExtensionsMap
         }
         updatePendingUpdatesCount()
     }
@@ -224,8 +228,7 @@ class ExtensionManager(
      * @param extension The extension to be updated.
      */
     fun updateExtension(extension: Extension.Installed): Flow<InstallStep> {
-        val availableExt = _availableExtensionsFlow.value.find { it.pkgName == extension.pkgName }
-            ?: return emptyFlow()
+        val availableExt = _availableExtensionsMapFlow.value[extension.pkgName] ?: return emptyFlow()
         return installExtension(availableExt)
     }
 
@@ -261,24 +264,16 @@ class ExtensionManager(
      *
      * @param extension the extension to trust
      */
-    fun trust(extension: Extension.Untrusted) {
-        val untrustedPkgNames = _untrustedExtensionsFlow.value.map { it.pkgName }.toSet()
-        if (extension.pkgName !in untrustedPkgNames) return
+    suspend fun trust(extension: Extension.Untrusted) {
+        _untrustedExtensionsMapFlow.value[extension.pkgName] ?: return
 
         trustExtension.trust(extension.pkgName, extension.versionCode, extension.signatureHash)
 
-        val nowTrustedExtensions = _untrustedExtensionsFlow.value
-            .filter { it.pkgName == extension.pkgName && it.versionCode == extension.versionCode }
-        _untrustedExtensionsFlow.value -= nowTrustedExtensions
+        _untrustedExtensionsMapFlow.value -= extension.pkgName
 
-        launchNow {
-            nowTrustedExtensions
-                .map { extension ->
-                    async { ExtensionLoader.loadExtensionFromPkgName(context, extension.pkgName) }.await()
-                }
-                .filterIsInstance<LoadResult.Success>()
-                .forEach { registerNewExtension(it.extension) }
-        }
+        ExtensionLoader.loadExtensionFromPkgName(context, extension.pkgName)
+            .let { it as? LoadResult.Success }
+            ?.let { registerNewExtension(it.extension) }
     }
 
     /**
@@ -287,7 +282,7 @@ class ExtensionManager(
      * @param extension The extension to be registered.
      */
     private fun registerNewExtension(extension: Extension.Installed) {
-        _installedExtensionsFlow.value += extension
+        _installedExtensionsMapFlow.value += extension
     }
 
     /**
@@ -297,13 +292,7 @@ class ExtensionManager(
      * @param extension The extension to be registered.
      */
     private fun registerUpdatedExtension(extension: Extension.Installed) {
-        val mutInstalledExtensions = _installedExtensionsFlow.value.toMutableList()
-        val oldExtension = mutInstalledExtensions.find { it.pkgName == extension.pkgName }
-        if (oldExtension != null) {
-            mutInstalledExtensions -= oldExtension
-        }
-        mutInstalledExtensions += extension
-        _installedExtensionsFlow.value = mutInstalledExtensions
+        _installedExtensionsMapFlow.value += extension
     }
 
     /**
@@ -313,14 +302,8 @@ class ExtensionManager(
      * @param pkgName The package name of the uninstalled application.
      */
     private fun unregisterExtension(pkgName: String) {
-        val installedExtension = _installedExtensionsFlow.value.find { it.pkgName == pkgName }
-        if (installedExtension != null) {
-            _installedExtensionsFlow.value -= installedExtension
-        }
-        val untrustedExtension = _untrustedExtensionsFlow.value.find { it.pkgName == pkgName }
-        if (untrustedExtension != null) {
-            _untrustedExtensionsFlow.value -= untrustedExtension
-        }
+        _installedExtensionsMapFlow.value -= pkgName
+        _untrustedExtensionsMapFlow.value -= pkgName
     }
 
     /**
@@ -339,14 +322,9 @@ class ExtensionManager(
         }
 
         override fun onExtensionUntrusted(extension: Extension.Untrusted) {
-            val installedExtension = _installedExtensionsFlow.value
-                .find { it.pkgName == extension.pkgName }
-
-            if (installedExtension != null) {
-                _installedExtensionsFlow.value -= installedExtension
-            } else {
-                _untrustedExtensionsFlow.value += extension
-            }
+            _installedExtensionsMapFlow.value -= extension.pkgName
+            _untrustedExtensionsMapFlow.value += extension
+            updatePendingUpdatesCount()
         }
 
         override fun onPackageUninstalled(pkgName: String) {
@@ -368,17 +346,24 @@ class ExtensionManager(
     }
 
     private fun Extension.Installed.updateExists(availableExtension: Extension.Available? = null): Boolean {
-        val availableExt = availableExtension ?: _availableExtensionsFlow.value.find { it.pkgName == pkgName }
+        val availableExt = availableExtension
+            ?: _availableExtensionsMapFlow.value[pkgName]
             ?: return false
 
         return (availableExt.versionCode > versionCode || availableExt.libVersion > libVersion)
     }
 
     private fun updatePendingUpdatesCount() {
-        val pendingUpdateCount = _installedExtensionsFlow.value.count { it.hasUpdate }
+        val pendingUpdateCount = _installedExtensionsMapFlow.value.values.count { it.hasUpdate }
         preferences.extensionUpdatesCount().set(pendingUpdateCount)
         if (pendingUpdateCount == 0) {
             ExtensionUpdateNotifier(context).dismiss()
         }
     }
+
+    private operator fun <T : Extension> Map<String, T>.plus(extension: T) = plus(extension.pkgName to extension)
+
+    private fun <T : Extension> StateFlow<Map<String, T>>.mapExtensions(scope: CoroutineScope): StateFlow<List<T>> {
+        return map { it.values.toList() }.stateIn(scope, SharingStarted.Lazily, value.values.toList())
+    }
 }

app/src/main/java/eu/kanade/tachiyomi/extension/util/ExtensionInstallReceiver.kt

@@ -9,12 +9,10 @@ import androidx.core.content.ContextCompat
 import eu.kanade.tachiyomi.BuildConfig
 import eu.kanade.tachiyomi.extension.model.Extension
 import eu.kanade.tachiyomi.extension.model.LoadResult
-import kotlinx.coroutines.CoroutineStart
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.async
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
 import logcat.LogPriority
-import tachiyomi.core.common.util.lang.launchNow
 import tachiyomi.core.common.util.system.logcat
 
 /**
@@ -23,29 +21,23 @@ import tachiyomi.core.common.util.system.logcat
  *
  * @param listener The listener that should be notified of extension installation events.
  */
-internal class ExtensionInstallReceiver(private val listener: Listener) :
-    BroadcastReceiver() {
+internal class ExtensionInstallReceiver(private val listener: Listener) : BroadcastReceiver() {
+
+    val scope = CoroutineScope(SupervisorJob())
 
-    /**
-     * Registers this broadcast receiver
-     */
     fun register(context: Context) {
         ContextCompat.registerReceiver(context, this, filter, ContextCompat.RECEIVER_NOT_EXPORTED)
     }
 
-    /**
-     * Returns the intent filter this receiver should subscribe to.
-     */
-    private val filter
-        get() = IntentFilter().apply {
-            addAction(Intent.ACTION_PACKAGE_ADDED)
-            addAction(Intent.ACTION_PACKAGE_REPLACED)
-            addAction(Intent.ACTION_PACKAGE_REMOVED)
-            addAction(ACTION_EXTENSION_ADDED)
-            addAction(ACTION_EXTENSION_REPLACED)
-            addAction(ACTION_EXTENSION_REMOVED)
-            addDataScheme("package")
-        }
+    private val filter = IntentFilter().apply {
+        addAction(Intent.ACTION_PACKAGE_ADDED)
+        addAction(Intent.ACTION_PACKAGE_REPLACED)
+        addAction(Intent.ACTION_PACKAGE_REMOVED)
+        addAction(ACTION_EXTENSION_ADDED)
+        addAction(ACTION_EXTENSION_REPLACED)
+        addAction(ACTION_EXTENSION_REMOVED)
+        addDataScheme("package")
+    }
 
     /**
      * Called when one of the events of the [filter] is received. When the package is an extension,
@@ -58,7 +50,7 @@ internal class ExtensionInstallReceiver(private val listener: Listener) :
             Intent.ACTION_PACKAGE_ADDED, ACTION_EXTENSION_ADDED -> {
                 if (isReplacing(intent)) return
 
-                launchNow {
+                scope.launch {
                     when (val result = getExtensionFromIntent(context, intent)) {
                         is LoadResult.Success -> listener.onExtensionInstalled(result.extension)
                         is LoadResult.Untrusted -> listener.onExtensionUntrusted(result.extension)
@@ -67,7 +59,7 @@ internal class ExtensionInstallReceiver(private val listener: Listener) :
                 }
             }
             Intent.ACTION_PACKAGE_REPLACED, ACTION_EXTENSION_REPLACED -> {
-                launchNow {
+                scope.launch {
                     when (val result = getExtensionFromIntent(context, intent)) {
                         is LoadResult.Success -> listener.onExtensionUpdated(result.extension)
                         is LoadResult.Untrusted -> listener.onExtensionUntrusted(result.extension)
@@ -107,9 +99,7 @@ internal class ExtensionInstallReceiver(private val listener: Listener) :
             logcat(LogPriority.WARN) { "Package name not found" }
             return LoadResult.Error
         }
-        return GlobalScope.async(Dispatchers.Default, CoroutineStart.DEFAULT) {
-            ExtensionLoader.loadExtensionFromPkgName(context, pkgName)
-        }.await()
+        return ExtensionLoader.loadExtensionFromPkgName(context, pkgName)
     }
 
     /**

app/src/main/java/eu/kanade/tachiyomi/extension/util/ExtensionLoader.kt

@@ -172,7 +172,7 @@ internal object ExtensionLoader {
      * Attempts to load an extension from the given package name. It checks if the extension
      * contains the required feature flag before trying to load it.
      */
-    fun loadExtensionFromPkgName(context: Context, pkgName: String): LoadResult {
+    suspend fun loadExtensionFromPkgName(context: Context, pkgName: String): LoadResult {
         val extensionPackage = getExtensionInfoFromPkgName(context, pkgName)
         if (extensionPackage == null) {
             logcat(LogPriority.ERROR) { "Extension package is not found ($pkgName)" }
@@ -223,7 +223,8 @@ internal object ExtensionLoader {
      * @param context The application context.
      * @param extensionInfo The extension to load.
      */
-    private fun loadExtension(context: Context, extensionInfo: ExtensionInfo): LoadResult {
+    @Suppress("LongMethod", "CyclomaticComplexMethod", "ReturnCount")
+    private suspend fun loadExtension(context: Context, extensionInfo: ExtensionInfo): LoadResult {
         val pkgManager = context.packageManager
         val pkgInfo = extensionInfo.packageInfo
         val appInfo = pkgInfo.applicationInfo
@@ -252,7 +253,7 @@ internal object ExtensionLoader {
         if (signatures.isNullOrEmpty()) {
             logcat(LogPriority.WARN) { "Package $pkgName isn't signed" }
             return LoadResult.Error
-        } else if (!trustExtension.isTrusted(pkgInfo, signatures.last())) {
+        } else if (!trustExtension.isTrusted(pkgInfo, signatures)) {
             val extension = Extension.Untrusted(
                 extName,
                 pkgName,

app/src/main/java/eu/kanade/tachiyomi/ui/browse/extension/ExtensionsScreenModel.kt

@@ -27,6 +27,7 @@ import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onCompletion
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
 import tachiyomi.core.common.util.lang.launchIO
 import tachiyomi.i18n.MR
 import uy.kohesive.injekt.Injekt
@@ -196,7 +197,9 @@ class ExtensionsScreenModel(
     }
 
     fun trustExtension(extension: Extension.Untrusted) {
-        extensionManager.trust(extension)
+        screenModelScope.launch {
+            extensionManager.trust(extension)
+        }
     }
 
     @Immutable

gradle/compose.versions.toml

@@ -1,5 +1,5 @@
 [versions]
-compiler = "1.5.13"
+compiler = "1.5.12"
 # 2024.04.00-alpha01 has several bugs with the new animateItem() modifier
 compose-bom = "2024.03.00-alpha02"
 accompanist = "0.35.0-alpha"

gradle/libs.versions.toml

@@ -73,7 +73,7 @@ moko-gradle = { module = "dev.icerock.moko:resources-generator", version.ref = "
 
 logcat = "com.squareup.logcat:logcat:0.1"
 
-firebase-analytics = "com.google.firebase:firebase-analytics-ktx:21.6.2"
+firebase-analytics = "com.google.firebase:firebase-analytics:22.0.0"
 
 aboutLibraries-gradle = { module = "com.mikepenz.aboutlibraries.plugin:aboutlibraries-plugin", version.ref = "aboutlib_version" }
 aboutLibraries-compose = { module = "com.mikepenz:aboutlibraries-compose-m3", version.ref = "aboutlib_version" }