diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/model/Account.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/model/Account.kt index 5952610a09..6ac097df8e 100644 --- a/amethyst/src/main/java/com/vitorpamplona/amethyst/model/Account.kt +++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/model/Account.kt @@ -425,6 +425,8 @@ class Account( scope = scope, assembler = cashuWalletFilterAssembler(), outboxRelaysFlow = outboxRelays.flow, + inboxRelaysFlow = notificationRelays.flow, + dmRelaysFlow = dmRelays.flow, settings = settings, okHttpClient = okHttpClientForMoney, ) diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip60Cashu/CashuWalletState.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip60Cashu/CashuWalletState.kt index 3018ddb4f1..48f372ae84 100644 --- a/amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip60Cashu/CashuWalletState.kt +++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/model/nip60Cashu/CashuWalletState.kt @@ -103,6 +103,8 @@ class CashuWalletState( private val scope: CoroutineScope, private val assembler: CashuWalletFilterAssembler, private val outboxRelaysFlow: StateFlow>, + private val inboxRelaysFlow: StateFlow>, + private val dmRelaysFlow: StateFlow>, private val settings: AccountSettings, okHttpClient: (String) -> OkHttpClient, ) { @@ -442,12 +444,31 @@ class CashuWalletState( triggerAutoRedeem() } - // Keep the relay subscription in sync with the outbox set. + // Keep the wallet subscription in sync with the relay sets it reads + // from. Following the NIP-65 outbox model, the two halves of the + // subscription read from different places: + // - our own NIP-60 events (wallet/token/history) are read back from + // our OUTBOX relays, where we published them; + // - inbound kind:9321 nutzaps are read from our INBOX set, since + // that is where other people deliver them. Per NIP-61 the source + // of truth for "where to send me nutzaps" is the `relay` tags in + // our own kind:10019 — and another client may have published that + // with relays unrelated to our NIP-65 lists — so we listen on the + // union of those plus our NIP-65 inbox + DM relays. jobs += scope.launch(Dispatchers.IO) { - outboxRelaysFlow.collect { relays -> - syncSubscription(relays) - } + combine( + outboxRelaysFlow, + inboxRelaysFlow, + dmRelaysFlow, + _nutzapInfoEvent, + ) { outbox, inbox, dm, info -> + CashuWalletQueryState( + pubkey = pubKey, + ownEventRelays = outbox, + inboxRelays = inbox + dm + (info?.relays() ?: emptyList()), + ) + }.collect { syncSubscription(it) } } // Reactive incremental update: any new event arrival that matches our @@ -510,17 +531,16 @@ class CashuWalletState( // ============================================================ // Subscription management // ============================================================ - private fun syncSubscription(relays: Set) { + private fun syncSubscription(next: CashuWalletQueryState) { val previous = currentSubscription - if (relays.isEmpty()) { + if (next.ownEventRelays.isEmpty() && next.inboxRelays.isEmpty()) { previous?.let { runCatching { assembler.unsubscribe(it) } } currentSubscription = null return } - if (previous != null && previous.relays == relays) return // unchanged + if (previous == next) return // unchanged previous?.let { runCatching { assembler.unsubscribe(it) } } - val next = CashuWalletQueryState(pubKey, relays) currentSubscription = next assembler.subscribe(next) } @@ -850,7 +870,11 @@ class CashuWalletState( ops.publishWalletEvents( mints = currentMints, p2pkPrivkeyHex = manualPrivkeyHex?.takeIf { it.isNotBlank() }, - nutzapRelays = outboxRelaysFlow.value.toList(), + // Advertise our NIP-65 inbox relays as the nutzap relays (NIP-65 + // outbox model): senders publish kind:9321 where we read inbound + // events. We listen on a wider set (inbox + DM + these tags), but + // the kind:10019 default copies the inbox relay list, not outbox. + nutzapRelays = inboxRelaysFlow.value.toList(), ) // The NUT-13 seed (derived from the P2PK key) is invalidated by // applyEvents when the new kind:17375 round-trips in, so it re-derives diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/service/relayClient/reqCommand/user/UserObservers.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/service/relayClient/reqCommand/user/UserObservers.kt index 30db8918c5..447b4f68d8 100644 --- a/amethyst/src/main/java/com/vitorpamplona/amethyst/service/relayClient/reqCommand/user/UserObservers.kt +++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/service/relayClient/reqCommand/user/UserObservers.kt @@ -150,9 +150,15 @@ fun observeUserBanner( fun observeUserPicture( user: User, accountViewModel: AccountViewModel, + subscribe: Boolean = true, ): State { // Subscribe in the relay for changes in the metadata of this user. - UserFinderFilterAssemblerSubscription(user, accountViewModel) + // Callers that already hold a single shared subscription for the same user + // (e.g. an author avatar that also observes the contact-card score) can pass + // subscribe = false to avoid setting up a redundant relay subscription. + if (subscribe) { + UserFinderFilterAssemblerSubscription(user, accountViewModel) + } // Subscribe in the LocalCache for changes that arrive in the device val flow = @@ -476,9 +482,14 @@ fun observeUserIsFollowingChannel( fun observeUserContactCardsScore( user: User, accountViewModel: AccountViewModel, + subscribe: Boolean = true, ): State { // Subscribe in the relay for changes in the metadata of this user. - UserFinderFilterAssemblerSubscription(user, accountViewModel) + // See observeUserPicture: pass subscribe = false when a shared subscription + // for the same user already exists. + if (subscribe) { + UserFinderFilterAssemblerSubscription(user, accountViewModel) + } // Subscribe in the LocalCache for changes that arrive in the device val flow = remember(user) { user.cards().rankFlow(accountViewModel.account.trustProviderList) } diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarNestedScroll.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarNestedScroll.kt index e49922f349..7e81278143 100644 --- a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarNestedScroll.kt +++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarNestedScroll.kt @@ -24,6 +24,7 @@ import androidx.compose.ui.geometry.Offset import androidx.compose.ui.input.nestedscroll.NestedScrollConnection import androidx.compose.ui.input.nestedscroll.NestedScrollSource import androidx.compose.ui.unit.Velocity +import kotlin.math.abs /** * Scroll-linked connection that hides/reveals the top and bottom bars together. @@ -43,10 +44,16 @@ import androidx.compose.ui.unit.Velocity * - onPostFling snaps a mid-way bar to the nearest edge, using the fling's remaining * velocity as the spring's initial velocity so the settle feels continuous. No velocity * is returned upward to avoid phantom scrolls on parent containers. - * - Hiding tracks the finger 1:1, but revealing is damped by [REVEAL_SENSITIVITY]. Once the - * bars are hidden, the small reverse drag a finger naturally makes when it catches/stops a - * fast scroll would otherwise be enough to snap the chrome (and the OS status bar) back. - * Damping the reveal direction makes bringing the bars back a more deliberate gesture. + * - Both hiding and revealing track the finger 1:1. The bar offset must equal the content's + * scroll offset so the bar's bottom edge stays glued to the first item's top edge; any + * asymmetry (e.g. a damped reveal) leaves the bar lagging behind the content and opens a + * blank band between the bar and the first item when the list returns to the top. + * + * Making the reveal a *deliberate* gesture — so the tiny reverse drag a finger makes when it + * catches/stops a fast scroll doesn't pop the chrome back — is handled without breaking that + * 1:1 invariant: a partial reveal that doesn't cross the halfway point is snapped back to the + * hidden edge by [DisappearingBarState.settleToNearestEdge] on fling/lift, and the binary OS + * status bar is debounced by the show/hide hysteresis in the scaffold. */ class DisappearingBarNestedScroll( private val state: DisappearingBarState, @@ -60,7 +67,10 @@ class DisappearingBarNestedScroll( ): Offset { if (!canScroll()) return Offset.Zero val totalY = consumed.y + available.y - if (totalY == 0f) return Offset.Zero + // Dead-zone: ignore sub-pixel jitter so the bars (and the binary status-bar toggle that + // tracks their collapse fraction) don't twitch on scroll noise. Kept symmetric and tiny so + // it never makes the reveal lag the content enough to open a visible gap. + if (abs(totalY) < MIN_SCROLL_DELTA) return Offset.Zero // If the list did not consume any scroll and the bars are fully visible, treat // this as a non-scrollable list and keep the bars in place. Without this, a tiny @@ -90,19 +100,18 @@ class DisappearingBarNestedScroll( private fun applyDelta(deltaY: Float) { val topLimit = state.topHeightLimit val bottomLimit = state.bottomHeightLimit - // Positive delta reveals the bars; negative delta hides them. Hiding stays 1:1 with the - // finger, while revealing is damped so a stray reverse drag doesn't bring the chrome back. - val effectiveDelta = if (deltaY > 0f) deltaY * REVEAL_SENSITIVITY else deltaY - state.topHeightOffset = (state.topHeightOffset + effectiveDelta).coerceIn(-topLimit, 0f) - state.bottomHeightOffset = (state.bottomHeightOffset + effectiveDelta).coerceIn(-bottomLimit, 0f) + // 1:1 in both directions: the bar offset mirrors the content scroll so the bar stays glued + // to the first item. Deliberate reveal is enforced on settle, not by damping the delta here. + state.topHeightOffset = (state.topHeightOffset + deltaY).coerceIn(-topLimit, 0f) + state.bottomHeightOffset = (state.bottomHeightOffset + deltaY).coerceIn(-bottomLimit, 0f) } companion object { /** - * Fraction of scroll distance applied when revealing the bars (1.0 = same rate as hiding). - * Lower values require a more deliberate downward scroll to bring the chrome back, so the - * tiny reverse movement of a finger stopping a fast scroll no longer pops the bars open. + * Sub-pixel dead-zone: scroll attempts smaller than this are ignored so jitter doesn't nudge + * the bars. Tiny on purpose — large enough to swallow fractional noise, small enough that the + * bar offset never measurably lags the content scroll. */ - const val REVEAL_SENSITIVITY = 0.5f + const val MIN_SCROLL_DELTA = 0.5f } } diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarState.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarState.kt index 8d743246db..13cddbc185 100644 --- a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarState.kt +++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarState.kt @@ -46,8 +46,46 @@ class DisappearingBarState( initialTopHeightOffset: Float = 0f, initialBottomHeightOffset: Float = 0f, ) { - var topHeightOffset by mutableFloatStateOf(initialTopHeightOffset) - var bottomHeightOffset by mutableFloatStateOf(initialBottomHeightOffset) + private var _topHeightOffset by mutableFloatStateOf(initialTopHeightOffset) + private var _bottomHeightOffset by mutableFloatStateOf(initialBottomHeightOffset) + + /** + * Latches that record whether each bar has been driven all the way to its hidden edge by real + * scrolling since it was last fully in view. The settle reads them to tell a deliberate hide — + * where the content has scrolled at least a full bar height, so snapping the bar fully hidden + * leaves content (not a blank band) in the slot it vacates — apart from a small near-top + * collapse, where snapping hidden would expose the background because the content hasn't + * scrolled far enough to fill the bar's slot. + */ + private var topReachedHiddenEdge = false + private var bottomReachedHiddenEdge = false + + var topHeightOffset: Float + get() = _topHeightOffset + set(value) { + _topHeightOffset = value + updateLatch(value, topHeightLimit) { topReachedHiddenEdge = it } + } + + var bottomHeightOffset: Float + get() = _bottomHeightOffset + set(value) { + _bottomHeightOffset = value + updateLatch(value, bottomHeightLimit) { bottomReachedHiddenEdge = it } + } + + private inline fun updateLatch( + offset: Float, + limit: Float, + set: (Boolean) -> Unit, + ) { + if (limit <= 0f) return + if (offset >= 0f) { + set(false) + } else if (offset <= -limit) { + set(true) + } + } var topHeightLimit: Float = 0f set(value) { @@ -76,8 +114,8 @@ class DisappearingBarState( */ suspend fun settleToNearestEdge(initialVelocityY: Float = 0f) { coroutineScope { - launch { settleOne({ topHeightOffset }, topHeightLimit, initialVelocityY) { topHeightOffset = it } } - launch { settleOne({ bottomHeightOffset }, bottomHeightLimit, initialVelocityY) { bottomHeightOffset = it } } + launch { settleOne({ topHeightOffset }, topHeightLimit, topReachedHiddenEdge, initialVelocityY) { topHeightOffset = it } } + launch { settleOne({ bottomHeightOffset }, bottomHeightLimit, bottomReachedHiddenEdge, initialVelocityY) { bottomHeightOffset = it } } } } @@ -94,6 +132,7 @@ class DisappearingBarState( private suspend fun settleOne( get: () -> Float, limit: Float, + canFullyHide: Boolean, initialVelocityY: Float, set: (Float) -> Unit, ) { @@ -105,6 +144,11 @@ class DisappearingBarState( val positionBiasToHide = -current > limit / 2f val target = when { + // Snapping to the hidden edge is only safe once the bar has actually been scrolled + // there (canFullyHide): the content has then moved at least a full bar height and + // fills the slot the bar vacates. From a small near-top collapse it hasn't, so + // snapping hidden would open a blank band — settle back into view instead. + !canFullyHide -> 0f initialVelocityY < -VELOCITY_BIAS_THRESHOLD -> -limit initialVelocityY > VELOCITY_BIAS_THRESHOLD -> 0f positionBiasToHide -> -limit @@ -142,10 +186,14 @@ class DisappearingBarState( companion object { private const val VELOCITY_BIAS_THRESHOLD = 200f + // Bounce-free so the chrome never wobbles past its edge, but stiff enough to feel like a + // quick native snap rather than a slow float once the finger lifts. Overshoot from a strong + // initial velocity is still caught by the bounds in animateOne, so a higher stiffness here + // only affects how briskly the bar resolves to its edge. private val SETTLE_SPRING = spring( dampingRatio = Spring.DampingRatioNoBouncy, - stiffness = Spring.StiffnessMediumLow, + stiffness = Spring.StiffnessMedium, ) val Saver: Saver = diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/note/AuthorGalleryRenderContext.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/note/AuthorGalleryRenderContext.kt new file mode 100644 index 0000000000..702d846009 --- /dev/null +++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/note/AuthorGalleryRenderContext.kt @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.amethyst.ui.note + +import androidx.compose.runtime.Composable +import androidx.compose.runtime.Immutable +import androidx.compose.runtime.compositionLocalOf +import androidx.compose.runtime.getValue +import androidx.compose.runtime.remember +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.vitorpamplona.amethyst.ui.screen.loggedIn.AccountViewModel + +/** + * The notification galleries (reactions, zaps, nutzaps, boosts) render up to 30 + * author avatars each. A couple of the inputs to every avatar are *account-global* + * — the auto-play-gif setting and the logged-in user's follow set — yet the avatar + * code used to collect each of them **once per author**. With dozens of authors per + * card that produced dozens of redundant Flow collectors / coroutine launches every + * time a card scrolled into view, a measurable chunk of the per-card composition cost. + * + * Hoisting those reads to a single collection per gallery and handing the snapshot + * down through [LocalAuthorGalleryRenderContext] lets each avatar read plain values + * and stay skippable. When the local is absent the avatar falls back to its old + * per-author behaviour, so callers that don't provide a context keep working. + */ +@Immutable +class AuthorGalleryRenderContext( + val autoPlayGif: Boolean, + val follows: Set, +) + +val LocalAuthorGalleryRenderContext = compositionLocalOf { null } + +/** + * Collects the account-global render inputs a single time. Provide the result via + * [LocalAuthorGalleryRenderContext] around a gallery's author list. + */ +@Composable +fun rememberAuthorGalleryRenderContext(accountViewModel: AccountViewModel): AuthorGalleryRenderContext { + val autoPlayGif by accountViewModel.settings.autoPlayVideosFlow.collectAsStateWithLifecycle() + val follows by accountViewModel.account.allFollows.flow + .collectAsStateWithLifecycle() + + val followAuthors = follows.authors + return remember(autoPlayGif, followAuthors) { + AuthorGalleryRenderContext(autoPlayGif, followAuthors) + } +} diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/note/MultiSetCompose.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/note/MultiSetCompose.kt index cc1e97ba06..672ce202f6 100644 --- a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/note/MultiSetCompose.kt +++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/note/MultiSetCompose.kt @@ -40,6 +40,7 @@ import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Surface import androidx.compose.material3.Text import androidx.compose.runtime.Composable +import androidx.compose.runtime.CompositionLocalProvider import androidx.compose.runtime.Immutable import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.MutableState @@ -72,6 +73,7 @@ import com.vitorpamplona.amethyst.model.Note import com.vitorpamplona.amethyst.model.NoteState import com.vitorpamplona.amethyst.model.User import com.vitorpamplona.amethyst.service.CachedRichTextParser +import com.vitorpamplona.amethyst.service.relayClient.reqCommand.user.UserFinderFilterAssemblerSubscription import com.vitorpamplona.amethyst.service.relayClient.reqCommand.user.observeUserContactCardsScore import com.vitorpamplona.amethyst.service.relayClient.reqCommand.user.observeUserPicture import com.vitorpamplona.amethyst.ui.components.AnimatedBorderTextCornerRadius @@ -463,8 +465,12 @@ fun AuthorGalleryZaps( nav: INav, accountViewModel: AccountViewModel, ) { - Column(modifier = StdStartPadding) { - FlowRow { authorNotes.forEach { RenderState(it, backgroundColor, accountViewModel, nav) } } + CompositionLocalProvider( + LocalAuthorGalleryRenderContext provides rememberAuthorGalleryRenderContext(accountViewModel), + ) { + Column(modifier = StdStartPadding) { + FlowRow { authorNotes.forEach { RenderState(it, backgroundColor, accountViewModel, nav) } } + } } } @@ -631,8 +637,12 @@ fun AuthorGallery( accountViewModel: AccountViewModel, clickRoute: (Note) -> Route? = ::authorRouteFor, ) { - Column(modifier = StdStartPadding) { - FlowRow { authorNotes.forEach { note -> BoxedAuthor(note, nav, accountViewModel, clickRoute) } } + CompositionLocalProvider( + LocalAuthorGalleryRenderContext provides rememberAuthorGalleryRenderContext(accountViewModel), + ) { + Column(modifier = StdStartPadding) { + FlowRow { authorNotes.forEach { note -> BoxedAuthor(note, nav, accountViewModel, clickRoute) } } + } } } @@ -643,9 +653,13 @@ fun AuthorGallery( nav: INav, accountViewModel: AccountViewModel, ) { - Column(modifier = StdStartPadding) { - FlowRow { - noteToGetBoostEvents.note.boosts.forEach { note -> BoxedAuthor(note, nav, accountViewModel) } + CompositionLocalProvider( + LocalAuthorGalleryRenderContext provides rememberAuthorGalleryRenderContext(accountViewModel), + ) { + Column(modifier = StdStartPadding) { + FlowRow { + noteToGetBoostEvents.note.boosts.forEach { note -> BoxedAuthor(note, nav, accountViewModel) } + } } } } @@ -684,7 +698,27 @@ fun WatchUserMetadataAndFollowsAndRenderUserProfilePicture( author: User, accountViewModel: AccountViewModel, ) { - WatchUserMetadata(author, accountViewModel) { baseUserPicture -> + // When rendered inside a gallery, the account-global auto-play and follow-set + // reads are hoisted to a single collection for the whole gallery (see + // [rememberAuthorGalleryRenderContext]). Falls back to per-author collection + // for callers that don't provide a context. + val galleryContext = LocalAuthorGalleryRenderContext.current + + // One shared relay subscription per author. The profile picture and the + // contact-card score below both fetch the same kind-0 metadata, so we + // subscribe once here and let them skip their own (formerly duplicate) one. + UserFinderFilterAssemblerSubscription(author, accountViewModel) + + WatchUserMetadata(author, accountViewModel, subscribe = false) { baseUserPicture -> + val autoPlayGif = + if (galleryContext != null) { + galleryContext.autoPlayGif + } else { + accountViewModel.settings.autoPlayVideosFlow + .collectAsStateWithLifecycle() + .value + } + RobohashFallbackAsyncImage( robot = author.pubkeyHex, model = baseUserPicture, @@ -693,30 +727,39 @@ fun WatchUserMetadataAndFollowsAndRenderUserProfilePicture( contentScale = ContentScale.Crop, loadProfilePicture = accountViewModel.settings.showProfilePictures(), loadRobohash = accountViewModel.settings.isNotPerformanceMode(), - autoPlayGif = - accountViewModel.settings.autoPlayVideosFlow - .collectAsStateWithLifecycle() - .value, + autoPlayGif = autoPlayGif, ) } - WatchUserFollows(author.pubkeyHex, accountViewModel) { isFollowing -> + if (galleryContext != null) { + val isFollowing = + accountViewModel.isLoggedUser(author.pubkeyHex) || + author.pubkeyHex in galleryContext.follows if (isFollowing) { Box(modifier = Size35Modifier, contentAlignment = Alignment.TopEnd) { FollowingIcon(Size10Modifier) } } + } else { + WatchUserFollows(author.pubkeyHex, accountViewModel) { isFollowing -> + if (isFollowing) { + Box(modifier = Size35Modifier, contentAlignment = Alignment.TopEnd) { + FollowingIcon(Size10Modifier) + } + } + } } - ObserveAndRenderBoxedUserCards(author, accountViewModel) + ObserveAndRenderBoxedUserCards(author, accountViewModel, subscribe = false) } @Composable fun ObserveAndRenderBoxedUserCards( user: User, accountViewModel: AccountViewModel, + subscribe: Boolean = true, ) { - val score by observeUserContactCardsScore(user, accountViewModel) + val score by observeUserContactCardsScore(user, accountViewModel, subscribe) score?.let { Box(modifier = Size35Modifier, contentAlignment = Alignment.BottomCenter) { @@ -729,9 +772,10 @@ fun ObserveAndRenderBoxedUserCards( private fun WatchUserMetadata( author: User, accountViewModel: AccountViewModel, + subscribe: Boolean = true, onNewMetadata: @Composable (String?) -> Unit, ) { - val userProfile by observeUserPicture(author, accountViewModel) + val userProfile by observeUserPicture(author, accountViewModel, subscribe) onNewMetadata(userProfile) } diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/notifications/CardFeedContentState.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/notifications/CardFeedContentState.kt index 15292532f9..0bbf0d54b2 100644 --- a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/notifications/CardFeedContentState.kt +++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/notifications/CardFeedContentState.kt @@ -63,7 +63,6 @@ import kotlinx.coroutines.flow.asStateFlow import kotlinx.coroutines.launch import java.time.Instant import java.time.ZoneId -import java.time.format.DateTimeFormatter @Stable class CardFeedContentState( @@ -266,7 +265,19 @@ class CardFeedContentState( } } - val sdf = DateTimeFormatter.ofPattern("yyyy-MM-dd") // SimpleDateFormat() + // Notifications are bucketed per calendar day. Computing the day key as a + // raw epoch-day Long (instead of formatting a "yyyy-MM-dd" String per event) + // gives identical buckets and chronological ordering while avoiding a + // DateTimeFormatter + ZonedDateTime + String allocation for every single + // reaction/zap/repost — a meaningful GC saving on full feed conversions. + val zone = ZoneId.systemDefault() + + fun epochDay(createdAt: Long?): Long = + Instant + .ofEpochSecond(createdAt ?: 0L) + .atZone(zone) + .toLocalDate() + .toEpochDay() val allBaseNotes = zapsPerEvent.keys + boostsPerEvent.keys + reactionsPerEvent.keys + nutzapsPerEvent.keys val multiCards = @@ -278,21 +289,16 @@ class CardFeedContentState( val singleList = (boostsInCard + zapsInCard.map { it.response } + reactionsInCard + nutzapsInCard).groupBy { - sdf.format( - Instant - .ofEpochSecond(it.createdAt() ?: 0L) - .atZone(ZoneId.systemDefault()) - .toLocalDateTime(), - ) + epochDay(it.createdAt()) } val days = singleList.keys.sortedBy { it } days - .mapNotNull { string -> + .mapNotNull { day -> val sortedList = singleList - .get(string) + .get(day) ?.sortedWith(compareByDescending { it.createdAt() }.thenBy { it.idHex }) sortedList?.chunked(30)?.map { chunk -> @@ -312,12 +318,7 @@ class CardFeedContentState( .map { user -> val byDay = user.value.groupBy { - sdf.format( - Instant - .ofEpochSecond(it.createdAt() ?: 0L) - .atZone(ZoneId.systemDefault()) - .toLocalDateTime(), - ) + epochDay(it.createdAt()) } byDay.values.map { zaps -> @@ -338,12 +339,7 @@ class CardFeedContentState( .map { user -> val byDay = user.value.groupBy { - sdf.format( - Instant - .ofEpochSecond(it.createdAt() ?: 0L) - .atZone(ZoneId.systemDefault()) - .toLocalDateTime(), - ) + epochDay(it.createdAt()) } byDay.values.map { nutzaps -> diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/wallet/CashuWalletViewModel.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/wallet/CashuWalletViewModel.kt index fbdd93f772..c799ce232e 100644 --- a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/wallet/CashuWalletViewModel.kt +++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/wallet/CashuWalletViewModel.kt @@ -500,8 +500,13 @@ class CashuWalletViewModel : ViewModel() { ops.publishWalletEvents( mints = mints, p2pkPrivkeyHex = privkey, + // Advertise our NIP-65 inbox relays as the nutzap relays, + // so senders publish kind:9321 where we read incoming + // events (NIP-65 outbox model). The kind:10019 default + // copies the inbox relay list, not outbox; the wallet + // still subscribes to a wider inbox + DM + tags set. nutzapRelays = - acc.outboxRelays.flow.value + acc.notificationRelays.flow.value .toList(), ) _createState.value = CashuWalletCreateState.Success diff --git a/amethyst/src/main/res/values-zh-rCN/strings.xml b/amethyst/src/main/res/values-zh-rCN/strings.xml index aa00d25fad..fe7b28ff70 100644 --- a/amethyst/src/main/res/values-zh-rCN/strings.xml +++ b/amethyst/src/main/res/values-zh-rCN/strings.xml @@ -566,6 +566,9 @@ 推荐的应用 选择您公开推荐的Nostr应用。建议显示在您的个人资料上，并帮助他人发现此客户端无法打开的内容。 尚未找到应用。应用在您的中继上被发现时会出现在这里。 + 按名称搜索应用 + 没有匹配您搜索的应用。 + 没有推荐应用匹配此过滤器。 未命名应用 不宣布它处理的内容 推荐 @@ -594,6 +597,8 @@ 集 重复 体重 + 练习 + 量 备注 小时 分钟 @@ -614,6 +619,9 @@ 冥想 饮食 节食 + 循环训练 + EMOM + AMRAP 应用 来源： %1$s v%1$s diff --git a/amethyst/src/test/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarNestedScrollTest.kt b/amethyst/src/test/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarNestedScrollTest.kt index 5f3a00a834..cad98a6229 100644 --- a/amethyst/src/test/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarNestedScrollTest.kt +++ b/amethyst/src/test/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarNestedScrollTest.kt @@ -79,17 +79,17 @@ class DisappearingBarNestedScrollTest { } @Test - fun `scrolling content down reveals both bars from a hidden state, damped`() { + fun `scrolling content down reveals both bars from a hidden state`() { val state = state(topLimit = 100f, bottomLimit = 50f) state.topHeightOffset = -100f state.bottomHeightOffset = -50f val connection = nsc(state) - // Reveal is damped by REVEAL_SENSITIVITY (0.5), so a 30px drag only reveals 15px. + // Reveal tracks the finger 1:1, so a 30px drag reveals 30px. connection.onPostScroll(Offset(0f, 30f), Offset(0f, 0f), NestedScrollSource.UserInput) - assertEquals(-85f, state.topHeightOffset) - assertEquals(-35f, state.bottomHeightOffset) + assertEquals(-70f, state.topHeightOffset) + assertEquals(-20f, state.bottomHeightOffset) } @Test @@ -100,26 +100,27 @@ class DisappearingBarNestedScrollTest { val connection = nsc(state) // The list consumed 20px of a 40px reveal drag; 20 more was left as overscroll. - // The bars should move by the total 40 (damped to 20 on reveal), not just one half. + // The bars should move by the total 40, not just one of the halves. connection.onPostScroll(Offset(0f, 20f), Offset(0f, 20f), NestedScrollSource.UserInput) - assertEquals(-30f, state.topHeightOffset) - assertEquals(-30f, state.bottomHeightOffset) + assertEquals(-10f, state.topHeightOffset) + assertEquals(-10f, state.bottomHeightOffset) } @Test - fun `revealing is less sensitive than hiding for the same drag distance`() { + fun `revealing tracks the finger 1 to 1, matching the hide rate so the bar stays glued to content`() { // Hiding a 40px drag moves the bars the full 40px... val hiding = state(topLimit = 100f, bottomLimit = 100f) nsc(hiding).onPostScroll(Offset(0f, -40f), Offset(0f, 0f), NestedScrollSource.UserInput) assertEquals(-40f, hiding.topHeightOffset) - // ...while revealing the same 40px from fully hidden only brings back 20px. + // ...and revealing the same 40px from fully hidden brings back the full 40px, so when the + // list returns to the top the bar is fully revealed with no blank band beneath it. val revealing = state(topLimit = 100f, bottomLimit = 100f) revealing.topHeightOffset = -100f revealing.bottomHeightOffset = -100f nsc(revealing).onPostScroll(Offset(0f, 40f), Offset(0f, 0f), NestedScrollSource.UserInput) - assertEquals(-80f, revealing.topHeightOffset) + assertEquals(-60f, revealing.topHeightOffset) } @Test diff --git a/amethyst/src/test/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarStateTest.kt b/amethyst/src/test/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarStateTest.kt index bae001b849..52ba051e3e 100644 --- a/amethyst/src/test/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarStateTest.kt +++ b/amethyst/src/test/java/com/vitorpamplona/amethyst/ui/layouts/DisappearingBarStateTest.kt @@ -93,4 +93,49 @@ class DisappearingBarStateTest { assertTrue("top bar overshot to $peakTop", peakTop <= 0.5f) assertTrue("bottom bar overshot to $peakBottom", peakBottom <= 0.5f) } + + @Test + fun `a partial collapse that never reached the hidden edge settles back into view`() = + runTest { + // The bar is past the halfway point but was only ever scrolled here from the top — it + // never reached -limit, so the content hasn't moved a full bar height. Snapping it fully + // hidden would expose a blank band, so it must settle back to visible instead. + val state = state(topLimit = 100f, bottomLimit = 50f) + state.topHeightOffset = -80f + + peakOffsetsDuring(state) { state.settleToNearestEdge() } + + assertEquals(0f, state.topHeightOffset, 0.01f) + } + + @Test + fun `a small reveal after fully hiding settles back to hidden, not into view`() = + runTest { + // Drive the bar to its hidden edge first (content has now scrolled a full bar height), + // then nudge it back a little — the small reverse drag a finger makes catching a scroll. + // Because it genuinely reached the hidden edge, snapping back hidden leaves no gap, so a + // sub-halfway reveal must not pop the chrome back open. + val state = state(topLimit = 100f, bottomLimit = 50f) + state.topHeightOffset = -100f + state.topHeightOffset = -90f + + peakOffsetsDuring(state) { state.settleToNearestEdge() } + + assertEquals(-100f, state.topHeightOffset, 0.01f) + } + + @Test + fun `returning fully into view re-arms the gap guard so the next near-top collapse settles open`() = + runTest { + // Hide fully (arms the latch), come all the way back to visible (disarms it), then do a + // small near-top collapse again. It must settle open, proving the latch resets at 0. + val state = state(topLimit = 100f, bottomLimit = 50f) + state.topHeightOffset = -100f + state.topHeightOffset = 0f + state.topHeightOffset = -80f + + peakOffsetsDuring(state) { state.settleToNearestEdge() } + + assertEquals(0f, state.topHeightOffset, 0.01f) + } } diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/relayClient/assemblers/CashuWalletFilterAssembler.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/relayClient/assemblers/CashuWalletFilterAssembler.kt index d70325c0fc..c761981205 100644 --- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/relayClient/assemblers/CashuWalletFilterAssembler.kt +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/relayClient/assemblers/CashuWalletFilterAssembler.kt @@ -42,13 +42,23 @@ import com.vitorpamplona.quartz.nip87Ecash.recommendation.MintRecommendationEven * Query state for the NIP-60 / NIP-61 wallet subscription. * * `pubkey` is the wallet owner — used both as `authors=` for their own - * NIP-60 events and as the `#p` tag value for inbound nutzaps. `relays` is - * the union of relays to subscribe on (NIP-65 outbox + DM relays at minimum). + * NIP-60 events and as the `#p` tag value for inbound nutzaps. + * + * The two filters read from different relay sets, following the NIP-65 + * outbox model: + * - [ownEventRelays] — the user's own write/outbox relays, where they + * published their NIP-60 wallet/token/history events. Restoring those + * means reading from where they were written. + * - [inboxRelays] — where *other* people deliver kind:9321 nutzaps to this + * user. Per NIP-61 the source of truth is the `relay` tags in the user's + * own kind:10019; in practice we listen on the union of those plus the + * user's NIP-65 inbox + DM relays so a nutzap can't slip past us. */ @Immutable data class CashuWalletQueryState( val pubkey: HexKey, - val relays: Set, + val ownEventRelays: Set, + val inboxRelays: Set, ) /** @@ -91,11 +101,9 @@ private class CashuWalletSubAssembler( if (keys.isEmpty()) return null val pubkey = keys.first().pubkey - val relays = - keys - .flatMap { it.relays } - .toSet() - .ifEmpty { return null } + val ownEventRelays = keys.flatMap { it.ownEventRelays }.toSet() + val inboxRelays = keys.flatMap { it.inboxRelays }.toSet() + if (ownEventRelays.isEmpty() && inboxRelays.isEmpty()) return null val ownedFilter = Filter( @@ -121,18 +129,26 @@ private class CashuWalletSubAssembler( tags = mapOf("p" to listOf(pubkey)), ) - return relays.flatMap { relay -> - val sinceTime = since?.get(relay)?.time - listOf( + // Own NIP-60 events are read from the user's outbox; inbound nutzaps + // from the user's inbox set. A relay that appears in both gets both + // filters. + val ownedSubs = + ownEventRelays.map { relay -> + val sinceTime = since?.get(relay)?.time RelayBasedFilter( relay, if (sinceTime != null) ownedFilter.copy(since = sinceTime) else ownedFilter, - ), + ) + } + val inboundSubs = + inboxRelays.map { relay -> + val sinceTime = since?.get(relay)?.time RelayBasedFilter( relay, if (sinceTime != null) inboundNutzapsFilter.copy(since = sinceTime) else inboundNutzapsFilter, - ), - ) - } + ) + } + + return ownedSubs + inboundSubs } } diff --git a/commons/src/jvmAndroid/kotlin/com/vitorpamplona/amethyst/commons/cashu/ops/CashuWalletOps.kt b/commons/src/jvmAndroid/kotlin/com/vitorpamplona/amethyst/commons/cashu/ops/CashuWalletOps.kt index cea2a3f9c2..c1d74c4089 100644 --- a/commons/src/jvmAndroid/kotlin/com/vitorpamplona/amethyst/commons/cashu/ops/CashuWalletOps.kt +++ b/commons/src/jvmAndroid/kotlin/com/vitorpamplona/amethyst/commons/cashu/ops/CashuWalletOps.kt @@ -153,9 +153,11 @@ class CashuWalletOps( val walletEvent = signer.sign(walletTemplate) publish(walletEvent) - // Populate `relay` tags so senders know where to publish nutzaps — - // without these, they fall back to NIP-65 outbox and may miss our - // subscription scope on relays we don't read from. + // Populate `relay` tags so senders know where to publish nutzaps. + // Per NIP-61 these are the relays where the recipient reads incoming + // token events, so callers pass our inbox-side relays here (NIP-65 + // outbox model). Without them, senders fall back to NIP-65 and may + // publish where we don't subscribe for inbound nutzaps. val nutzapInfoTemplate = NutzapInfoEvent.build( mints = mints.map { NutzapMintTag(it, listOf("sat")) }, diff --git a/docs/changelog/translators.json b/docs/changelog/translators.json index 1cf20fc728..31cf8a58bc 100644 --- a/docs/changelog/translators.json +++ b/docs/changelog/translators.json @@ -94,18 +94,18 @@ "Slovenian" ] }, - { - "user": "summoner001", - "languages": [ - "Hungarian" - ] - }, { "user": "hypnotichemionus4", "languages": [ "Chinese Simplified" ] }, + { + "user": "summoner001", + "languages": [ + "Hungarian" + ] + }, { "user": "vitorpamplona", "languages": []