The resume card read only the item's artUri, which stays empty for a
network song whose cover the store does not hold, such as the first
launch after an update from a build that kept loopback URLs. It now
falls back to the item's cover reference, as the queue rows do, so
the cover is fetched once and shows.
Android Auto lists kept every cover starting with http. Collection
tracks loved from the player by older builds can hold a loopback URL
of the app's cover proxy, which a car cannot load and which named a
route of an earlier run. The browser now leaves those out like local
files.
A song loved from the player without a Library record stored the
item's artUri as its collection cover, and an album or artist opened
from the player recorded its cover in recents. Older builds put
loopback URLs there; a tag cover the store could not keep still shows
from a temporary file on that play. Both writers now store only
covers that outlast the run, through durableCoverReference.
Listening statistics rows from older builds hold loopback URLs and
temporary files that no longer load, so the statistics screen, Home
and Rewind showed broken covers. Rows are read through one
ListeningTrack.fromRow, which reads those as no artwork, so the
fallback shows until the song plays again.
A play whose cover is not known yet no longer erases the stored cover
of that day, and a write never stores a loopback or temporary cover.
Artist artwork and Rewind album covers dropped network:// references
because normalizeCoverReference rejects them; they now read through
normalizeStoredCoverReference, which keeps them without changing what
other stores accept.
A tag read without a cover dropped the song's stored tag cover. For a
Subsonic song played from the Library that cover is the server's, and a
failed cover request also reads without one (and is remembered for five
minutes), so the playing song and the lock screen lost their cover on a
passing failure. A stored tag cover now stays until the store trims it:
a picture removed from a network file's tags lingers a while, which is
better than losing a cover the server still has. The store's forget
goes with it.
A metadata event whose song left the queue during the read threw, and an
older event's read could still store its cover after a newer one's. Both
now stop before touching the store.
The cover read with a Subsonic song's tags is the server's own cover,
the one the song's network reference names. Keeping it again as a tag
cover made that copy win once the phone had played a desktop song, so a
cover changed on the desktop never reached the phone: the refresh
checks the network reference, and songs with a known tag cover skip it.
Subsonic songs with a network reference now keep only that reference,
which also stores each Link cover once and lets statistics keep a
reference the store can fetch again.
A tag read that finds no cover now drops the song's stored tag cover, so
a picture removed from the tags gives way to the folder cover as it did
before covers were stored. A metadata event updates the queue once: the
tag cover goes into the replaced entries instead of a separate update.
The Home resume item drops a loopback or temporary cover of an earlier
version, as a restored session does.
A network song with both a folder image and a cover in its tags showed
the folder image on every play once it was stored, unlike the Library.
The cover from the tags now wins once read: it is stored under the
song's cover reference, which a later play finds in the store's index,
so the item shows it from the first emission without flashing the
folder image. The folder image shows only while no tag cover is known,
and a late or changed folder cover no longer replaces a tag cover. The
session keeps neither file; statistics keep the reference of the cover
shown.
Covers a server reported changed are no longer fetched at once. A
desktop library job reported every song it touched, and each fetched
its cover, queued or not and stored or not. The store now marks the
cover stale and checks it on its next use, so only the playing song and
the next three fetch. The same mark drops the wait after a failed fetch,
so a Link reconnect retries the covers that failed while the desktop was
away instead of waiting out the store's minute.
A network:// artwork, as listening statistics keep for Home to play,
is the song's cover reference: the item shows its stored file and never
the network:// string, which the lock screen cannot load. Restored
sessions drop loopback and temporary covers of older versions, and the
temporary preview rule matches the preview folder, not a file name. A
tag cover the store could not keep shows on that play only.
The resolver and the remote's metadata subscriber each built the cover
reference of a desktop song. The cover store keys covers by that exact
string, so one helper builds it for both and the forms cannot drift.
An AutoMix transition showed a stored cover, but a cover not stored yet
was only fetched if an earlier load had fetched it ahead, so after a few
mixed songs in a row a network song could stay without one. The
transition now fetches the new song's cover and the next three, as a
gapless start does.
Cover widgets, precaching and palettes saw a network:// cover as a form
without an image. coverFilePath now answers it with the file the cover
store's index names, without file IO, so they show a stored cover as a
local file. A cover widget given a network cover the store does not
hold yet fetches it once through the store, within its fetch limit, and
builds again when it lands. Queue rows whose cover is not stored yet
show it that way.
Playing a folder resolved its cover image to a loopback URL before
playback began and passed it as the songs' artwork, a URL that named the
cover for this run only, even for Subsonic songs whose own cover
differs. The songs already carry the cover as networkArtworkSource,
which the player now shows from the cover store, so the screen passes
only that and starts playback without the extra request.
The desktop and phone remotes resolved each queued song's network cover
through the loopback proxy, a new URL per lookup, for every row of a
queue up to 500 songs long. The items now show the cover store's file,
the same on every update, and carry the reference as
extras['artworkRef'].
Only the playing song and the next three fetch their covers; other rows
fetch theirs once they show. A failed cover is tried again after a
reconnect, as before. When the desktop changes a song's file, its cover
is fetched again at once, and a cover the store replaced shows on the
items with it.
Each play resolved a song's network cover through the loopback proxy,
which hands out a new URL per call. The first item had no cover, every
play showed a different URL, the lock screen and Link Now Playing saw
the cover change, and listening statistics recorded a URL that was dead
after the run.
Items now show the file the cover store holds for the cover from their
first emission, the same file on every play, and carry the reference as
extras['artworkRef']. A cover not stored yet is fetched without holding
up the audio and shows on the song and its queue entries once it lands,
the covers of the next three songs are fetched ahead for skips and
gapless starts, and a cover the store replaced shows at once. A restored
session and the Home resume item read the store's index first.
The tag cover a network metadata read leaves in a temporary file is
copied into the store before the session keeps it. Statistics record
the cover reference, or the artwork only when it lasts. The store's
index is read at startup and trimmed once a launch.
Playback needs a stored network cover while it builds a MediaItem, so
indexedFile answers from the in-memory index without file IO. adopt
copies a cover that reached the device another way, such as the tag
cover a network metadata read leaves in a temporary file, into the store
under a reference derived from the song (songCoverReference), named by
its bytes like a fetched cover. refresh fetches a cover again at once
when its server reports a change, instead of waiting a day for the
recheck.
durableCoverReference keeps only cover strings that outlast the run:
loopback URLs and files in the system temporary directory or the known
temporary cover folders are dropped, so statistics never record them.
Clearing library covers marked rows whose cover_path started with Dart's
spelling of the folder. Scans store their own spelling: the canonical
/data/data path on Android 7 to 10, where /data/user/0 is a symlink, and
canonical backslash paths (possibly \\?\) on Windows. There no row was
marked, so local covers stayed broken until a forced rescan.
Rows are now matched by a library_covers path segment with either
separator; every file in that folder was just deleted, so each such row
is broken. The update also retries a busy writer before it begins, so a
running native scan no longer leaves the rows unmarked after the files
are gone.
A source without a modification time always published its preview to
v2_<path hash>_0.jpg. After an in-app cover edit (invalidate, then extract
again) the new cover landed on the same path, so ImageCache kept showing
the old decoded cover in the metadata screen, Library and player.
Untimed previews are now named v2_<path hash>_0_<content hash>.jpg from a
SHA-256 of the extracted bytes: an unchanged cover keeps its path across
memory misses, an edited one gets a new path, and the existing variant
cleanup removes the previous file. Publishing also no longer deletes the
target before the rename, which already replaces it atomically, so a
reader never finds the preview missing.
Clearing library covers in Settings deleted every file while Library rows
kept naming them. Network songs recover, since their scan reads a song
again when its cover file is gone, but local and document songs are
skipped by an unchanged timestamp, so their covers stayed broken until a
full rescan despite "Will re-extract on next scan".
The clear now also lowers the audio metadata scan version of local rows
whose cover was in that folder to the lyrics version. The incremental
snapshot then reports those files as changed once, so any next scan
extracts the covers again under the same names, which also brings back
the covers that playlists and sessions name. Lyrics filters are unchanged
meanwhile.
When a source had no modification time (some document providers), its
embedded cover preview went to a new systemTemp/download_cover_preview_*
folder and was deleted as soon as the 180-entry memory cache evicted it,
even while the player or the saved session still pointed at it.
Such previews now go to the existing embedded_cover_previews folder under
one durable name (v2_<path hash>_0.jpg). They are still extracted again on
each memory miss, since a disk copy cannot be validated without a
timestamp, but evicting the memory entry never deletes a file: only the
disk budget, a refresh that replaces the preview, invalidate and the
manual clear do.
The cover prune after a full scan treated a library_covers file as in use
only when library.cover_path named it. Playlists, favorites, the saved and
dismissed playback sessions, recent items, the download queue, listening
statistics and download history (including Link save offline copies) copy
those paths, so their covers broke after the next full scan.
The prune now also reads every such text column (read-only, in pages,
filtered with instr) and keeps the files they name, rebased onto today's
cover directory so file:// URIs and paths from an older iOS container
match. The names join the private native projection, so Rust still never
reads a live database and a failed read cancels the sweep.
A Subsonic cover kept by a reference also keeps its
subsonic_<hash>.image.current pointer, in Rust and in the Dart fallback;
before, the pointer was always deleted and the next scan fetched and
renamed the cover again.
A forced rescan wrote every thumbnail into a new library_covers/full_scan_*
folder, so all stored cover paths changed at once. It did that to bypass
reuse of possibly wrong cached thumbnails and stale decoded images.
With collision-free names, a forced rescan now writes the .regenerate
marker into library_covers itself: native scans extract every thumbnail
again under its existing name, and the decoded image cache is cleared once
the rescan is indexed. Playlists, sessions and statistics that copied a
cover path keep a valid file.
An unsatisfiable Range on SMB sets content-length 0 only for GET again,
so a HEAD answers as it did before the cover read moved to the shared
opener. A new test rejects 24 covers (404, audio, HTML) over one host's
six pooled connections, which times out if downloadCover stops
discarding a rejected response.
Background rechecks of stale covers and first-time fetches shared one
FIFO queue, so a scrolled grid could queue many rechecks ahead of the
playing song's cover. Waiting fetches a caller awaits now take the next
free turn before any queued recheck, and the turn is taken before the
store folder is created so queue order follows call order.
A recheck that finds changed bytes leaves the old file dated ahead of
the clock; warmUp and trim now rank a file dated more than a day ahead
as the oldest, so a restart picks the new file and a trim drops the
stuck one first. The constructor asserts a positive fetch cap, and the
cap test waits with a bounded poll instead of one event queue pump.
Playback and display will ask the store for whole queues and grids.
- At most four covers are fetched at once (maxFetches); the rest wait
their turn in order, so a burst does not queue past the HTTP pool
and time out into a retry backoff.
- A cover the server does not have (NetworkMediaUnavailable) or whose
bytes are not an image waits an hour before the next fetch instead of
a minute, so a desktop's songs without art are not asked for every
minute while they are shown. Transfer failures keep the one-minute
delay.
- A stored cover dated more than a day ahead of the clock is checked
again, as one more than a day old is.
- trim checks again that no fetch has taken up a name after reading its
details, before deleting it.
Review of the direct cover read found two regressions.
- downloadCover parsed Content-Type with ContentType.parse, which throws
on a malformed value such as an unterminated quote. The response was
then never read or discarded, so it held one of the server's six
pooled connections for good, the same pool audio playback uses.
The mime type is now read without throwing, and any response whose
body was not read is discarded, in downloadCover and in _serve. The
opener also discards when its own header checks throw (the Subsonic
contentType getter had the same hold before this unit).
- An SMB range that cannot be satisfied answered with an empty chunked
body instead of the old Content-Length: 0. The 416 answer sets the
length again.
A cover answer that will not change soon (404 or 410, a Subsonic error
document with either status, audio or video, too large, empty) now
throws NetworkMediaUnavailable, an HttpException, so callers can wait
longer before asking again. Declared audio and video types are refused
before any bytes are read. A pinned TLS server is covered by a direct
read test too.
Network covers reach the app as a loopback URL that changes on every
resolve, so the cover cache, the image cache, palettes and the media
session miss each time, and the URL breaks once the route is evicted
or the process ends. CoverStore turns a cover reference into a durable
local file instead.
- A network:// cover is fetched once with downloadCover() into
<support>/covers/<reference key>_<content key>.image. The same
reference with the same bytes keeps one path across calls and runs;
changed bytes give a new path, so caches keyed by path show the new
image.
- cachedFile() answers synchronously from an index that warmUp() reads
from disk, so the first frame can show a stored cover. Existing file
paths and file:// URIs pass through; https stays with
CoverCacheManager.
- Concurrent requests for a reference share one fetch, a failure waits
a minute before the next attempt (an unreachable desktop is not
asked once per queue row), and a cover older than a day is answered
at once and checked again in the background. New bytes are reported
on changes.
- Fetched bytes must start like a JPEG, PNG, GIF, WebP, BMP, HEIF or
AVIF image and stay within 16 MiB; they are staged and renamed, so a
failure leaves no file.
- trim() removes superseded and abandoned staging files, then the
covers checked longest ago beyond 2000 files or 200 MiB. Any cover
can be fetched again from its reference.
Nothing uses the store yet; playback and display move to it next.
A network cover (Subsonic or Link desktop getCoverArt, a WebDAV, HTTP
or SMB folder image) could only be read through resolve(), which hands
out a new loopback route per call. That URL defeats every URL-keyed
cache and dies with the Dart process, so it cannot back a durable cover
file.
downloadCover() saves the cover at a network:// source to a file over
the connection's own pinned client, with the same source validation,
local network access and out-of-reach check as resolve(). It rejects
non-200 answers, text documents (Subsonic JSON or XML errors among
them), Subsonic song paths, empty bodies and anything over 16 MiB, and
strips the credential-bearing request URI from transport errors.
Virtual sources answer with their local file; a URL from them streams
a song on its way and is refused.
The proxy and the direct read now share one opener for a connection
and path, so _serve keeps its exact statuses, headers, HEAD and range
handling without a second copy of the SMB and HTTP code.
When a phone committed a new song list, the desktop deleted every stored
cover the new list did not name right away, before the rescan of the
phone's Library source had moved the rows off them. Songs whose cover
changed (a phone rescan changes every cover id) showed placeholders until
the rescan finished, and longer when the rescan waited behind another
scan.
A commit's removal now also keeps covers the phone source's Library rows
name (LinkPhoneLibrary.coverPaths, read from the library table) and skips
deleting anything when those rows cannot be read. It is queued right
behind the last page, so it runs after the commit reply and before
anything the phone sends next. A cover kept only for rows goes at a later
commit, or at the next GET phone/catalog (the start of a sync) when it is
older than the committed list; covers sent since that commit wait for the
commit they were sent for, so a sync that stopped halfway does not upload
them again. GET phone/covers waits for the removals queued before it, so
the phone never skips a cover that is deleted right after it was listed.
The other cover readers look up covers of committed songs, which no
removal takes away, so they answer at once and never wait behind a web
cover download. Web cover fetches stay a separate queued step. The 1 GiB
store limit and the cover ids are unchanged.
The metadata cover prewarm now also runs for local paths and file URIs,
so a stale path reported an image error that the app logs as an uncaught
error and stores as the crash snapshot. Swallow local prewarm failures
as the backdrop prewarm already does; http failures still report.
Both prewarm helpers now build the provider once and return when the
form has no image, so a stateful network:// lookup cannot disagree
between two calls. Document that the network:// hook must read only an
in-memory index, since it runs during build.
Screens repeated the http-or-file check and raw Image.file calls for
cover strings. The Link transfer rows accepted only http(s) and plain
paths, so a song cover stored as a file:// URI showed the placeholder.
Track Metadata, the transfer rows and the queue artwork now use
isHttpCoverUrl, coverFilePath and coverImageSource. The album, local
album and playlist header backgrounds and the playlist grid cover use
LocalOrNetworkCoverImage with the same decode, filter, gapless and
placeholder settings they had, so they draw the same pixels. The queue
grid prewarm builds its provider with cachedCoverImageProvider.
Cover strings reach the UI as absolute paths, file:// URIs (MediaItem
artUri values saved into listening statistics), http(s) URLs and
content:// URIs, and each primitive parsed them itself.
LocalOrNetworkCoverImage sent every non-http string to File(url), so
file:// covers failed silently; precacheCoverImage skipped local files;
CoverPalette keyed a file:// URI and its path separately and never
decoded the URI.
coverFilePath, coverImageSource and coverImageProvider in
cached_cover_image.dart now map a stored string to its file, its decode
source and its image, keyed like the widgets' own decode. PlayerArtwork,
LocalOrNetworkCoverImage, both precache helpers, CoverPalette,
PlayerArtworkTheme and LocalLibraryArtworkBuilder go through them, so
the Mornye palette callers pass artUri as it is. network:// covers have
one hook in coverFilePath for the cover store. content:// and other
forms still show the placeholder.
While a paired computer plays, the iPhone publishes a NowPlaying
RemoteMediaSession through a new LinkNowPlaying ExtensionKit extension
instead of starting local audio for a Lock Screen card. The app sends
the track, position and volume over a method channel; the extension
reads the computer's state and sends its commands directly over the
pinned Link connection, so the card keeps working while the app
sleeps.
- Pairing credentials go to a Keychain item shared through the app
group. An install without the app group, and so without that
Keychain, carries them in the session attributes instead.
- A desktop catalog song's cover comes from the computer's
getCoverArt by song id. The app's own cover is a loopback proxy URL
that the extension cannot use.
- Errors returned to the system carry only their domain and code: a
URL error's details cannot cross XPC and aborted the extension.
Failures are logged to the device log without URLs or keys.
- CI and release builds move to Xcode 27 and check that the extension
is embedded.
On a test device the card appears, but its controls and cover do not
reach the computer yet; that is still being investigated.
Shrinking Material's empty "Playing on" row to one line of the label
(24dp) left it too short on Android, while the iPhone still showed a
wide empty band: the safe area stacked the 34pt home indicator inset
under the row. The row is 36dp again on every platform. On an iPhone,
Material's portrait player now lets it reach into the home indicator
inset, keeping only the bottom 12pt below it, so the label still ends
clear of the indicator and the bottom gap drops from 58pt to 48pt.
The Material Home's sections sat in an AnimatedSize with its default
center alignment, so when a section left (Continue listening once the
player hides) or arrived, every section under it sank and rose again
while the space resized. They now stay at the top and only the space
below them opens or closes, as the intro above already does.
Material's portrait player keeps an empty row under its buttons for the
"Playing on" label, so the controls stay put when a computer takes over
playback. It was 36dp, a full touch target, which on an iPhone sits on
top of the home indicator inset and leaves a wide empty band that
shrinks the cover. The row is now one line of the label plus 4dp (24dp
at the default text size, growing with larger text).
Rotating the Mornye player from its player page fades the portrait
cover out for 380 ms while the landscape cover borrows the same video.
When the outgoing cover was disposed it paused that shared video, so
the landscape cover froze on one frame. Opening in landscape or
rotating from the lyrics page worked, which made it look intermittent.
Banners now track who borrows a prepared video: it plays while any of
them is visible and pauses only when the last one leaves.
On wide screens Sort and the view button sat on the first section
header, right next to its Show all, so the three read as one control.
They now end the filter chip row (alone, aligned to the end, when the
provider has no filters) and show once there are results, leaving each
header to end with its own Show all. Phone results keep Sort on the
first section.
Audio over Bluetooth reaches the listener late, so synced lyrics ran
ahead of what was heard (#753). Lyrics settings gain Lyrics timing: a
slider from 2 s earlier to 2 s later in 0.1 s steps, saved on release,
with a reset.
The offset moves every line and word of the player's lyrics and the
desktop mini player's, so line focus, word sweeps and countdowns follow
it together. Tapping a line still seeks to where it is sung, and a
long-pressed line opens sharing with its own time.
The actions on a linked computer's songs looked unlike the same actions on
the phone's files. The song menu now lists them in the places and words of
the local actions instead of eight "... on <computer>" items, and only the
dialogs name the computer. A started action shows the batch progress
dialog local batches use, with Cancel stopping after the current song,
then the local result snackbar, instead of a "Desktop work" sheet. Editing
tags reuses the metadata editor without its cover and autofill parts,
which work on local files only.
"Desktop work" in Devices becomes "File changes": one grouped list, newest
first, with progress and a stop button on running changes, failed songs
under finished ones, an empty state, and no rows for the internal read and
preview steps.
Albums, singles and playlists, online and in the Library, end with
"Suggested songs": up to ten songs like the ones above that the collection
does not hold yet, each with a preview, an add button and a click or tap
that downloads it. On a user playlist the add button adds the song there
and it leaves the suggestions; elsewhere it opens the playlist picker.
Phones list the songs as rows, desktop in the page's song table.
Suggestions come from a new optional extension method, getRelatedTracks,
which extensions declare with the relatedTracks capability: it takes up to
three of the collection's songs and returns songs in the shape of search
results. The extension most seeds came from is preferred so it can use
their IDs. Without such an extension, the first metadata provider is
searched by the collection's artists. A refresh button starts from other
songs, and loaded suggestions stay for ten minutes.
Reduce the track thickness to 4 and handle length to 20 so volume stays secondary to the seek bar.
Validation: 7 player volume tests passed, scoped analysis and pinned formatting passed, and git diff --check is clean.
Add paired-phone actions for deletion, metadata editing and re-enrichment, conversion, ReplayGain, and cover or lyrics export. Run serial desktop jobs with progress, cancellation between songs, retry deduplication, and status recovery after reconnecting.
Review re-enrichment before applying it, resolve catalog IDs against current records, and refresh metadata and artwork on both devices. Support batches of up to 100 songs from one computer.
Validation: 163 Flutter tests passed, scoped analysis and pinned formatting passed, and git diff --check is clean.