Napstr cover events (kind 30427): host-resolved art, phone scraper removed

.gitattributes

@@ -0,0 +1,8 @@
+# Shell scripts are executed inside the Linux build containers, which mount this
+# working tree directly rather than checking it out themselves. With
+# core.autocrlf=true a Windows working copy would hand those scripts CRLF
+# endings, and bash stops on the second line of every one of them:
+#   set: pipefail\r: invalid option name
+# Pinning them to LF keeps the mounted scripts runnable from any host.
+*.sh text eol=lf
+scripts/appimage/AppRun text eol=lf

.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "chat.tools.terminal.autoApprove": {
+        "Get-Item": true,
+        "cargo build": true,
+        "git rev-parse": true
+    }
+}

PROTOCOL.md

@@ -704,6 +704,9 @@ discriminator. Defined requests are:
 {"type":"transfers"}
 {"type":"fetchAudio","fileId":"<fileId>"}
 {"type":"available","fileIds":["<fileId>","<fileId>"]}
+{"type":"albumCovers","keys":["<artist|album>"]}
+{"type":"playback","command":{"type":"playTrack","fileId":"<fileId>","queue":["<fileId>"]}}
+{"type":"playbackState"}
 {"type":"status"}
 {"type":"ping"}
 ```
@@ -736,6 +739,33 @@ increasing local-library revision. A companion MAY poll it and should reload
 library pages only when it changes. The revision check carries no catalogue
 rows and does not affect active audio streams.
 
+It also contains `coverRevision`, which moves whenever the album art the
+desktop would report changes: a claim that arrived from a relay, or art the
+desktop resolved for itself. Artwork is requested album by album, so a
+companion that caches covers — including the albums the desktop had none for —
+MUST ask again about the ones it was told were missing when this changes,
+because an album with no art a moment ago may have art now. A desktop that has
+no cover support reports `0`, which a companion MUST read as "never
+invalidated" rather than as a revision of zero.
+
+`playback` drives the desktop's own player, and only a pairing with write access
+may send it. Its `command.type` values are `play`, `pause`, `toggle`, `stop`,
+`next`, `previous`, `seek` (`positionMs`), `volume` (`percent`, 0 to 100),
+`repeat` (`mode` of `off`, `all` or `one`), `shuffle` (`enabled`), and
+`playTrack`. Both `playback` and `playbackState` answer with a `playback`
+response carrying the host's own state, which includes its `queueLen`,
+`queueIndex`, `repeat` and `shuffle`.
+
+`playTrack` is how a companion plays a chosen track on the desktop instead of on
+itself. `fileId` is the track to begin on and `queue` is the list the companion
+was showing, in order, at most 200 entries. The desktop adopts that list as its
+queue, so "next" goes where the companion would have gone, but it plays only the
+entries it actually holds — exactly as it does for its own search results — and
+refuses a request whose track it does not have rather than playing something
+else. Commands the native player can carry out alone are applied directly;
+`next`, `previous`, `repeat`, `shuffle` and `playTrack` are handed to the
+desktop's window, because only the window knows the queue.
+
 For `fetchAudio`, an `audioReady` control frame is immediately followed on the
 same receive stream by exactly `track.size` raw bytes and then stream finish.
 The desktop MUST serve only an indexed supported-audio path contained by the
@@ -762,6 +792,12 @@ button. A report is kind `1984`:
 }
 ```
 
+`x` always carries the SHA-256 of the reported content, as NIP-56 defines it.
+A report about an album cover names the cover event with `e` and carries the
+album key in a `napstr-cover` tag; it MUST NOT put the album key in `x`. See
+[NIP-NAPSTR-COVER.md](NIP-NAPSTR-COVER.md) for the cover report shape and for
+why the key is repeated there.
+
 Supported report types are `illegal`, `malware`, `spam`, `nudity`, `profanity`,
 `impersonation`, and `other`.
 

android/native/android/BackBridge.kt

@@ -0,0 +1,63 @@
+package net.napstr.nostrfy
+
+import android.webkit.JavascriptInterface
+import android.webkit.WebView
+import java.lang.ref.WeakReference
+
+/**
+ * Lets the page own the hardware back button.
+ *
+ * Kotlin cannot ask the page whether it has anything for back to close, so the
+ * webview pushes that flag on every transition and after every press it handles.
+ * While it is set, a back press is handed to the page and consumed; otherwise the
+ * press goes back to the system, so back still leaves the app when the page has
+ * nothing open.
+ */
+class BackBridge {
+  @JavascriptInterface
+  fun setBackAvailable(available: Boolean) {
+    backAvailable = available
+  }
+
+  /** The older name for the same flag, for a page that predates this one. */
+  @JavascriptInterface
+  fun setDrawerOpen(open: Boolean) {
+    backAvailable = open
+  }
+
+  companion object {
+    private const val BACK_EVENT = "napstrfy-back"
+    // Written from the webview's JS bridge thread and read from the UI thread.
+    @Volatile private var backAvailable = false
+    private var webView = WeakReference<WebView>(null)
+
+    fun attach(next: WebView) {
+      webView = WeakReference(next)
+    }
+
+    fun detach() {
+      backAvailable = false
+      webView.clear()
+    }
+
+    /**
+     * True when the press was handed to the page rather than the system.
+     *
+     * Clearing the flag here is what makes one press one answer: the page
+     * publishes again as soon as it has moved, which is why a page that still
+     * has somewhere to go - the search tab under the liked page - is not left
+     * with a flag that says otherwise and then goes unheard.
+     */
+    fun consumeBack(): Boolean {
+      if (!backAvailable) return false
+      backAvailable = false
+      webView.get()?.post {
+        webView.get()?.evaluateJavascript(
+          "window.dispatchEvent(new CustomEvent('$BACK_EVENT'))",
+          null
+        )
+      }
+      return true
+    }
+  }
+}

android/native/android/MainActivity.kt

@@ -7,6 +7,7 @@ import android.os.Bundle
 import android.view.WindowManager
 import android.webkit.WebSettings
 import android.webkit.WebView
+import androidx.activity.addCallback
 import androidx.activity.enableEdgeToEdge
 import androidx.core.app.ActivityCompat
 import androidx.core.content.ContextCompat
@@ -19,6 +20,14 @@ class MainActivity : TauriActivity() {
     super.onCreate(savedInstanceState)
     // Keep Napstrfy visible until the user locks the phone or leaves the app.
     window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+    // The page gets first refusal on back, then the press continues to the
+    // system so back still leaves the app when nothing is open.
+    onBackPressedDispatcher.addCallback(this) {
+      if (BackBridge.consumeBack()) return@addCallback
+      isEnabled = false
+      onBackPressedDispatcher.onBackPressed()
+      isEnabled = true
+    }
   }
 
   override fun onWebViewCreate(webView: WebView) {
@@ -27,7 +36,9 @@ class MainActivity : TauriActivity() {
     // token-protected loopback server allowed by the CSP and network policy.
     webView.settings.mixedContentMode = WebSettings.MIXED_CONTENT_ALWAYS_ALLOW
     MediaControlBridge.attach(webView)
+    BackBridge.attach(webView)
     webView.addJavascriptInterface(MediaControlBridge(this), "NapstrfyMedia")
+    webView.addJavascriptInterface(BackBridge(), "NapstrfyBack")
   }
 
   fun ensureMediaNotificationPermission() {
@@ -48,6 +59,7 @@ class MainActivity : TauriActivity() {
 
   override fun onDestroy() {
     MediaControlBridge.detach()
+    BackBridge.detach()
     super.onDestroy()
   }
 

android/native/android/MediaControlBridge.kt

@@ -21,14 +21,26 @@ class MediaControlBridge(private val activity: MainActivity) {
       action = MediaNotificationService.ACTION_UPDATE
       putExtra(MediaNotificationService.EXTRA_TITLE, safeText(state.optString("title"), 300))
       putExtra(MediaNotificationService.EXTRA_ARTIST, safeText(state.optString("artist"), 300))
+      putExtra(MediaNotificationService.EXTRA_ARTWORK, safeText(state.optString("artwork"), 512))
       putExtra(MediaNotificationService.EXTRA_PLAYING, state.optBoolean("playing"))
       putExtra(MediaNotificationService.EXTRA_POSITION, state.optDouble("position").coerceIn(0.0, MAX_SECONDS).toLong() * 1000L)
       putExtra(MediaNotificationService.EXTRA_DURATION, state.optDouble("duration").coerceIn(0.0, MAX_SECONDS).toLong() * 1000L)
       putExtra(MediaNotificationService.EXTRA_CAN_PREVIOUS, state.optBoolean("canPrevious"))
       putExtra(MediaNotificationService.EXTRA_CAN_NEXT, state.optBoolean("canNext"))
       putExtra(MediaNotificationService.EXTRA_CAN_SEEK, state.optBoolean("canSeek"))
+      putExtra(MediaNotificationService.EXTRA_LIKED, state.optBoolean("liked"))
+      putExtra(MediaNotificationService.EXTRA_LOOPING, state.optBoolean("looping"))
+      // The state describes the computer's player rather than this phone's, and
+      // volume is a percentage of the computer's volume.
+      putExtra(MediaNotificationService.EXTRA_REMOTE, state.optBoolean("remote"))
+      putExtra(MediaNotificationService.EXTRA_VOLUME, state.optInt("volume", 0))
+      // Labels are translated by the webview, which owns the chosen language.
       val labels = state.optJSONObject("labels")
-      for (key in listOf("previous", "rewind", "play", "pause", "forward", "next", "channel")) {
+      for (key in listOf(
+          "previous", "rewind", "play", "pause", "forward", "next", "channel",
+          "like", "unlike", "repeat", "repeatOff"
+        )
+      ) {
         putExtra("label_$key", safeText(labels?.optString(key).orEmpty(), 100))
       }
     }
@@ -57,7 +69,14 @@ class MediaControlBridge(private val activity: MainActivity) {
     }
 
     fun dispatch(action: String) {
-      if (action !in setOf("play", "pause", "previous", "next", "rewind", "forward") && !action.startsWith("seek:")) return
+      if (action !in setOf(
+          "play", "pause", "previous", "next", "rewind", "forward", "like", "repeat",
+          "volumeUp", "volumeDown"
+        ) &&
+        !action.startsWith("seek:")
+      ) {
+        return
+      }
       webView.get()?.post {
         val encoded = JSONObject.quote(action)
         webView.get()?.evaluateJavascript(