diff --git a/amethyst/src/main/AndroidManifest.xml b/amethyst/src/main/AndroidManifest.xml
index 91acb98039..467e9ac3d9 100644
--- a/amethyst/src/main/AndroidManifest.xml
+++ b/amethyst/src/main/AndroidManifest.xml
@@ -90,6 +90,11 @@
+
+
+
+
@@ -556,6 +561,25 @@
+
+
+
+
+
+
+
+
+
(null, packageName) {
+ value =
+ withContext(Dispatchers.IO) {
+ runCatching {
+ context.packageManager
+ .getApplicationIcon(packageName)
+ .toBitmap(ICON_PX, ICON_PX)
+ .asImageBitmap()
+ }.getOrNull()
+ }
+ }
+
+ val current = icon
+ if (current != null) {
+ Image(bitmap = current, contentDescription = null, modifier = Modifier.fillMaxSize())
+ } else {
+ MonogramBadge(label, size = 36, shape = RoundedCornerShape(10.dp))
+ }
+}
+
+private const val ICON_PX = 108
diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/service/nowPlaying/AndroidNowPlayingAccess.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/service/nowPlaying/AndroidNowPlayingAccess.kt
new file mode 100644
index 0000000000..93bb929353
--- /dev/null
+++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/service/nowPlaying/AndroidNowPlayingAccess.kt
@@ -0,0 +1,33 @@
+/*
+ * 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.service.nowPlaying
+
+import android.content.Context
+import com.vitorpamplona.amethyst.commons.model.nip38UserStatuses.nowPlaying.NowPlayingAccess
+
+/** Notification access, which Android requires before it shares other apps' media sessions. */
+class AndroidNowPlayingAccess(
+ private val context: Context,
+) : NowPlayingAccess {
+ override fun hasAccess() = OtherAppsNowPlayingService.hasAccess(context)
+
+ override fun requestAccess() = OtherAppsNowPlayingService.openAccessSettings(context)
+}
diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/service/nowPlaying/InAppPlayback.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/service/nowPlaying/InAppPlayback.kt
new file mode 100644
index 0000000000..3515857edd
--- /dev/null
+++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/service/nowPlaying/InAppPlayback.kt
@@ -0,0 +1,135 @@
+/*
+ * 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.service.nowPlaying
+
+import androidx.compose.runtime.Immutable
+import androidx.media3.common.C
+import androidx.media3.common.Player
+import com.vitorpamplona.amethyst.commons.model.nip38UserStatuses.nowPlaying.NowPlaying
+import com.vitorpamplona.amethyst.service.playback.composable.mediaitem.MediaItemCache
+import com.vitorpamplona.quartz.utils.TimeUtils
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.update
+import kotlin.math.abs
+
+/** What one of the app's players is audibly playing: its item's `nostr:` URI and where it ends. */
+@Immutable
+data class InAppPlayback(
+ val callbackUri: String,
+ val title: String?,
+ val artist: String?,
+ val endsAt: Long?,
+) {
+ /** Same item, ending within a few seconds: a position tick rather than a change. */
+ fun isSameMoment(other: InAppPlayback?): Boolean {
+ if (other == null || callbackUri != other.callbackUri || title != other.title || artist != other.artist) return false
+ val a = endsAt
+ val b = other.endsAt
+ return if (a == null || b == null) a == b else abs(a - b) <= NowPlaying.MOMENT_TOLERANCE_SECONDS
+ }
+}
+
+/**
+ * The players in this process that are audibly playing something with a Nostr event behind it,
+ * keyed by player. Fed by [InAppPlaybackListener]; read by the now-playing coordinator, which
+ * resolves the URI to a music track or podcast episode and ignores everything else.
+ */
+object InAppPlaybackRegistry {
+ private val playing = MutableStateFlow>(emptyMap())
+
+ val flow: StateFlow> = playing
+
+ fun update(
+ player: Player,
+ playback: InAppPlayback?,
+ ) {
+ val key = System.identityHashCode(player)
+ playing.update { current ->
+ val previous = current[key]
+ when {
+ playback == null -> if (previous != null) current - key else current
+ // Live streams and some players report timeline/position changes every few
+ // seconds; keeping the same map avoids re-running everything downstream.
+ playback.isSameMoment(previous) -> current
+ // The same item with a corrected end keeps its place; a new item moves to the
+ // end, so iterating backwards visits the most recently started first.
+ previous?.callbackUri == playback.callbackUri -> current + (key to playback)
+ else -> (current - key) + (key to playback)
+ }
+ }
+ }
+
+ /** A released player reports nothing on its way out, so the pool drops it here. */
+ fun forget(player: Player) = update(player, null)
+}
+
+/**
+ * Reports a player's audible playback to [InAppPlaybackRegistry]. A muted player (feed autoplay)
+ * or one without a `nostr:` callback URI reports nothing.
+ *
+ * Attached once per player in `ExoPlayerBuilder`; runs on the player's looper.
+ */
+class InAppPlaybackListener(
+ private val registry: InAppPlaybackRegistry = InAppPlaybackRegistry,
+ private val nowSeconds: () -> Long = TimeUtils::now,
+) : Player.Listener {
+ override fun onEvents(
+ player: Player,
+ events: Player.Events,
+ ) {
+ if (events.containsAny(*RELEVANT_EVENTS)) {
+ registry.update(player, snapshot(player))
+ }
+ }
+
+ private fun snapshot(player: Player): InAppPlayback? {
+ if (!player.isPlaying || player.volume < 0.001f) return null
+
+ val item = player.currentMediaItem ?: return null
+ val metadata = item.mediaMetadata
+ val callbackUri = metadata.extras?.getString(MediaItemCache.EXTRA_CALLBACK_URI) ?: return null
+ if (!callbackUri.startsWith("nostr:")) return null
+
+ val duration = player.duration.takeIf { it != C.TIME_UNSET && !player.isCurrentMediaItemLive }
+
+ return InAppPlayback(
+ callbackUri = callbackUri,
+ // MediaItemCache falls back to the media URL (the media id) when there is no title.
+ title = metadata.title?.toString()?.takeUnless { it == item.mediaId },
+ artist = metadata.artist?.toString(),
+ endsAt = NowPlaying.endsAt(nowSeconds(), duration, player.currentPosition, player.playbackParameters.speed),
+ )
+ }
+
+ companion object {
+ private val RELEVANT_EVENTS =
+ intArrayOf(
+ Player.EVENT_IS_PLAYING_CHANGED,
+ Player.EVENT_MEDIA_ITEM_TRANSITION,
+ Player.EVENT_POSITION_DISCONTINUITY,
+ Player.EVENT_TIMELINE_CHANGED,
+ Player.EVENT_VOLUME_CHANGED,
+ Player.EVENT_PLAYBACK_PARAMETERS_CHANGED,
+ Player.EVENT_MEDIA_METADATA_CHANGED,
+ )
+ }
+}
diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/service/nowPlaying/NowPlayingStatusCoordinator.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/service/nowPlaying/NowPlayingStatusCoordinator.kt
new file mode 100644
index 0000000000..40485ae3df
--- /dev/null
+++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/service/nowPlaying/NowPlayingStatusCoordinator.kt
@@ -0,0 +1,144 @@
+/*
+ * 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.service.nowPlaying
+
+import com.vitorpamplona.amethyst.commons.model.Account
+import com.vitorpamplona.amethyst.commons.model.cache.LocalCache
+import com.vitorpamplona.amethyst.commons.model.nip38UserStatuses.nowPlaying.NowPlaying
+import com.vitorpamplona.amethyst.commons.model.nip38UserStatuses.nowPlaying.NowPlayingPublisher
+import com.vitorpamplona.amethyst.commons.model.nip38UserStatuses.nowPlaying.NowPlayingResolver
+import com.vitorpamplona.amethyst.commons.model.nip38UserStatuses.nowPlaying.NowPlayingStatusService
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withTimeoutOrNull
+
+/**
+ * Publishes what the user is listening to, in Amethyst or in another app, as the logged-in
+ * account's NIP-38 music status, following that account's now-playing settings.
+ *
+ * App-scoped, like the other background watchers in AppModules: the music keeps playing (and
+ * other apps keep reporting) after the activity is gone. While the app is in the background the
+ * relay pool is paused, so every publish holds [relayServices] open for [RELAY_HOLD_MS], long
+ * enough for the event to go out.
+ */
+class NowPlayingStatusCoordinator(
+ private val scope: CoroutineScope,
+ private val accountFlow: Flow,
+ private val relayServices: Flow<*>,
+ private val inApp: StateFlow> = InAppPlaybackRegistry.flow,
+ private val otherApps: StateFlow = OtherAppsPlaybackRegistry.flow,
+) {
+ private var relayHold: Job? = null
+
+ fun start() {
+ scope.launch(Dispatchers.IO) {
+ accountFlow
+ .distinctUntilChanged { a, b -> a?.signer?.pubKey == b?.signer?.pubKey }
+ .collectLatest { account ->
+ if (account == null || !account.isWriteable()) return@collectLatest
+ run(account)
+ }
+ }
+ }
+
+ private suspend fun run(account: Account) {
+ // Every player that is audibly playing, most recently started first: the first one that
+ // is a music track or podcast episode wins, so an unmuted feed video started after a song
+ // does not hide the song.
+ val inAppTracks =
+ inApp
+ .map { playing -> playing.values.reversed().firstNotNullOfOrNull(::resolve) }
+ .flowOn(Dispatchers.IO)
+
+ val publisher =
+ NowPlayingPublisher(
+ // Relays are woken first: in the background the pool is paused, and the event
+ // waits in the outbox until a relay connects.
+ publish = { track, expiration ->
+ holdRelays()
+ account.publishNowPlaying(track, expiration)
+ },
+ clear = {
+ holdRelays()
+ account.clearNowPlaying()
+ },
+ )
+
+ NowPlayingStatusService(
+ settings = account.nowPlayingSettings.flow,
+ sources = listOf(inAppTracks, otherApps),
+ onOtherAppSeen = { account.nowPlayingSettings.rememberApp(it.id, it.label) },
+ publisher = publisher,
+ ).run()
+ }
+
+ /**
+ * What a player's item is as a status, without its end time. Keyed by the item's `nostr:` URI
+ * so the NIP-19 parse and the cache lookup run once per item, not once per position update.
+ * Only touched from the single flow collecting [inApp].
+ */
+ private val resolved = HashMap()
+
+ private class Resolution(
+ val track: NowPlaying?,
+ )
+
+ private fun resolve(playback: InAppPlayback): NowPlaying? {
+ val cached =
+ resolved[playback.callbackUri] ?: run {
+ val key = NowPlayingResolver.noteKey(playback.callbackUri)
+ val event =
+ if (key != null) {
+ // Not loaded yet: resolve again on the next update instead of caching a miss.
+ LocalCache.getNoteIfExists(key)?.event ?: return null
+ } else {
+ null
+ }
+ val track = event?.let { NowPlayingResolver.fromEvent(it, playback.title, playback.artist) }
+
+ if (resolved.size >= MAX_RESOLVED) resolved.clear()
+ Resolution(track).also { resolved[playback.callbackUri] = it }
+ }
+
+ return cached.track?.copy(endsAt = playback.endsAt)
+ }
+
+ private fun holdRelays() {
+ relayHold?.cancel()
+ relayHold =
+ scope.launch(Dispatchers.IO) {
+ withTimeoutOrNull(RELAY_HOLD_MS) { relayServices.collect {} }
+ }
+ }
+
+ companion object {
+ private const val RELAY_HOLD_MS = 30_000L
+ private const val MAX_RESOLVED = 64
+ }
+}
diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/service/nowPlaying/OtherAppsNowPlayingService.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/service/nowPlaying/OtherAppsNowPlayingService.kt
new file mode 100644
index 0000000000..a461d2b516
--- /dev/null
+++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/service/nowPlaying/OtherAppsNowPlayingService.kt
@@ -0,0 +1,225 @@
+/*
+ * 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.service.nowPlaying
+
+import android.content.ActivityNotFoundException
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.media.MediaMetadata
+import android.media.session.MediaController
+import android.media.session.MediaSession
+import android.media.session.MediaSessionManager
+import android.media.session.PlaybackState
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.os.SystemClock
+import android.provider.Settings
+import android.service.notification.NotificationListenerService
+import androidx.core.app.NotificationManagerCompat
+import com.vitorpamplona.amethyst.commons.model.nip38UserStatuses.nowPlaying.NowPlaying
+import com.vitorpamplona.amethyst.commons.model.nip38UserStatuses.nowPlaying.NowPlayingSource
+import com.vitorpamplona.quartz.utils.Log
+import com.vitorpamplona.quartz.utils.TimeUtils
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+
+/** What another app on this device is playing, as reported by its media session. */
+object OtherAppsPlaybackRegistry {
+ private val playing = MutableStateFlow(null)
+
+ val flow: StateFlow = playing
+
+ fun update(track: NowPlaying?) {
+ // Many players report their position every second; only a real change goes downstream.
+ if (track != null && track.isSameMoment(playing.value)) return
+ playing.value = track
+ }
+}
+
+/**
+ * Reads the media sessions of other apps (Spotify, YouTube Music, podcast players, ...) to share
+ * what the user is listening to as a NIP-38 music status.
+ *
+ * Android only hands out other apps' sessions to an enabled notification listener, which is why
+ * this is one: it never reads or posts notifications. The user grants it in the system's
+ * "Notification access" screen ([openAccessSettings]); until then the system never binds it.
+ * Whether anything is published is still up to the account's now-playing settings.
+ *
+ * Runs in the main process (it is not declared in `:napplet`), where the account lives. The
+ * system may start that process just to bind this listener; AppModules then logs the saved
+ * account in on its own, as it does on every start, so the publisher has it.
+ */
+class OtherAppsNowPlayingService : NotificationListenerService() {
+ private val handler = Handler(Looper.getMainLooper())
+ private var sessionManager: MediaSessionManager? = null
+ private val watched = mutableMapOf>()
+
+ // App labels come from PackageManager, an IPC; players report state up to once a second.
+ private val labels = mutableMapOf()
+
+ private val sessionsListener =
+ MediaSessionManager.OnActiveSessionsChangedListener { controllers ->
+ watch(controllers.orEmpty())
+ }
+
+ override fun onListenerConnected() {
+ super.onListenerConnected()
+ val manager = getSystemService(MediaSessionManager::class.java) ?: return
+ sessionManager = manager
+
+ try {
+ val component = ComponentName(this, OtherAppsNowPlayingService::class.java)
+ manager.addOnActiveSessionsChangedListener(sessionsListener, component, handler)
+ watch(manager.getActiveSessions(component))
+ } catch (e: SecurityException) {
+ // Access was revoked between the bind and this call.
+ Log.w("OtherAppsNowPlaying", "Notification access is not granted", e)
+ }
+ }
+
+ override fun onListenerDisconnected() {
+ sessionManager?.removeOnActiveSessionsChangedListener(sessionsListener)
+ sessionManager = null
+ unwatchAll()
+ OtherAppsPlaybackRegistry.update(null)
+ super.onListenerDisconnected()
+ }
+
+ override fun onDestroy() {
+ sessionManager?.removeOnActiveSessionsChangedListener(sessionsListener)
+ unwatchAll()
+ OtherAppsPlaybackRegistry.update(null)
+ super.onDestroy()
+ }
+
+ private fun watch(controllers: List) {
+ val others = controllers.filter { it.packageName != packageName }
+ val keys = others.mapTo(mutableSetOf()) { it.sessionToken }
+
+ watched.keys.filter { it !in keys }.forEach { key ->
+ watched.remove(key)?.let { (controller, callback) -> controller.unregisterCallback(callback) }
+ }
+
+ others.forEach { controller ->
+ val key = controller.sessionToken
+ if (key !in watched) {
+ val callback =
+ object : MediaController.Callback() {
+ override fun onPlaybackStateChanged(state: PlaybackState?) = refresh()
+
+ override fun onMetadataChanged(metadata: MediaMetadata?) = refresh()
+
+ override fun onSessionDestroyed() {
+ watched.remove(key)?.let { (it, cb) -> it.unregisterCallback(cb) }
+ refresh()
+ }
+ }
+ controller.registerCallback(callback, handler)
+ watched[key] = controller to callback
+ }
+ }
+
+ refresh()
+ }
+
+ private fun unwatchAll() {
+ watched.values.forEach { (controller, callback) -> controller.unregisterCallback(callback) }
+ watched.clear()
+ }
+
+ /** The first session that is playing, in the system's priority order. */
+ private fun refresh() {
+ val track = watched.values.firstNotNullOfOrNull { (controller, _) -> toNowPlaying(controller) }
+ OtherAppsPlaybackRegistry.update(track)
+ }
+
+ private fun toNowPlaying(controller: MediaController): NowPlaying? {
+ val state = controller.playbackState ?: return null
+ if (state.state != PlaybackState.STATE_PLAYING) return null
+
+ val metadata = controller.metadata ?: return null
+ val title =
+ metadata.getString(MediaMetadata.METADATA_KEY_TITLE)?.ifBlank { null }
+ ?: metadata.getString(MediaMetadata.METADATA_KEY_DISPLAY_TITLE)?.ifBlank { null }
+ ?: return null
+ val artist =
+ metadata.getString(MediaMetadata.METADATA_KEY_ARTIST)?.ifBlank { null }
+ ?: metadata.getString(MediaMetadata.METADATA_KEY_ALBUM_ARTIST)?.ifBlank { null }
+ ?: metadata.getString(MediaMetadata.METADATA_KEY_DISPLAY_SUBTITLE)?.ifBlank { null }
+
+ val duration = metadata.getLong(MediaMetadata.METADATA_KEY_DURATION).takeIf { it > 0 }
+ val speed = state.playbackSpeed.takeIf { it > 0f } ?: 1f
+ val position =
+ if (state.lastPositionUpdateTime > 0) {
+ state.position + ((SystemClock.elapsedRealtime() - state.lastPositionUpdateTime) * speed).toLong()
+ } else {
+ state.position
+ }
+
+ return NowPlaying(
+ title = title,
+ artist = artist,
+ source = NowPlayingSource.OtherApp(controller.packageName, appLabel(controller.packageName)),
+ endsAt = NowPlaying.endsAt(TimeUtils.now(), duration, position, speed),
+ )
+ }
+
+ private fun appLabel(packageName: String): String =
+ labels.getOrPut(packageName) {
+ try {
+ packageManager.getApplicationLabel(packageManager.getApplicationInfo(packageName, 0)).toString()
+ } catch (_: PackageManager.NameNotFoundException) {
+ packageName
+ }
+ }
+
+ companion object {
+ fun hasAccess(context: Context): Boolean = context.packageName in NotificationManagerCompat.getEnabledListenerPackages(context)
+
+ /** Opens the system screen where the user grants or revokes access to this listener. */
+ fun openAccessSettings(context: Context) {
+ val component = ComponentName(context, OtherAppsNowPlayingService::class.java).flattenToString()
+ // Straight to this app's toggle where the system supports it, else the list of listeners.
+ val intents =
+ listOfNotNull(
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+ Intent(Settings.ACTION_NOTIFICATION_LISTENER_DETAIL_SETTINGS)
+ .putExtra(Settings.EXTRA_NOTIFICATION_LISTENER_COMPONENT_NAME, component)
+ } else {
+ null
+ },
+ Intent(Settings.ACTION_NOTIFICATION_LISTENER_SETTINGS),
+ )
+
+ for (intent in intents) {
+ try {
+ context.startActivity(intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
+ return
+ } catch (e: ActivityNotFoundException) {
+ Log.w("OtherAppsNowPlaying", "No activity for ${intent.action}", e)
+ }
+ }
+ }
+ }
+}
diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/service/playback/playerPool/ExoPlayerBuilder.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/service/playback/playerPool/ExoPlayerBuilder.kt
index aa969245d4..888df68e76 100644
--- a/amethyst/src/main/java/com/vitorpamplona/amethyst/service/playback/playerPool/ExoPlayerBuilder.kt
+++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/service/playback/playerPool/ExoPlayerBuilder.kt
@@ -33,6 +33,7 @@ import androidx.media3.exoplayer.audio.AudioSink
import androidx.media3.exoplayer.audio.DefaultAudioSink
import androidx.media3.exoplayer.audio.TeeAudioProcessor
import com.vitorpamplona.amethyst.commons.model.MediaAspectRatioCache
+import com.vitorpamplona.amethyst.service.nowPlaying.InAppPlaybackListener
import com.vitorpamplona.amethyst.service.playback.diskCache.VideoCache
import com.vitorpamplona.amethyst.service.playback.playerPool.aspectRatio.AspectRatioCacher
import com.vitorpamplona.amethyst.service.playback.playerPool.positions.CurrentPlayPositionCacher
@@ -89,6 +90,7 @@ class ExoPlayerBuilder(
addListener(KeepVideosPlaying(this))
addListener(CurrentPlayPositionCacher(this, VideoViewedPositionCache))
addListener(MediaPlayTimeTracker())
+ addListener(InAppPlaybackListener())
}
}
diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/service/playback/playerPool/ExoPlayerPool.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/service/playback/playerPool/ExoPlayerPool.kt
index 6e9c18c89c..c6de2f111e 100644
--- a/amethyst/src/main/java/com/vitorpamplona/amethyst/service/playback/playerPool/ExoPlayerPool.kt
+++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/service/playback/playerPool/ExoPlayerPool.kt
@@ -25,6 +25,7 @@ import androidx.annotation.OptIn
import androidx.media3.common.C
import androidx.media3.common.util.UnstableApi
import androidx.media3.exoplayer.ExoPlayer
+import com.vitorpamplona.amethyst.service.nowPlaying.InAppPlaybackRegistry
import com.vitorpamplona.amethyst.service.playback.PLAYBACK_DIAG_TAG
import com.vitorpamplona.quartz.utils.Log
import kotlinx.coroutines.CoroutineExceptionHandler
@@ -132,6 +133,7 @@ class ExoPlayerPool(
if (error != null) {
Log.d("PlaybackService") { "ExoPlayerPool discarding errored warm player: $preferredMediaId (${error.errorCodeName})" }
PcmTapRegistry.unregisterPlayer(warm)
+ InAppPlaybackRegistry.forget(warm)
warm.release()
releaseDecoder()
} else {
@@ -239,6 +241,7 @@ class ExoPlayerPool(
if (error != null) {
Log.d("PlaybackService") { "ExoPlayerPool dropping errored player: ${player.currentMediaItem?.mediaId} (${error.errorCodeName})" }
PcmTapRegistry.unregisterPlayer(player)
+ InAppPlaybackRegistry.forget(player)
player.release()
releaseDecoder()
return@withLock
@@ -309,6 +312,7 @@ class ExoPlayerPool(
}
} else {
PcmTapRegistry.unregisterPlayer(player)
+ InAppPlaybackRegistry.forget(player)
player.release() // Release if pool is full.
}
}
@@ -345,11 +349,13 @@ class ExoPlayerPool(
}
warmSnapshot.forEach {
PcmTapRegistry.unregisterPlayer(it.player)
+ InAppPlaybackRegistry.forget(it.player)
it.player.release()
releaseDecoder()
}
coldPool.forEach {
PcmTapRegistry.unregisterPlayer(it)
+ InAppPlaybackRegistry.forget(it)
it.release()
}
coldPool.clear()
diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/navigation/AppNavigation.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/navigation/AppNavigation.kt
index 3131255e72..56689d78ff 100644
--- a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/navigation/AppNavigation.kt
+++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/navigation/AppNavigation.kt
@@ -232,6 +232,7 @@ import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.settings.HomeTabsSe
import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.settings.MessagesSettingsScreen
import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.settings.MutedThreadsScreen
import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.settings.NIP47SetupScreen
+import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.settings.NowPlayingSettingsScreen
import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.settings.ProfileUiSettingsScreen
import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.settings.ReactionsSettingsScreen
import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.settings.SecurityFiltersScreen
@@ -271,6 +272,8 @@ import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.workouts.WorkoutsSc
import com.vitorpamplona.amethyst.commons.ui.uriToRoute
import com.vitorpamplona.amethyst.commons.viewmodels.AccountViewModel
import com.vitorpamplona.amethyst.service.crashreports.DisplayCrashMessages
+import com.vitorpamplona.amethyst.service.nowPlaying.AndroidAppIcon
+import com.vitorpamplona.amethyst.service.nowPlaying.AndroidNowPlayingAccess
import com.vitorpamplona.amethyst.service.relayClient.authCommand.compose.RelayAuthPromptHost
import com.vitorpamplona.amethyst.service.relayClient.notifyCommand.compose.DisplayNotifyMessages
import com.vitorpamplona.amethyst.service.resourceusage.DisplayResourceUsageAlert
@@ -653,6 +656,11 @@ fun BuildNavigation(
composableFromEnd { ProfileUiSettingsScreen(accountViewModel, nav) }
composableFromEnd { VideoPlayerSettingsScreen(accountViewModel, nav) }
composableFromEnd { CallSettingsScreen(accountViewModel, nav) }
+ composableFromEnd {
+ val context = LocalContext.current
+ val access = remember(context) { AndroidNowPlayingAccess(context.applicationContext) }
+ NowPlayingSettingsScreen(accountViewModel, nav, access) { appId, label -> AndroidAppIcon(appId, label) }
+ }
composableFromEnd { NotificationSettingsScreen(accountViewModel, nav) }
composableFromEnd { ResourceUsageScreen(accountViewModel, nav) }
composableFromEnd { ImportFollowListSelectUserScreen(accountViewModel, nav) }
diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/navigation/drawer/DrawerContent.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/navigation/drawer/DrawerContent.kt
index e947d9f041..5190d02c82 100644
--- a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/navigation/drawer/DrawerContent.kt
+++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/navigation/drawer/DrawerContent.kt
@@ -165,6 +165,7 @@ import com.vitorpamplona.amethyst.isDebug
import com.vitorpamplona.amethyst.ui.painterRes
import com.vitorpamplona.quartz.nip01Core.core.Address
import com.vitorpamplona.quartz.nip01Core.core.HexKey
+import com.vitorpamplona.quartz.nip38UserStatus.UserStatusEvent
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.combine
import org.jetbrains.compose.resources.StringResource
@@ -355,7 +356,11 @@ private fun EditStatusBoxes(
accountViewModel: AccountViewModel,
nav: INav,
) {
- val statuses by observeUserStatuses(baseAccountUser, accountViewModel)
+ val allStatuses by observeUserStatuses(baseAccountUser, accountViewModel)
+
+ // The music status is written by the now-playing publisher, not typed here: editing it would
+ // overwrite the track and keep its expiration, so only the other statuses are editable.
+ val statuses = remember(allStatuses) { allStatuses.filter { it.address.dTag != UserStatusEvent.MUSIC } }
if (statuses.isEmpty()) {
PreviewStatusEditBar(accountViewModel = accountViewModel, nav = nav)
diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/Account.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/Account.kt
index 886cbeea46..557380d38c 100644
--- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/Account.kt
+++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/Account.kt
@@ -93,6 +93,8 @@ import com.vitorpamplona.amethyst.commons.model.nip29RelayGroups.RelayGroupListS
import com.vitorpamplona.amethyst.commons.model.nip30CustomEmojis.EmojiPackState
import com.vitorpamplona.amethyst.commons.model.nip30CustomEmojis.OwnedEmojiPacksState
import com.vitorpamplona.amethyst.commons.model.nip38UserStatuses.UserStatusAction
+import com.vitorpamplona.amethyst.commons.model.nip38UserStatuses.nowPlaying.NowPlaying
+import com.vitorpamplona.amethyst.commons.model.nip38UserStatuses.nowPlaying.NowPlayingSettingsState
import com.vitorpamplona.amethyst.commons.model.nip46Signer.Nip46ConsentPrompter
import com.vitorpamplona.amethyst.commons.model.nip46Signer.Nip46SignerState
import com.vitorpamplona.amethyst.commons.model.nip47WalletConnect.NwcInfoCache
@@ -533,6 +535,11 @@ class Account(
// channel list. Restored/persisted per account by BuzzChannelStarStore.
val buzzChannelStars = BuzzChannelStars()
+ // Whether THIS account shares what the user listens to as its NIP-38 music status, and from
+ // which apps. Per account because the status is signed and published by this key. Restored/
+ // persisted per account by NowPlayingSettingsStore on Android.
+ val nowPlayingSettings = NowPlayingSettingsState()
+
// The NIP-OA attestation an owner issued to THIS account's key, attached to its Buzz-relay
// AUTH so the relay grants virtual membership. Restored/persisted per account by
// BuzzAttestationStore.
@@ -3351,6 +3358,13 @@ class Account(
suspend fun deleteStatus(oldStatus: AddressableNote) = sendMyPublicAndPrivateOutbox(UserStatusAction.delete(oldStatus, signer))
+ suspend fun publishNowPlaying(
+ track: NowPlaying,
+ expiration: Long,
+ ) = sendMyPublicAndPrivateOutbox(UserStatusAction.createMusic(track, expiration, signer))
+
+ suspend fun clearNowPlaying() = sendMyPublicAndPrivateOutbox(UserStatusAction.clearMusic(signer))
+
suspend fun removeEmojiPack(emojiPack: Note) = sendMyPublicAndPrivateOutbox(emoji.removeEmojiPack(emojiPack))
suspend fun addEmojiPack(emojiPack: Note) = sendMyPublicAndPrivateOutbox(emoji.addEmojiPack(emojiPack))
diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/navigation/Routes.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/navigation/Routes.kt
index 70b8daf092..f2a0d2e832 100644
--- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/navigation/Routes.kt
+++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/navigation/Routes.kt
@@ -585,6 +585,8 @@ sealed class Route {
@Serializable object CallSettings : Route()
+ @Serializable object NowPlayingSettings : Route()
+
@Serializable object NotificationSettings : Route()
@Serializable object CalendarReminderSettings : Route()
diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/UserStatusAction.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/UserStatusAction.kt
index 4fac63e096..57499eb3cb 100644
--- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/UserStatusAction.kt
+++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/UserStatusAction.kt
@@ -21,6 +21,7 @@
package com.vitorpamplona.amethyst.commons.model.nip38UserStatuses
import com.vitorpamplona.amethyst.commons.model.AddressableNote
+import com.vitorpamplona.amethyst.commons.model.nip38UserStatuses.nowPlaying.NowPlaying
import com.vitorpamplona.quartz.nip01Core.core.Event
import com.vitorpamplona.quartz.nip01Core.signers.NostrSigner
import com.vitorpamplona.quartz.nip09Deletions.DeletionRequestEvent
@@ -34,6 +35,25 @@ class UserStatusAction {
type: String = UserStatusEvent.GENERAL,
): UserStatusEvent = UserStatusEvent.create(newStatus, type, signer = signer)
+ /** A `music` status for [track] that expires at [expiration], when the track ends. */
+ suspend fun createMusic(
+ track: NowPlaying,
+ expiration: Long,
+ signer: NostrSigner,
+ ): UserStatusEvent =
+ UserStatusEvent.create(
+ msg = track.statusText(),
+ type = UserStatusEvent.MUSIC,
+ expiration = expiration,
+ url = track.url,
+ eventId = track.eventId,
+ addressableId = track.addressId,
+ signer = signer,
+ )
+
+ /** Clears the `music` status: NIP-38 clears a status by replacing it with blank content. */
+ suspend fun clearMusic(signer: NostrSigner): UserStatusEvent = UserStatusEvent.create("", UserStatusEvent.MUSIC, signer = signer)
+
suspend fun update(
oldStatus: AddressableNote,
newStatus: String,
diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/UserStatusCache.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/UserStatusCache.kt
index fc04d0352a..c5a548cc31 100644
--- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/UserStatusCache.kt
+++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/UserStatusCache.kt
@@ -42,11 +42,16 @@ class UserStatusCache : UserDependencies {
)
fun addStatus(note: AddressableNote) {
- // if it's already there, quick exit
- if (statuses.value.contains(note) || note.isEmptyStatus()) return
+ // A newer version of a listed status can be blank (NIP-38 clears a status that way, and
+ // a music status is cleared every time playback stops) or already expired: the note is
+ // the same object, so it has to leave the list rather than be skipped as already there.
+ if (note.isEmptyStatus() || note.event?.isExpired() == true) {
+ removeStatus(note)
+ return
+ }
- // don't add expired statuses
- if (note.event?.isExpired() == true) return
+ // if it's already there, quick exit
+ if (statuses.value.contains(note)) return
statuses.update {
(it + note).sortedWith(sortModel).toImmutableList()
diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlaying.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlaying.kt
new file mode 100644
index 0000000000..32287b1968
--- /dev/null
+++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlaying.kt
@@ -0,0 +1,111 @@
+/*
+ * 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.commons.model.nip38UserStatuses.nowPlaying
+
+import androidx.compose.runtime.Immutable
+import com.vitorpamplona.quartz.nip01Core.core.HexKey
+import kotlin.math.abs
+
+/** Where a track is being played. */
+@Immutable
+sealed interface NowPlayingSource {
+ /** Amethyst's own player (a music track or podcast episode opened in the app). */
+ data object InApp : NowPlayingSource
+
+ /**
+ * Another app on this device. [id] is stable across sessions (an Android package name, an
+ * MPRIS bus name, a Windows app id) and is what the per-app block list keys on; [label] is
+ * what the settings screen shows.
+ */
+ data class OtherApp(
+ val id: String,
+ val label: String,
+ ) : NowPlayingSource
+}
+
+/**
+ * A track (song or podcast episode) the user is playing right now, ready to become a NIP-38
+ * `music` status.
+ *
+ * [endsAt] is the Unix time (seconds) the track will finish at its current position and speed,
+ * which becomes the status' NIP-40 expiration, as NIP-38 asks for music. It is null when the
+ * length is unknown (a live stream, an app that does not report a duration).
+ *
+ * [url], [addressId] and [eventId] become the status' `r`, `a` and `e` tags, so readers can open
+ * what is playing: in-app tracks point at their Nostr event.
+ */
+@Immutable
+data class NowPlaying(
+ val title: String,
+ val artist: String? = null,
+ val source: NowPlayingSource,
+ val endsAt: Long? = null,
+ val url: String? = null,
+ val addressId: String? = null,
+ val eventId: HexKey? = null,
+) {
+ /** The status line, in the `Title - Artist` shape of the NIP-38 example. */
+ fun statusText(): String = if (artist.isNullOrBlank()) title else "$title - $artist"
+
+ /** Same track, regardless of the playback position. */
+ fun isSameTrack(other: NowPlaying): Boolean =
+ title == other.title &&
+ artist == other.artist &&
+ url == other.url &&
+ addressId == other.addressId &&
+ eventId == other.eventId
+
+ /**
+ * Same track from the same source, ending within [toleranceSeconds] of [other]. Sources call
+ * this to drop the position ticks some players report every second, which would otherwise
+ * re-emit a "new" value (and re-run everything downstream) for a status that has not changed.
+ */
+ fun isSameMoment(
+ other: NowPlaying?,
+ toleranceSeconds: Long = MOMENT_TOLERANCE_SECONDS,
+ ): Boolean {
+ if (other == null || source != other.source || !isSameTrack(other)) return false
+ val a = endsAt
+ val b = other.endsAt
+ return if (a == null || b == null) a == b else abs(a - b) <= toleranceSeconds
+ }
+
+ companion object {
+ const val MOMENT_TOLERANCE_SECONDS = 5L
+
+ /**
+ * When a track [durationMs] long, now at [positionMs] and playing at [speed], ends,
+ * measured from [nowSeconds]. Null when the duration is unknown or the track already ended.
+ */
+ fun endsAt(
+ nowSeconds: Long,
+ durationMs: Long?,
+ positionMs: Long,
+ speed: Float = 1f,
+ ): Long? {
+ if (durationMs == null || durationMs <= 0) return null
+ val remainingMs = durationMs - positionMs.coerceAtLeast(0)
+ if (remainingMs <= 0) return null
+ val effectiveSpeed = if (speed > 0f) speed else 1f
+ return nowSeconds + (remainingMs / effectiveSpeed / 1000).toLong() + 1
+ }
+ }
+}
diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingAccess.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingAccess.kt
new file mode 100644
index 0000000000..44d3f6db59
--- /dev/null
+++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingAccess.kt
@@ -0,0 +1,33 @@
+/*
+ * 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.commons.model.nip38UserStatuses.nowPlaying
+
+/**
+ * The OS permission that sharing other apps' playback depends on. On Android that is notification
+ * access, which only the user can grant in system settings; platforms that need nothing pass no
+ * port at all.
+ */
+interface NowPlayingAccess {
+ fun hasAccess(): Boolean
+
+ /** Takes the user to where the access is granted or revoked. */
+ fun requestAccess()
+}
diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingPublisher.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingPublisher.kt
new file mode 100644
index 0000000000..55a6899d0e
--- /dev/null
+++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingPublisher.kt
@@ -0,0 +1,156 @@
+/*
+ * 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.commons.model.nip38UserStatuses.nowPlaying
+
+import com.vitorpamplona.quartz.utils.Log
+import com.vitorpamplona.quartz.utils.TimeUtils
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlin.coroutines.cancellation.CancellationException
+import kotlin.math.abs
+
+/**
+ * Picks what to share out of the tracks each source reports, in priority order (the in-app
+ * player first), skipping the sources [settings] does not allow.
+ */
+fun pickNowPlaying(
+ settings: NowPlayingSettings,
+ vararg candidates: NowPlaying?,
+): NowPlaying? = candidates.firstOrNull { it != null && settings.isAllowed(it.source) }
+
+/**
+ * Turns a stream of "what is playing now" (null when nothing is) into NIP-38 `music` statuses.
+ *
+ * - A new track is published only after it has played for [Config.startDelayMs], so skipping
+ * through a playlist does not sign and send an event per skipped song.
+ * - The status expires when the track ends (NIP-38 asks music statuses for that), so a crash or a
+ * dead battery never leaves a stale "listening to". When the length is unknown it expires after
+ * [Config.unknownLengthTtlSeconds] and is refreshed shortly before that while still playing.
+ * - A seek or a resume that moves the end by more than [Config.toleranceSeconds] republishes the
+ * same track with the corrected expiration.
+ * - When playback stops, the status is cleared (blank content, as NIP-38 says) after
+ * [Config.clearDelayMs], so a short pause or a buffering stall does not clear and re-post it.
+ *
+ * Runs on a single coroutine ([run]); a newer value cancels whatever wait the previous one was in.
+ */
+class NowPlayingPublisher(
+ private val publish: suspend (track: NowPlaying, expiration: Long) -> Unit,
+ private val clear: suspend () -> Unit,
+ private val nowSeconds: () -> Long = TimeUtils::now,
+ private val config: Config = Config(),
+) {
+ data class Config(
+ val startDelayMs: Long = 5_000,
+ val clearDelayMs: Long = 30_000,
+ val unknownLengthTtlSeconds: Long = 600,
+ val refreshLeadSeconds: Long = 60,
+ val toleranceSeconds: Long = 20,
+ )
+
+ private var published: NowPlaying? = null
+ private var publishedExpiration: Long = 0
+
+ suspend fun run(tracks: Flow) {
+ tracks
+ .distinctUntilChanged(::isEquivalent)
+ .collectLatest { track ->
+ if (track == null) stopped() else playing(track)
+ }
+ }
+
+ private fun isEquivalent(
+ old: NowPlaying?,
+ new: NowPlaying?,
+ ): Boolean =
+ when {
+ old == null || new == null -> old == new
+ old.source != new.source || !old.isSameTrack(new) -> false
+ else -> isSameEnd(old.endsAt, new.endsAt)
+ }
+
+ private fun isSameEnd(
+ a: Long?,
+ b: Long?,
+ ) = if (a == null || b == null) a == b else abs(a - b) <= config.toleranceSeconds
+
+ /** The status on relays still shows [track]. */
+ private fun isLive(track: NowPlaying) = published?.isSameTrack(track) == true && publishedExpiration > nowSeconds()
+
+ private suspend fun playing(track: NowPlaying) {
+ if (!isLive(track)) delay(config.startDelayMs)
+
+ while (true) {
+ val now = nowSeconds()
+ val expiration = track.endsAt?.takeIf { it > now } ?: (now + config.unknownLengthTtlSeconds)
+
+ if (!isLive(track) || abs(publishedExpiration - expiration) > config.toleranceSeconds) {
+ send(track, expiration)
+ }
+
+ // A known end needs nothing more: the next track, a seek or a stop comes in as a new value.
+ if (track.endsAt != null) return
+
+ val refreshIn = (publishedExpiration - nowSeconds() - config.refreshLeadSeconds).coerceAtLeast(MIN_REFRESH_SECONDS)
+ delay(refreshIn * 1000)
+ }
+ }
+
+ private suspend fun stopped() {
+ if (published == null) return
+
+ if (publishedExpiration <= nowSeconds()) {
+ // Relays already dropped it.
+ published = null
+ return
+ }
+
+ delay(config.clearDelayMs)
+
+ try {
+ clear()
+ published = null
+ publishedExpiration = 0
+ } catch (e: Exception) {
+ if (e is CancellationException) throw e
+ Log.w("NowPlayingPublisher", "Could not clear the music status", e)
+ }
+ }
+
+ private suspend fun send(
+ track: NowPlaying,
+ expiration: Long,
+ ) {
+ try {
+ publish(track, expiration)
+ published = track
+ publishedExpiration = expiration
+ } catch (e: Exception) {
+ if (e is CancellationException) throw e
+ Log.w("NowPlayingPublisher", "Could not publish the music status", e)
+ }
+ }
+
+ companion object {
+ private const val MIN_REFRESH_SECONDS = 60L
+ }
+}
diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingResolver.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingResolver.kt
new file mode 100644
index 0000000000..8d203fc781
--- /dev/null
+++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingResolver.kt
@@ -0,0 +1,111 @@
+/*
+ * 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.commons.model.nip38UserStatuses.nowPlaying
+
+import com.vitorpamplona.quartz.experimental.audio.track.AudioTrackEvent
+import com.vitorpamplona.quartz.experimental.music.track.MusicTrackEvent
+import com.vitorpamplona.quartz.nip01Core.core.AddressableEvent
+import com.vitorpamplona.quartz.nip01Core.core.Event
+import com.vitorpamplona.quartz.nip19Bech32.Nip19Parser
+import com.vitorpamplona.quartz.nip19Bech32.entities.NAddress
+import com.vitorpamplona.quartz.nip19Bech32.entities.NEvent
+import com.vitorpamplona.quartz.nip19Bech32.entities.NNote
+import com.vitorpamplona.quartz.podcasts.PodcastEpisode
+
+/**
+ * Turns the Nostr event behind an in-app player into a [NowPlaying], or null when the event is
+ * not something to share as a listening status.
+ *
+ * Only music tracks (kind 36787), audio tracks (kind 31337) and podcast episodes (both drafts)
+ * qualify. Everything else the app plays (feed videos, voice messages, live streams) returns null,
+ * so autoplaying a clip never announces itself as "listening to".
+ *
+ * [fallbackTitle] and [fallbackArtist] are what the player shows (the event's title and the
+ * author's display name) and fill the gaps an event leaves.
+ */
+object NowPlayingResolver {
+ /**
+ * Resolves the `nostr:` URI the in-app player carries (`Note.toNostrUri()`) to its event with
+ * [findEvent] (given an event id or an `kind:pubkey:d` address) and then calls [fromEvent].
+ */
+ fun fromNostrUri(
+ uri: String,
+ findEvent: (key: String) -> Event?,
+ fallbackTitle: String? = null,
+ fallbackArtist: String? = null,
+ endsAt: Long? = null,
+ ): NowPlaying? {
+ val key = noteKey(uri) ?: return null
+ val event = findEvent(key) ?: return null
+ return fromEvent(event, fallbackTitle, fallbackArtist, endsAt)
+ }
+
+ /** The cache key (event id, or `kind:pubkey:d` address) a `nostr:` note URI points at. */
+ fun noteKey(uri: String): String? =
+ when (val entity = Nip19Parser.uriToRoute(uri)?.entity) {
+ is NEvent -> entity.hex
+ is NNote -> entity.hex
+ is NAddress -> entity.aTag()
+ else -> null
+ }
+
+ fun fromEvent(
+ event: Event,
+ fallbackTitle: String? = null,
+ fallbackArtist: String? = null,
+ endsAt: Long? = null,
+ ): NowPlaying? {
+ val title: String?
+ val artist: String?
+
+ when (event) {
+ is MusicTrackEvent -> {
+ title = event.title()
+ artist = event.artist() ?: fallbackArtist
+ }
+
+ is AudioTrackEvent -> {
+ title = event.subject()
+ artist = fallbackArtist
+ }
+
+ is PodcastEpisode -> {
+ title = event.episodeTitle()
+ artist = fallbackArtist
+ }
+
+ else -> {
+ return null
+ }
+ }
+
+ val bestTitle = title?.ifBlank { null } ?: fallbackTitle?.ifBlank { null } ?: return null
+
+ return NowPlaying(
+ title = bestTitle,
+ artist = artist?.ifBlank { null },
+ source = NowPlayingSource.InApp,
+ endsAt = endsAt,
+ addressId = (event as? AddressableEvent)?.address()?.toValue(),
+ eventId = if (event is AddressableEvent) null else event.id,
+ )
+ }
+}
diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingSettings.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingSettings.kt
new file mode 100644
index 0000000000..95139b35f0
--- /dev/null
+++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingSettings.kt
@@ -0,0 +1,89 @@
+/*
+ * 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.commons.model.nip38UserStatuses.nowPlaying
+
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.Stable
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.update
+
+/**
+ * What this account shares as its NIP-38 `music` status. Everything is off by default: a listening
+ * status is public, so the user opts in.
+ *
+ * - [shareInApp]: tracks and podcast episodes played in Amethyst.
+ * - [shareOtherApps]: whatever another app on this device reports through the OS media controls
+ * (needs a platform permission on Android), except the apps in [blockedApps].
+ * - [knownApps]: the other apps seen playing so far (id to label), listed on the settings screen
+ * so the user can block one.
+ */
+@Immutable
+data class NowPlayingSettings(
+ val shareInApp: Boolean = false,
+ val shareOtherApps: Boolean = false,
+ val blockedApps: Set = emptySet(),
+ val knownApps: Map = emptyMap(),
+) {
+ fun isEnabled() = shareInApp || shareOtherApps
+
+ fun isAllowed(source: NowPlayingSource): Boolean =
+ when (source) {
+ NowPlayingSource.InApp -> shareInApp
+ is NowPlayingSource.OtherApp -> shareOtherApps && source.id !in blockedApps
+ }
+}
+
+/**
+ * Per-account holder for [NowPlayingSettings] (`Account.nowPlayingSettings`). The platform
+ * restores and persists it (Android: `NowPlayingSettingsStore`).
+ */
+@Stable
+class NowPlayingSettingsState {
+ private val state = MutableStateFlow(NowPlayingSettings())
+
+ val flow: StateFlow = state
+
+ fun restore(settings: NowPlayingSettings) = state.update { settings }
+
+ fun setShareInApp(enabled: Boolean) = state.update { it.copy(shareInApp = enabled) }
+
+ fun setShareOtherApps(enabled: Boolean) = state.update { it.copy(shareOtherApps = enabled) }
+
+ fun setAppBlocked(
+ appId: String,
+ blocked: Boolean,
+ ) = state.update { it.copy(blockedApps = if (blocked) it.blockedApps + appId else it.blockedApps - appId) }
+
+ /** Records an app seen playing, so the settings screen can offer to block it. */
+ fun rememberApp(
+ appId: String,
+ label: String,
+ ) {
+ if (state.value.knownApps[appId] == label) return
+ state.update { it.copy(knownApps = it.knownApps + (appId to label)) }
+ }
+
+ fun forgetApp(appId: String) =
+ state.update {
+ it.copy(knownApps = it.knownApps - appId, blockedApps = it.blockedApps - appId)
+ }
+}
diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingStatusService.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingStatusService.kt
new file mode 100644
index 0000000000..cc82f52b05
--- /dev/null
+++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingStatusService.kt
@@ -0,0 +1,59 @@
+/*
+ * 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.commons.model.nip38UserStatuses.nowPlaying
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.onEach
+
+/**
+ * Wires the platform's playback sources to a [NowPlayingPublisher] under one account's
+ * [settings]. [sources] are in priority order: the first one playing an allowed track wins (the
+ * in-app player goes first, since the user is looking at it).
+ *
+ * Every other app seen playing while [NowPlayingSettings.shareOtherApps] is on is reported to
+ * [onOtherAppSeen], so the settings screen can list it and let the user block it.
+ */
+class NowPlayingStatusService(
+ private val settings: StateFlow,
+ private val sources: List>,
+ private val onOtherAppSeen: (NowPlayingSource.OtherApp) -> Unit,
+ private val publisher: NowPlayingPublisher,
+) {
+ suspend fun run() {
+ val observed =
+ sources.map { source ->
+ source.onEach { track ->
+ val app = track?.source as? NowPlayingSource.OtherApp
+ if (app != null && settings.value.shareOtherApps) onOtherAppSeen(app)
+ }
+ }
+
+ val tracks =
+ combine(listOf(settings) + observed) { values ->
+ val current = values[0] as NowPlayingSettings
+ pickNowPlaying(current, *Array(values.size - 1) { values[it + 1] as NowPlaying? })
+ }
+
+ publisher.run(tracks)
+ }
+}
diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/preferences/NowPlayingSettingsStore.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/preferences/NowPlayingSettingsStore.kt
new file mode 100644
index 0000000000..74da2d9b31
--- /dev/null
+++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/preferences/NowPlayingSettingsStore.kt
@@ -0,0 +1,108 @@
+/*
+ * 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.commons.model.preferences
+
+import androidx.compose.runtime.Stable
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.booleanPreferencesKey
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringSetPreferencesKey
+import com.vitorpamplona.amethyst.commons.model.nip38UserStatuses.nowPlaying.NowPlayingSettings
+import com.vitorpamplona.amethyst.commons.model.nip38UserStatuses.nowPlaying.NowPlayingSettingsState
+import com.vitorpamplona.quartz.nip01Core.core.HexKey
+import com.vitorpamplona.quartz.utils.Log
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.drop
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import kotlin.coroutines.cancellation.CancellationException
+
+/**
+ * Per-account persistence for [NowPlayingSettings]. Keys are namespaced by pubkey because the
+ * status is published by that account. Loads the saved settings into [state] on construction, then
+ * writes every later change back. Construct once per account, eagerly.
+ */
+@Stable
+class NowPlayingSettingsStore(
+ private val store: DataStore,
+ private val scope: CoroutineScope,
+ pubKeyHex: HexKey,
+ private val state: NowPlayingSettingsState,
+) {
+ private val shareInApp = booleanPreferencesKey("$KEY_PREFIX$pubKeyHex.shareInApp")
+ private val shareOtherApps = booleanPreferencesKey("$KEY_PREFIX$pubKeyHex.shareOtherApps")
+ private val blockedApps = stringSetPreferencesKey("$KEY_PREFIX$pubKeyHex.blockedApps")
+ private val knownApps = stringSetPreferencesKey("$KEY_PREFIX$pubKeyHex.knownApps")
+
+ init {
+ scope.launch {
+ restoreFromDisk()
+ // drop(1) skips the value present at collection start, which restoreFromDisk already wrote.
+ state.flow.drop(1).collect { persist(it) }
+ }
+ }
+
+ private suspend fun restoreFromDisk() {
+ try {
+ val prefs = store.data.first()
+ state.restore(
+ NowPlayingSettings(
+ shareInApp = prefs[shareInApp] ?: false,
+ shareOtherApps = prefs[shareOtherApps] ?: false,
+ blockedApps = prefs[blockedApps] ?: emptySet(),
+ knownApps = decodeApps(prefs[knownApps] ?: emptySet()),
+ ),
+ )
+ } catch (e: Exception) {
+ if (e is CancellationException) throw e
+ Log.e("NowPlayingSettingsStore") { "Error reading now playing settings: ${e.message}" }
+ }
+ }
+
+ private suspend fun persist(value: NowPlayingSettings) {
+ try {
+ store.edit { prefs ->
+ prefs[shareInApp] = value.shareInApp
+ prefs[shareOtherApps] = value.shareOtherApps
+ prefs[blockedApps] = value.blockedApps
+ prefs[knownApps] = encodeApps(value.knownApps)
+ }
+ } catch (e: Exception) {
+ if (e is CancellationException) throw e
+ Log.e("NowPlayingSettingsStore") { "Error writing now playing settings: ${e.message}" }
+ }
+ }
+
+ companion object {
+ private const val KEY_PREFIX = "nowPlaying."
+ private const val SEPARATOR = '\t'
+
+ fun encodeApps(apps: Map): Set = apps.mapTo(mutableSetOf()) { (id, label) -> "$id$SEPARATOR$label" }
+
+ fun decodeApps(raw: Set): Map =
+ raw
+ .mapNotNull { entry ->
+ val split = entry.indexOf(SEPARATOR)
+ if (split <= 0) null else entry.substring(0, split) to entry.substring(split + 1)
+ }.toMap()
+ }
+}
diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/HtmlParser.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/HtmlParser.kt
index 823862bf31..27571bebae 100644
--- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/HtmlParser.kt
+++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/HtmlParser.kt
@@ -49,7 +49,7 @@ class HtmlParser {
?: bodyBytes.bomCharsetName()
?: HtmlCharsetParser.detectCharset(bodyBytes)
val content = decodeBytes(bodyBytes, name)
- MetaTagsParser.parse(content)
+ MetaTagsParser.parse(content, includeTitleAndIcons = true)
}
private fun ByteArray.bomCharsetName(): String? {
diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/MetaTagsParser.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/MetaTagsParser.kt
index 62e46ced82..5f4bd4cd4b 100644
--- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/MetaTagsParser.kt
+++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/MetaTagsParser.kt
@@ -22,8 +22,21 @@ package com.vitorpamplona.amethyst.commons.preview
import com.vitorpamplona.amethyst.commons.util.codePointToChars
+/** The `` element a [MetaTag] was read from. */
+enum class HeadElement {
+ /** A `` tag, the only kind [MetaTagsParser.parse] yields unless asked for more. */
+ META,
+
+ /** The document's ``, its text carried as the `content` attribute. */
+ TITLE,
+
+ /** A `<link>` whose `rel` names an icon (`icon`, `shortcut icon`, `apple-touch-icon`, …). */
+ LINK,
+}
+
data class MetaTag(
private val attrs: Map<String, String>,
+ val element: HeadElement = HeadElement.META,
) {
/**
* Returns a value of an attribute specified by its name (case insensitive), or empty string if it doesn't exist.
@@ -43,7 +56,17 @@ object MetaTagsParser {
private const val NO_QUOTE = ' '
private const val META = "meta"
+ private const val LINK = "link"
private const val HEAD = "head"
+ private const val BODY = "body"
+ private const val ICON = "icon"
+ private const val REL = "rel"
+ private const val CONTENT = "content"
+
+ // A `<title>` is only a fallback label, so one that runs on (an unclosed tag swallowing the
+ // page, a spam keyword dump) is cut rather than carried into the preview cache whole.
+ private const val MAX_TITLE_LENGTH = 300
+ private val WHITESPACE_RUN = Regex("\\s+")
// Elements whose content is text rather than markup: script and style hold raw text, title and
// textarea hold character data. A `<` inside any of them is not a tag.
@@ -66,26 +89,99 @@ object MetaTagsParser {
/** The `</head>` that ends the interesting part of the document. */
HEAD_END,
+ /**
+ * A `<body>` start tag. `</head>` is optional, so on a page that omits it this is the only
+ * sign the head is over.
+ */
+ BODY_START,
+
+ /** A closed `<title>`: its text is [TagScanner.textStart]..<[TagScanner.textEnd]. */
+ TITLE,
+
+ /** A `<link …>` whose attribute span mentions `icon`; same span fields as [META]. */
+ LINK,
+
/** Anything else: other elements, comments, declarations, unparseable markup. */
OTHER,
}
/**
* Lazily parse a partial HTML document and extract meta tags.
+ *
+ * With [includeTitleAndIcons], the document's `<title>` and its icon `<link>`s are yielded
+ * too, tagged by [MetaTag.element]. They are what a page without OpenGraph still offers for a
+ * preview: browsers show exactly these two in a tab.
*/
- fun parse(input: String): Sequence<MetaTag> =
+ fun parse(
+ input: String,
+ includeTitleAndIcons: Boolean = false,
+ ): Sequence<MetaTag> =
sequence {
val s = TagScanner(input)
+ // Meta tags past an implicit end of head are still read, as they always were. The
+ // title and icons are not: past `<body>`, a `<title>` is an inline SVG's tooltip
+ // ("Close", "Menu"), not the page's name.
+ var inBody = false
while (!s.exhausted()) {
- val kind = s.nextTag()
- if (kind == TagKind.HEAD_END) break
- if (kind == TagKind.META) {
- val attrs = parseAttrs(input, s.attrsStart, s.attrsEnd) ?: continue
- yield(MetaTag(attrs))
+ when (s.nextTag()) {
+ TagKind.HEAD_END -> {
+ break
+ }
+
+ TagKind.BODY_START -> {
+ inBody = true
+ }
+
+ TagKind.META -> {
+ val attrs = parseAttrs(input, s.attrsStart, s.attrsEnd) ?: continue
+ yield(MetaTag(attrs))
+ }
+
+ TagKind.TITLE -> {
+ if (includeTitleAndIcons && !inBody) {
+ val text = titleText(input, s.textStart, s.textEnd)
+ if (text.isNotEmpty()) yield(MetaTag(mapOf(CONTENT to text), HeadElement.TITLE))
+ }
+ }
+
+ TagKind.LINK -> {
+ if (includeTitleAndIcons && !inBody) {
+ val attrs = parseAttrs(input, s.attrsStart, s.attrsEnd) ?: continue
+ if (isIconRel(attrs[REL])) yield(MetaTag(attrs, HeadElement.LINK))
+ }
+ }
+
+ TagKind.OTHER -> {}
}
}
}
+ /**
+ * Whether a `rel` names an icon: one of its space-separated tokens is `icon` or an
+ * `apple-touch-icon` variant. `mask-icon` is deliberately not one -- it is Safari's monochrome
+ * pinned-tab silhouette, which renders as a black blob anywhere else.
+ */
+ private fun isIconRel(rel: String?): Boolean =
+ rel != null &&
+ rel.split(' ', '\t', '\n', '\r', '\u000C').any {
+ it.equals(ICON, ignoreCase = true) || it.startsWith("apple-touch-icon", ignoreCase = true)
+ }
+
+ /** The `<title>`'s character data, with references resolved and whitespace collapsed. */
+ private fun titleText(
+ input: String,
+ from: Int,
+ to: Int,
+ ): String {
+ val raw = input.substring(from, to)
+ val decoded = if (raw.indexOf('&') < 0) raw else raw.replace(Attrs.RE_CHAR_REF, Attrs.Companion::replaceCharRefs)
+ val title = decoded.replace(WHITESPACE_RUN, " ").trim()
+ if (title.length <= MAX_TITLE_LENGTH) return title
+ // Never end on half of a surrogate pair: a lone high surrogate renders as tofu.
+ val cut = if (title[MAX_TITLE_LENGTH - 1].isHighSurrogate()) MAX_TITLE_LENGTH - 1 else MAX_TITLE_LENGTH
+ return title.substring(0, cut)
+ }
+
private class TagScanner(
private val input: String,
) {
@@ -98,6 +194,12 @@ object MetaTagsParser {
var attrsEnd = 0
private set
+ /** Character-data span of the `<title>` [nextTag] last reported as [TagKind.TITLE]. */
+ var textStart = 0
+ private set
+ var textEnd = 0
+ private set
+
fun exhausted(): Boolean = p >= length
/**
@@ -128,6 +230,20 @@ object MetaTagsParser {
p = if (end < 0) length else end + 1
}
+ /** True when `input[from..<to]` contains [lower], ASCII-case-insensitively. */
+ private fun spanContains(
+ from: Int,
+ to: Int,
+ lower: String,
+ ): Boolean {
+ var i = from
+ while (i + lower.length <= to) {
+ if (input.regionMatches(i, lower, 0, lower.length, ignoreCase = true)) return true
+ i++
+ }
+ return false
+ }
+
/** Leaves [p] on the `</name` that closes a raw-text element, or at the end of the input. */
private fun skipRawText(endTag: String) {
var i = p
@@ -215,14 +331,25 @@ object MetaTagsParser {
// the same way an unbalanced quote inside a comment does. Switching on the name length
// first keeps the common tag (a `<div>`, a `<link>`) down to one comparison.
when (nameEnd - nameStart) {
- META.length -> if (nameIs(nameStart, nameEnd, META)) return TagKind.META
+ META.length -> {
+ if (nameIs(nameStart, nameEnd, META)) return TagKind.META
+ if (nameIs(nameStart, nameEnd, BODY)) return TagKind.BODY_START
+ // Most `<link>`s are stylesheets and preloads; checking the raw span for `icon`
+ // keeps their attributes from ever being parsed into a map.
+ if (nameIs(nameStart, nameEnd, LINK) && spanContains(attrsStart, attrsEnd, ICON)) return TagKind.LINK
+ }
- STYLE.length ->
+ STYLE.length -> {
if (nameIs(nameStart, nameEnd, STYLE)) {
skipRawText(STYLE_END)
} else if (nameIs(nameStart, nameEnd, TITLE)) {
+ textStart = p
skipRawText(TITLE_END)
+ textEnd = p
+ // An unclosed title runs to the end of the input: that is not a title.
+ if (p < length) return TagKind.TITLE
}
+ }
SCRIPT.length -> if (nameIs(nameStart, nameEnd, SCRIPT)) skipRawText(SCRIPT_END)
diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/OpenGraphParser.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/OpenGraphParser.kt
index 9e4714756b..3c0dfe3667 100644
--- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/OpenGraphParser.kt
+++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/OpenGraphParser.kt
@@ -22,6 +22,7 @@ package com.vitorpamplona.amethyst.commons.preview
class OpenGraphParser {
class Result(
+ /** The OpenGraph/Twitter/meta title, or the document's `<title>` when it declares none. */
val title: String,
val description: String,
val image: String,
@@ -35,6 +36,8 @@ class OpenGraphParser {
val videoType: String = "",
/** `og:type` — what the page says it *is*, e.g. `music.song`, `video.other`, `article`. */
val type: String = "",
+ /** The best icon `<link>` the page declares, verbatim (may be relative). Empty when none. */
+ val icon: String = "",
)
companion object {
@@ -112,6 +115,17 @@ class OpenGraphParser {
)
private val CONTENT = "content"
+ private val HREF = "href"
+ private val REL = "rel"
+ private val SIZES = "sizes"
+ private val TYPE = "type"
+
+ // How an icon with no `sizes` is ranked. An `apple-touch-icon` is 180px by Apple's
+ // convention; a plain `icon` without sizes is usually the 16/32px tab favicon. A scalable
+ // one (SVG, or `sizes="any"`) beats every bitmap: it is sharp at any card size.
+ private const val APPLE_TOUCH_ICON_DEFAULT_SIZE = 180
+ private const val ICON_DEFAULT_SIZE = 32
+ private const val SCALABLE_ICON_SIZE = Int.MAX_VALUE
}
/** Which field of [Result] a meta tag's key fills, or null when the key is not one we read. */
@@ -156,8 +170,33 @@ class OpenGraphParser {
var video = ""
var videoType = ""
var type = ""
+ var documentTitle = ""
+ var icon = ""
+ var iconSize = -1
metaTags.forEach {
+ when (it.element) {
+ HeadElement.META -> {}
+
+ HeadElement.TITLE -> {
+ if (documentTitle.isEmpty()) documentTitle = it.attr(CONTENT)
+ return@forEach
+ }
+
+ HeadElement.LINK -> {
+ val href = it.attr(HREF)
+ if (href.isNotBlank()) {
+ val size = iconSize(it)
+ // Strictly greater, so among equals the first declared wins.
+ if (size > iconSize) {
+ icon = href
+ iconSize = size
+ }
+ }
+ return@forEach
+ }
+ }
+
// A meta tag names its key in exactly one of these three attributes, but which one
// varies by site, so each is tried in turn until one is a key we read.
val field =
@@ -179,6 +218,32 @@ class OpenGraphParser {
null -> Unit
}
}
- return Result(title, description, image, audio, audioType, video, videoType, type)
+ return Result(title.ifEmpty { documentTitle }, description, image, audio, audioType, video, videoType, type, icon)
+ }
+
+ /** The pixel size an icon `<link>` is ranked by: its largest declared size, or a default. */
+ private fun iconSize(link: MetaTag): Int {
+ val sizes = link.attr(SIZES)
+ if (sizes.contains("any", ignoreCase = true)) return SCALABLE_ICON_SIZE
+ if (link.attr(TYPE).equals("image/svg+xml", ignoreCase = true)) return SCALABLE_ICON_SIZE
+ if (link
+ .attr(HREF)
+ .substringBefore('?')
+ .substringBefore('#')
+ .endsWith(".svg", ignoreCase = true)
+ ) {
+ return SCALABLE_ICON_SIZE
+ }
+
+ // `sizes="16x16 32x32"`: rank by the largest, which is the one a decoder will pick.
+ val declared =
+ sizes
+ .split(' ')
+ .mapNotNull { it.lowercase().substringBefore('x', "").toIntOrNull() }
+ .maxOrNull()
+ if (declared != null) return declared
+
+ val isAppleTouch = link.attr(REL).contains("apple-touch-icon", ignoreCase = true)
+ return if (isAppleTouch) APPLE_TOUCH_ICON_DEFAULT_SIZE else ICON_DEFAULT_SIZE
}
}
diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/UrlInfoItem.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/UrlInfoItem.kt
index 5cb955845d..4977a6cd67 100644
--- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/UrlInfoItem.kt
+++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/preview/UrlInfoItem.kt
@@ -43,6 +43,8 @@ class UrlInfoItem(
val videoType: String = "",
/** `og:type` — what the page says it is, e.g. `music.song`, `video.other`, `article`. */
val type: String = "",
+ /** The page's best declared icon `<link>` (favicon / apple-touch-icon). Empty when none. */
+ val icon: String = "",
) {
/** The page's host, or null when [url] is not an absolute URL. */
val verifiedHost = absoluteUrlHost(url)
@@ -66,6 +68,24 @@ class UrlInfoItem(
// which is what it did before. Only the playable gate below treats unresolvable as refusal.
val imageUrlFullPath = resolve(image) ?: image
+ /**
+ * The page's icon, absolute: the one it declared, else `/favicon.ico` at its origin -- the
+ * same guess every browser makes, since most sites that declare nothing still serve one.
+ *
+ * A `data:` icon is used as-is when it is an image (the image loader decodes those inline),
+ * and taken at its word when it is not: `href="data:,"` is how a site tells browsers it has no
+ * favicon, so guessing `/favicon.ico` there is a request that is known to miss.
+ *
+ * Null for a non-HTML URL (an image or a video is its own preview) or an unresolvable one.
+ */
+ val iconUrlFullPath: String? =
+ when {
+ !mimeType.startsWith("text/html", ignoreCase = true) -> null
+ icon.startsWith("data:image/", ignoreCase = true) -> if (icon.length <= MAX_INLINE_ICON_LENGTH) icon else resolve(DEFAULT_FAVICON)
+ icon.startsWith("data:", ignoreCase = true) -> null
+ else -> resolve(icon) ?: resolve(DEFAULT_FAVICON)
+ }
+
/**
* The declared `og:video`, absolute, but only when the declaration holds up: a [videoType] the
* renderer can actually play (a `video/` MIME, an `audio/` one, or an HLS playlist type), or
@@ -119,13 +139,29 @@ class UrlInfoItem(
else -> audioType.ifEmpty { null }
}
+ /**
+ * Whether the page has text to show without an image: a title (OpenGraph's or the document's
+ * own `<title>`) or a description. Such a page gets the compact icon + text card rather than
+ * a bare link.
+ */
+ val hasTextPreview: Boolean = title.isNotBlank() || description.isNotBlank()
+
/**
* Whether the fetch produced something worth rendering. An image is the usual evidence, but a
* page that declared playable media counts too — a track page that ships no cover art would
* otherwise be thrown away as Empty and fall back to a bare link, which is exactly the player
- * we went to the trouble of finding.
+ * we went to the trouble of finding. So does a page with no OpenGraph at all that still has a
+ * title or description: it renders as the compact card instead of a bare link.
*/
- fun fetchComplete(): Boolean = url.isNotEmpty() && (image.isNotEmpty() || playableMediaUrl != null)
+ fun fetchComplete(): Boolean = url.isNotEmpty() && (image.isNotEmpty() || playableMediaUrl != null || hasTextPreview)
fun allFetchComplete(): Boolean = title.isNotEmpty() && description.isNotEmpty() && image.isNotEmpty()
+
+ companion object {
+ private const val DEFAULT_FAVICON = "/favicon.ico"
+
+ // Previews are cached, so an inline icon is held for as long as its card is. Real inline
+ // favicons are a few KB; anything far past that is not worth keeping in memory.
+ private const val MAX_INLINE_ICON_LENGTH = 64 * 1024
+ }
}
diff --git a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/UserStatusCacheTest.kt b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/UserStatusCacheTest.kt
new file mode 100644
index 0000000000..d175a52fb8
--- /dev/null
+++ b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/UserStatusCacheTest.kt
@@ -0,0 +1,61 @@
+/*
+ * 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.commons.model.nip38UserStatuses
+
+import com.vitorpamplona.amethyst.commons.model.AddressableNote
+import com.vitorpamplona.amethyst.commons.model.User
+import com.vitorpamplona.amethyst.commons.model.UserContext
+import com.vitorpamplona.quartz.nip01Core.core.Address
+import com.vitorpamplona.quartz.nip38UserStatus.UserStatusEvent
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class UserStatusCacheTest {
+ private val pubKey = "b".repeat(64)
+ private val sig = "c".repeat(128)
+ private val author = User(pubKey, UserContext { addr -> AddressableNote(addr) })
+
+ private fun status(
+ id: Char,
+ content: String,
+ createdAt: Long,
+ ) = UserStatusEvent(id.toString().repeat(64), pubKey, createdAt, arrayOf(arrayOf("d", UserStatusEvent.MUSIC)), content, sig)
+
+ @Test
+ fun aClearedStatusLeavesTheList() {
+ val cache = UserStatusCache()
+ val note = AddressableNote(Address(UserStatusEvent.KIND, pubKey, UserStatusEvent.MUSIC))
+
+ note.loadEvent(status('1', "Song - Band", 100), author, emptyList())
+ cache.addStatus(note)
+ assertEquals(listOf(note), cache.statuses.value)
+
+ // The same address now holds the newer, blank version: nothing to show any more.
+ note.loadEvent(status('2', "", 200), author, emptyList())
+ cache.addStatus(note)
+ assertEquals(emptyList(), cache.statuses.value)
+
+ // And a new track brings it back.
+ note.loadEvent(status('3', "Other Song - Band", 300), author, emptyList())
+ cache.addStatus(note)
+ assertEquals(listOf(note), cache.statuses.value)
+ }
+}
diff --git a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingPublisherTest.kt b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingPublisherTest.kt
new file mode 100644
index 0000000000..c4761cb6b1
--- /dev/null
+++ b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingPublisherTest.kt
@@ -0,0 +1,229 @@
+/*
+ * 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.commons.model.nip38UserStatuses.nowPlaying
+
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class NowPlayingPublisherTest {
+ private val base = 1_700_000_000L
+
+ private class Recorder {
+ val published = mutableListOf<Pair<NowPlaying, Long>>()
+ var clears = 0
+ }
+
+ private fun TestScope.now() = base + testScheduler.currentTime / 1000
+
+ private fun TestScope.start(source: MutableStateFlow<NowPlaying?>): Recorder {
+ val recorder = Recorder()
+ val publisher =
+ NowPlayingPublisher(
+ publish = { track, expiration -> recorder.published.add(track to expiration) },
+ clear = { recorder.clears++ },
+ nowSeconds = { now() },
+ )
+ backgroundScope.launch { publisher.run(source) }
+ runCurrent()
+ return recorder
+ }
+
+ private fun TestScope.track(
+ title: String,
+ remainingSeconds: Long? = 180,
+ ) = NowPlaying(
+ title = title,
+ artist = "Artist",
+ source = NowPlayingSource.InApp,
+ endsAt = remainingSeconds?.let { now() + it },
+ )
+
+ @Test
+ fun publishesAfterTheStartDelayWithTheTrackEndAsExpiration() =
+ runTest {
+ val source = MutableStateFlow<NowPlaying?>(null)
+ val recorder = start(source)
+
+ val song = track("Song")
+ source.value = song
+ advanceTimeBy(4_000)
+ assertEquals(0, recorder.published.size)
+
+ advanceTimeBy(2_000)
+ assertEquals(1, recorder.published.size)
+ assertEquals(song, recorder.published[0].first)
+ assertEquals(song.endsAt, recorder.published[0].second)
+ }
+
+ @Test
+ fun skippingThroughTracksOnlyPublishesTheOneThatKeepsPlaying() =
+ runTest {
+ val source = MutableStateFlow<NowPlaying?>(null)
+ val recorder = start(source)
+
+ source.value = track("One")
+ advanceTimeBy(2_000)
+ source.value = track("Two")
+ advanceTimeBy(2_000)
+ source.value = track("Three")
+ advanceTimeBy(10_000)
+
+ assertEquals(listOf("Three"), recorder.published.map { it.first.title })
+ }
+
+ @Test
+ fun aShortPauseNeitherClearsNorRepublishes() =
+ runTest {
+ val source = MutableStateFlow<NowPlaying?>(null)
+ val recorder = start(source)
+
+ source.value = track("Song", remainingSeconds = 180)
+ advanceTimeBy(6_000)
+ assertEquals(1, recorder.published.size)
+
+ source.value = null
+ advanceTimeBy(10_000)
+ // Resumed 10s later: the end moved by 10s, within the tolerance.
+ source.value = track("Song", remainingSeconds = 174)
+ advanceTimeBy(60_000)
+
+ assertEquals(0, recorder.clears)
+ assertEquals(1, recorder.published.size)
+ }
+
+ @Test
+ fun stoppingClearsTheStatusAfterTheClearDelay() =
+ runTest {
+ val source = MutableStateFlow<NowPlaying?>(null)
+ val recorder = start(source)
+
+ source.value = track("Song")
+ advanceTimeBy(6_000)
+ source.value = null
+ advanceTimeBy(29_000)
+ assertEquals(0, recorder.clears)
+
+ advanceTimeBy(2_000)
+ assertEquals(1, recorder.clears)
+ }
+
+ @Test
+ fun aStatusThatAlreadyExpiredIsNotCleared() =
+ runTest {
+ val source = MutableStateFlow<NowPlaying?>(null)
+ val recorder = start(source)
+
+ source.value = track("Short", remainingSeconds = 20)
+ advanceTimeBy(30_000)
+ source.value = null
+ advanceTimeBy(120_000)
+
+ assertEquals(1, recorder.published.size)
+ assertEquals(0, recorder.clears)
+ }
+
+ @Test
+ fun seekingRepublishesWithTheNewEnd() =
+ runTest {
+ val source = MutableStateFlow<NowPlaying?>(null)
+ val recorder = start(source)
+
+ source.value = track("Song", remainingSeconds = 180)
+ advanceTimeBy(6_000)
+ val seeked = track("Song", remainingSeconds = 60)
+ source.value = seeked
+ runCurrent()
+
+ assertEquals(2, recorder.published.size)
+ assertEquals(seeked.endsAt, recorder.published[1].second)
+ }
+
+ @Test
+ fun anUnknownLengthIsRefreshedBeforeItExpires() =
+ runTest {
+ val source = MutableStateFlow<NowPlaying?>(null)
+ val recorder = start(source)
+
+ source.value = track("Radio", remainingSeconds = null)
+ advanceTimeBy(6_000)
+ assertEquals(1, recorder.published.size)
+ assertEquals(now() - 1 + 600, recorder.published[0].second)
+
+ // Refreshed a minute before the 10-minute expiration.
+ advanceTimeBy(541_000)
+ assertEquals(2, recorder.published.size)
+ }
+
+ @Test
+ fun pickHonorsSettingsAndTheBlockList() {
+ val inApp = NowPlaying("In app", source = NowPlayingSource.InApp)
+ val spotify = NowPlaying("Other", source = NowPlayingSource.OtherApp("com.spotify.music", "Spotify"))
+
+ assertNull(pickNowPlaying(NowPlayingSettings(), inApp, spotify))
+ assertEquals(inApp, pickNowPlaying(NowPlayingSettings(shareInApp = true, shareOtherApps = true), inApp, spotify))
+ assertEquals(spotify, pickNowPlaying(NowPlayingSettings(shareOtherApps = true), inApp, spotify))
+ assertEquals(spotify, pickNowPlaying(NowPlayingSettings(shareInApp = true, shareOtherApps = true), null, spotify))
+ assertNull(
+ pickNowPlaying(
+ NowPlayingSettings(shareOtherApps = true, blockedApps = setOf("com.spotify.music")),
+ null,
+ spotify,
+ ),
+ )
+ }
+
+ @Test
+ fun statusTextFollowsTheNipExample() {
+ assertEquals("Intergalactic - Beastie Boys", NowPlaying("Intergalactic", "Beastie Boys", NowPlayingSource.InApp).statusText())
+ assertEquals("Intergalactic", NowPlaying("Intergalactic", null, NowPlayingSource.InApp).statusText())
+ }
+
+ @Test
+ fun aPositionTickIsTheSameMomentButASeekIsNot() {
+ val song = NowPlaying("Song", "Band", NowPlayingSource.InApp, endsAt = 1_000)
+
+ assertTrue(song.isSameMoment(song.copy(endsAt = 1_004)))
+ assertFalse(song.isSameMoment(song.copy(endsAt = 1_060)))
+ assertFalse(song.isSameMoment(song.copy(title = "Other")))
+ assertFalse(song.isSameMoment(song.copy(source = NowPlayingSource.OtherApp("x", "X"))))
+ assertFalse(song.isSameMoment(null))
+ assertTrue(song.copy(endsAt = null).isSameMoment(song.copy(endsAt = null)))
+ }
+
+ @Test
+ fun endsAtAccountsForPositionAndSpeed() {
+ assertEquals(1_000L + 60 + 1, NowPlaying.endsAt(1_000, durationMs = 180_000, positionMs = 120_000))
+ assertEquals(1_000L + 30 + 1, NowPlaying.endsAt(1_000, durationMs = 180_000, positionMs = 120_000, speed = 2f))
+ assertNull(NowPlaying.endsAt(1_000, durationMs = null, positionMs = 0))
+ assertNull(NowPlaying.endsAt(1_000, durationMs = 1_000, positionMs = 2_000))
+ }
+}
diff --git a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingResolverTest.kt b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingResolverTest.kt
new file mode 100644
index 0000000000..d09a83b28f
--- /dev/null
+++ b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/nip38UserStatuses/nowPlaying/NowPlayingResolverTest.kt
@@ -0,0 +1,73 @@
+/*
+ * 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.commons.model.nip38UserStatuses.nowPlaying
+
+import com.vitorpamplona.quartz.experimental.music.track.MusicTrackEvent
+import com.vitorpamplona.quartz.nip10Notes.TextNoteEvent
+import com.vitorpamplona.quartz.nipF4Podcasts.episode.PodcastEpisodeEvent
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+
+class NowPlayingResolverTest {
+ private val id = "a".repeat(64)
+ private val pubKey = "b".repeat(64)
+ private val sig = "c".repeat(128)
+
+ @Test
+ fun musicTrackPointsAtItsAddress() {
+ val event =
+ MusicTrackEvent(
+ id,
+ pubKey,
+ 1L,
+ arrayOf(arrayOf("d", "song"), arrayOf("title", "Song"), arrayOf("artist", "Band")),
+ "",
+ sig,
+ )
+
+ val track = NowPlayingResolver.fromEvent(event, fallbackArtist = "Uploader", endsAt = 10L)!!
+
+ assertEquals("Song - Band", track.statusText())
+ assertEquals("${MusicTrackEvent.KIND}:$pubKey:song", track.addressId)
+ assertNull(track.eventId)
+ assertEquals(10L, track.endsAt)
+ assertEquals(NowPlayingSource.InApp, track.source)
+ }
+
+ @Test
+ fun podcastEpisodeUsesTheShowAsArtistAndPointsAtTheEvent() {
+ val event = PodcastEpisodeEvent(id, pubKey, 1L, arrayOf(arrayOf("title", "Episode 1")), "", sig)
+
+ val track = NowPlayingResolver.fromEvent(event, fallbackArtist = "The Show")!!
+
+ assertEquals("Episode 1 - The Show", track.statusText())
+ assertEquals(id, track.eventId)
+ assertNull(track.addressId)
+ }
+
+ @Test
+ fun otherEventsAreNotShared() {
+ val event = TextNoteEvent(id, pubKey, 1L, emptyArray(), "a video", sig)
+
+ assertNull(NowPlayingResolver.fromEvent(event, fallbackTitle = "video", fallbackArtist = "someone"))
+ }
+}
diff --git a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/preview/TitleAndIconFallbackTest.kt b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/preview/TitleAndIconFallbackTest.kt
new file mode 100644
index 0000000000..4822fceaa4
--- /dev/null
+++ b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/preview/TitleAndIconFallbackTest.kt
@@ -0,0 +1,213 @@
+/*
+ * 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.commons.preview
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+/**
+ * A page with no OpenGraph still has what a browser tab shows: its `<title>` and its icon
+ * `<link>`s. These are read only when asked for, and only ever as a fallback.
+ */
+class TitleAndIconFallbackTest {
+ private fun headTags(html: String) = MetaTagsParser.parse(html, includeTitleAndIcons = true).toList()
+
+ private fun extract(html: String) = OpenGraphParser().extractUrlInfo(MetaTagsParser.parse(html, includeTitleAndIcons = true))
+
+ // Trimmed from the nsite that prompted this: no og:*, no twitter:*, only a title, a meta
+ // description and an SVG favicon.
+ private val noOpenGraphPage =
+ """
+ |<!DOCTYPE html>
+ |<html lang="en">
+ |<head>
+ |<meta charset="utf-8">
+ |<meta name="viewport" content="width=device-width, initial-scale=1">
+ |<title>Private Provider — Confidential AI
+ |
+ |
+ |
+ |
+ |