fix: speed up pubky profile loading

app/src/main/java/to/bitkit/data/PubkyImageCacheEpoch.kt

@@ -0,0 +1,22 @@
+package to.bitkit.data
+
+import java.util.concurrent.atomic.AtomicLong
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Counts clears of the Pubky image disk cache. [PubkyImageFetcher] reads it before a network fetch and commits
+ * the fetched image only while it is unchanged, so a fetch in flight across a clear cannot re-populate the
+ * cleared directory, and [PubkyImageFailureCache] forgets every failed fetch once it changes. Advance it before
+ * clearing the directory.
+ */
+@Singleton
+class PubkyImageCacheEpoch @Inject constructor() {
+    private val epoch = AtomicLong(0L)
+
+    fun current(): Long = epoch.get()
+
+    fun advance() {
+        epoch.incrementAndGet()
+    }
+}

app/src/main/java/to/bitkit/data/PubkyImageFetcher.kt

@@ -4,51 +4,171 @@ import coil3.ImageLoader
 import coil3.Uri
 import coil3.decode.DataSource
 import coil3.decode.ImageSource
+import coil3.disk.DiskCache
 import coil3.fetch.FetchResult
 import coil3.fetch.Fetcher
 import coil3.fetch.SourceFetchResult
 import coil3.request.Options
+import com.synonym.paykit.PaykitException
 import okio.Buffer
 import org.json.JSONObject
+import to.bitkit.ext.nowMs
 import to.bitkit.ext.runSuspendCatching
+import to.bitkit.models.PubkyPublicKeyFormat
+import to.bitkit.services.PubkyFileNotFoundError
 import to.bitkit.services.PubkyService
+import to.bitkit.utils.AppError
 import to.bitkit.utils.Logger
+import kotlin.coroutines.cancellation.CancellationException
+import kotlin.time.Clock
+import kotlin.time.Duration.Companion.seconds
 
 private const val TAG = "PubkyImageFetcher"
 private const val PUBKY_SCHEME = "pubky://"
 
 /** Maximum successful response body accepted for a displayed Pubky image. */
 internal const val PUBKY_IMAGE_MAX_BYTES = 1_048_576uL
 
+/** How long a Pubky image whose fetch failed for a reason that can pass, such as a network error, is not fetched. */
+internal val PUBKY_IMAGE_TRANSIENT_FAILURE_TTL = 60.seconds
+
 class PubkyImageFetcher(
     private val uri: String,
     private val options: Options,
     private val pubkyService: PubkyService,
+    private val diskCache: DiskCache?,
+    private val cacheEpoch: PubkyImageCacheEpoch,
+    private val failures: PubkyImageFailureCache,
 ) : Fetcher {
+    private val diskCacheKey = options.diskCacheKey ?: uri
 
     override suspend fun fetch(): FetchResult {
-        val data = pubkyService.fetchFile(uri, PUBKY_IMAGE_MAX_BYTES)
-        val blobData = resolveImageData(data)
-        val source = ImageSource(Buffer().apply { write(blobData) }, options.fileSystem)
+        readFromDiskCache()?.let { return it }
+        failures.recentFailure(uri)?.let { throw PubkyImageRecentlyFailedError(it) }
+
+        val epoch = cacheEpoch.current()
+        val data = runSuspendCatching { pubkyService.fetchFile(uri, PUBKY_IMAGE_MAX_BYTES) }
+            .onFailure { failures.remember(uri, it, epoch) }
+            .getOrThrow()
+        val image = resolveImageData(data, epoch)
+        if (image.isCacheable) writeToDiskCache(image.bytes, epoch)
+        val source = ImageSource(Buffer().apply { write(image.bytes) }, options.fileSystem)
         return SourceFetchResult(source, null, dataSource = DataSource.NETWORK)
     }
 
-    private suspend fun resolveImageData(data: ByteArray): ByteArray = runSuspendCatching {
-        val json = JSONObject(String(data))
-        val src = json.optString("src", "")
-        if (src.isNotEmpty() && src.startsWith(PUBKY_SCHEME)) {
-            Logger.debug("Found file descriptor, fetching blob from '$src'", context = TAG)
-            pubkyService.fetchFile(src, PUBKY_IMAGE_MAX_BYTES)
-        } else {
-            data
+    private suspend fun readFromDiskCache(): FetchResult? {
+        if (!options.diskCachePolicy.readEnabled) return null
+        val cache = diskCache ?: return null
+        val snapshot = runSuspendCatching { cache.openSnapshot(diskCacheKey) }
+            .onFailure { Logger.warn("Failed to read pubky image from disk cache", it, context = TAG) }
+            .getOrNull()
+            ?: return null
+        val source = ImageSource(snapshot.data, cache.fileSystem, diskCacheKey, snapshot)
+        return SourceFetchResult(source, null, dataSource = DataSource.DISK)
+    }
+
+    private suspend fun writeToDiskCache(bytes: ByteArray, epoch: Long) {
+        if (!options.diskCachePolicy.writeEnabled) return
+        val cache = diskCache ?: return
+        val editor = runSuspendCatching { cache.openEditor(diskCacheKey) }
+            .onFailure { Logger.warn("Failed to open pubky image disk cache editor", it, context = TAG) }
+            .getOrNull()
+            ?: return
+        runCatching {
+            cache.fileSystem.write(editor.data) { write(bytes) }
+            // The editor is open, so a clear after this check makes evictAll() zombie the entry and drop the commit.
+            if (cacheEpoch.current() == epoch) editor.commit() else editor.abort()
+        }.onFailure {
+            runCatching { editor.abort() }
+            if (it is CancellationException) throw it
+            Logger.warn("Failed to cache pubky image", it, context = TAG)
         }
-    }.getOrDefault(data)
+    }
+
+    private suspend fun resolveImageData(data: ByteArray, epoch: Long): PubkyImageData {
+        val descriptor = runSuspendCatching { JSONObject(String(data)) }.getOrNull()
+            ?: return PubkyImageData(data, isCacheable = true)
+        val src = descriptor.optString("src", "")
+        if (!src.startsWith(PUBKY_SCHEME)) return PubkyImageData(data, isCacheable = false)
+
+        Logger.debug("Found file descriptor, fetching blob from '${PubkyPublicKeyFormat.redacted(src)}'", context = TAG)
+        return runSuspendCatching { pubkyService.fetchFile(src, PUBKY_IMAGE_MAX_BYTES) }
+            .map { PubkyImageData(it, isCacheable = true) }
+            .onFailure {
+                Logger.warn("Failed to fetch pubky image blob", it, context = TAG)
+                failures.remember(uri, it, epoch)
+            }
+            .getOrDefault(PubkyImageData(data, isCacheable = false))
+    }
+
+    class Factory(
+        private val pubkyService: PubkyService,
+        private val cacheEpoch: PubkyImageCacheEpoch,
+        clock: Clock,
+    ) : Fetcher.Factory<Uri> {
+        private val failures = PubkyImageFailureCache(cacheEpoch, clock)
 
-    class Factory(private val pubkyService: PubkyService) : Fetcher.Factory<Uri> {
         override fun create(data: Uri, options: Options, imageLoader: ImageLoader): Fetcher? {
             val uri = data.toString()
             if (!uri.startsWith(PUBKY_SCHEME)) return null
-            return PubkyImageFetcher(uri, options, pubkyService)
+            return PubkyImageFetcher(uri, options, pubkyService, imageLoader.diskCache, cacheEpoch, failures)
+        }
+    }
+}
+
+/**
+ * Remembers failed Pubky image fetches by URI, so an image that cannot load is not fetched again each time it is
+ * shown. A missing file, a file over [PUBKY_IMAGE_MAX_BYTES] or another invalid response is remembered until the
+ * image cache is next cleared, and any other failure for [PUBKY_IMAGE_TRANSIENT_FAILURE_TTL]. A clear of the image
+ * cache, which advances [PubkyImageCacheEpoch] on sign-out and identity change, forgets every failure, and a failure
+ * of a fetch that a clear overtook is not remembered. For a file descriptor, a failed blob fetch counts as a failure
+ * of the descriptor URI.
+ */
+class PubkyImageFailureCache(
+    private val cacheEpoch: PubkyImageCacheEpoch,
+    private val clock: Clock,
+) {
+    private val lock = Any()
+    private val failures = mutableMapOf<String, Failure>()
+    private var failuresEpoch = cacheEpoch.current()
+
+    fun recentFailure(uri: String): Throwable? = synchronized(lock) {
+        forgetIfCleared()
+        val failure = failures[uri] ?: return null
+        if (failure.expiresAtMillis != null && clock.nowMs() >= failure.expiresAtMillis) {
+            failures.remove(uri)
+            return null
+        }
+        failure.error
+    }
+
+    fun remember(uri: String, error: Throwable, epoch: Long) {
+        synchronized(lock) {
+            forgetIfCleared()
+            if (epoch != failuresEpoch) return
+            val expiresAtMillis = if (error.isPermanentImageFailure()) {
+                null
+            } else {
+                clock.nowMs() + PUBKY_IMAGE_TRANSIENT_FAILURE_TTL.inWholeMilliseconds
+            }
+            failures[uri] = Failure(error, expiresAtMillis)
         }
     }
+
+    private fun forgetIfCleared() {
+        val epoch = cacheEpoch.current()
+        if (epoch == failuresEpoch) return
+        failures.clear()
+        failuresEpoch = epoch
+    }
+
+    private fun Throwable.isPermanentImageFailure(): Boolean = generateSequence(this) { it.cause }.any {
+        it is PubkyFileNotFoundError || it is PaykitException.NotFound || it is PaykitException.Protocol
+    }
+
+    private class Failure(val error: Throwable, val expiresAtMillis: Long?)
 }
+
+class PubkyImageRecentlyFailedError(cause: Throwable) : AppError("Pubky image fetch failed recently", cause)
+
+private class PubkyImageData(val bytes: ByteArray, val isCacheable: Boolean)

app/src/main/java/to/bitkit/data/PubkyStore.kt

@@ -36,7 +36,19 @@ class PubkyStore @Inject constructor(
 @Serializable
 data class PubkyStoreData(
     val ownerPublicKey: String? = null,
+    /** Public key whose profile [cachedName] and [cachedImageUri] were cached from. */
+    val cachedProfileOwner: String? = null,
     val cachedName: String? = null,
     val cachedImageUri: String? = null,
     val contactProfileOverrides: Map<String, PubkyProfileData> = emptyMap(),
+) {
+    fun cachedProfile(): PubkyCachedProfile? = cachedProfileOwner?.let {
+        PubkyCachedProfile(publicKey = it, name = cachedName.orEmpty(), imageUri = cachedImageUri)
+    }
+}
+
+data class PubkyCachedProfile(
+    val publicKey: String,
+    val name: String,
+    val imageUri: String?,
 )

app/src/main/java/to/bitkit/di/ImageModule.kt

@@ -11,9 +11,11 @@ import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
+import to.bitkit.data.PubkyImageCacheEpoch
 import to.bitkit.data.PubkyImageFetcher
 import to.bitkit.services.PubkyService
 import javax.inject.Singleton
+import kotlin.time.Clock
 
 @Module
 @InstallIn(SingletonComponent::class)
@@ -24,9 +26,11 @@ object ImageModule {
     fun provideImageLoader(
         @ApplicationContext context: Context,
         pubkyService: PubkyService,
+        cacheEpoch: PubkyImageCacheEpoch,
+        clock: Clock,
     ): ImageLoader = ImageLoader.Builder(context)
         .crossfade(true)
-        .components { add(PubkyImageFetcher.Factory(pubkyService)) }
+        .components { add(PubkyImageFetcher.Factory(pubkyService, cacheEpoch, clock)) }
         .memoryCache {
             MemoryCache.Builder()
                 .maxSizePercent(context, percent = 0.15)

app/src/main/java/to/bitkit/repositories/PaykitPaymentRequestRepo.kt

@@ -46,6 +46,7 @@ import to.bitkit.models.PubkyPublicKeyFormat
 import to.bitkit.models.satsToMsat
 import to.bitkit.services.PaykitPaymentRequestProposalTerms
 import to.bitkit.services.PaykitPaymentRequestRecurrenceTerms
+import to.bitkit.services.PaykitReadLane
 import to.bitkit.services.PaykitReceiverPaths
 import to.bitkit.services.PaykitSdkService
 import to.bitkit.utils.AppError
@@ -458,7 +459,7 @@ class PaykitPaymentRequestRepo @Inject constructor(
                     val context = targetContext(savedPublicKeys, expectedIdentity)
                     if (!force && context == cachedTargetContext) return@discovery
                     val previousTargets = _eligibleTargets.value.associateBy { it.publicKey }
-                    val discovery = context?.let { eligibleTargets(it, previousTargets) }
+                    val discovery = context?.let { eligibleTargets(it, previousTargets, PaykitReadLane.Bulk) }
                         ?: PaykitPaymentRequestTargetDiscovery(emptyList(), isComplete = true)
                     operationMutex.withLock operation@{
                         if (!isCurrentState(generation, expectedIdentity)) return@operation
@@ -1085,13 +1086,14 @@ class PaykitPaymentRequestRepo @Inject constructor(
     private suspend fun eligibleTargets(
         context: PaykitPaymentRequestTargetContext,
         previousTargets: Map<String, PaykitPaymentRequestTarget> = emptyMap(),
+        lane: PaykitReadLane = PaykitReadLane.Interactive,
     ): PaykitPaymentRequestTargetDiscovery {
         var isComplete = true
         val failedPublicKeys = mutableSetOf<String>()
         val targets = context.savedPublicKeys.mapNotNull { publicKey ->
             val linked = context.linkedReceiverPaths[publicKey] ?: return@mapNotNull null
             val lookup = withTimeoutOrNull(TARGET_DISCOVERY_TIMEOUT) {
-                runSuspendCatching { paykitSdkService.paymentRequestReceiverPaths(publicKey) }
+                runSuspendCatching { paykitSdkService.paymentRequestReceiverPaths(publicKey, lane) }
             }
             if (lookup == null) {
                 isComplete = false

app/src/main/java/to/bitkit/repositories/PrivatePaykitRepo.kt

@@ -43,6 +43,7 @@ import to.bitkit.models.PubkyPublicKeyFormat
 import to.bitkit.services.CoreService
 import to.bitkit.services.PaykitPreparedPrivateContactPayment
 import to.bitkit.services.PaykitPrivateContactPaymentResolution
+import to.bitkit.services.PaykitReadLane
 import to.bitkit.services.PaykitReceiverPaths
 import to.bitkit.services.PaykitSdkService
 import to.bitkit.services.PubkyService
@@ -213,7 +214,7 @@ class PrivatePaykitRepo @Inject constructor(
     ): Result<Unit> = withContext(serializedDispatcher) {
         runSuspendCatching {
             if (!canPublishPrivateEndpoints()) {
-                prepareRelevantPrivateLinksIfAvailable(knownSavedContactKeys, reason)
+                prepareRelevantPrivateLinksIfAvailable(knownSavedContactKeys.toList(), reason)
                 return@runSuspendCatching
             }
             publishLocalEndpoints(
@@ -638,6 +639,7 @@ class PrivatePaykitRepo @Inject constructor(
         publishLocalEndpoints(
             publicKeys = listOf(publicKey),
             reason = "payment",
+            lane = PaykitReadLane.Interactive,
         ).onFailure {
             Logger.warn(
                 "Failed to refresh private Paykit endpoints before payment for '${redacted(publicKey)}'",
@@ -788,6 +790,7 @@ class PrivatePaykitRepo @Inject constructor(
         reason: String,
         forceRefreshLightning: Boolean = false,
         requireImmediatePublication: Boolean = false,
+        lane: PaykitReadLane = PaykitReadLane.Bulk,
     ): Result<Unit> = withContext(serializedDispatcher) {
         runSuspendCatching {
             val keys = publicKeys.mapNotNull { normalizedPublicKey(it) }.distinct()
@@ -804,6 +807,7 @@ class PrivatePaykitRepo @Inject constructor(
                     publicKeys = keys,
                     reason = reason,
                     forceRefreshLightning = forceRefreshLightning,
+                    lane = lane,
                 )
 
                 if (preparation.updates.isEmpty()) {
@@ -837,6 +841,7 @@ class PrivatePaykitRepo @Inject constructor(
         publicKeys: Collection<String>,
         reason: String,
         forceRefreshLightning: Boolean,
+        lane: PaykitReadLane,
     ): PrivatePublicationPreparation {
         var firstError: Throwable? = null
         var receiverPathSelectionError: Throwable? = null
@@ -847,7 +852,7 @@ class PrivatePaykitRepo @Inject constructor(
         firstError = linkedReceiverPathsSnapshot.error
 
         for (publicKey in publicKeys) {
-            val receiverPaths = runSuspendCatching { receiverPathsForSavedContact(publicKey) }
+            val receiverPaths = runSuspendCatching { receiverPathsForSavedContact(publicKey, lane) }
                 .onFailure {
                     firstError = firstError ?: it
                     Logger.warn(
@@ -856,7 +861,7 @@ class PrivatePaykitRepo @Inject constructor(
                         context = TAG,
                     )
                 }.getOrNull() ?: continue
-            val receiverPathSelection = paykitSdkService.privateReceiverPathSelection(publicKey, receiverPaths)
+            val receiverPathSelection = paykitSdkService.privateReceiverPathSelection(publicKey, receiverPaths, lane)
             val linkableReceiverPaths = receiverPathSelection.linkableReceiverPaths
             val publicationReceiverPaths = receiverPathSelection.publishableReceiverPaths
             receiverPathSelection.error?.let {
@@ -901,15 +906,15 @@ class PrivatePaykitRepo @Inject constructor(
 
         val retryKeys = mutableListOf<PrivateMessageDrainRetryKey>()
         for (publicKey in publicKeys) {
-            val receiverPaths = runSuspendCatching { receiverPathsForSavedContact(publicKey) }
+            val receiverPaths = runSuspendCatching { receiverPathsForSavedContact(publicKey, PaykitReadLane.Bulk) }
                 .onFailure {
                     Logger.warn(
                         "Failed to read saved Paykit receivers for '${redacted(publicKey)}' during '$reason'",
                         it,
                         context = TAG,
                     )
                 }.getOrNull() ?: continue
-            val selection = paykitSdkService.privateReceiverPathSelection(publicKey, receiverPaths)
+            val selection = paykitSdkService.privateReceiverPathSelection(publicKey, receiverPaths, PaykitReadLane.Bulk)
             selection.error?.let {
                 Logger.warn(
                     "Failed to inspect private Paykit receiver markers for '${redacted(publicKey)}' during '$reason'",
@@ -1490,12 +1495,12 @@ class PrivatePaykitRepo @Inject constructor(
         )
     }
 
-    private suspend fun receiverPathsForSavedContact(publicKey: String): List<String> {
+    private suspend fun receiverPathsForSavedContact(publicKey: String, lane: PaykitReadLane): List<String> {
         val record = paykitSdkService.contactRecord(publicKey)
         val savedPaths = supportedReceiverPaths(record?.receiverPaths.orEmpty())
 
         return runSuspendCatching {
-            val discoveredPaths = pubkyService.discoverRelevantReceiverPaths(publicKey)
+            val discoveredPaths = pubkyService.discoverRelevantReceiverPaths(publicKey, lane)
             val currentRecord = paykitSdkService.contactRecord(publicKey)
                 ?: return@runSuspendCatching savedPaths
             val currentSavedPaths = supportedReceiverPaths(currentRecord.receiverPaths)