Commit Graph
3928 Commits
Author SHA1 Message Date
zarzet 28ff305699 fix(home): show a network cover not stored yet in Continue listening
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.
2026-10-30 15:45:15 +07:00
zarzet e913f09d4a fix(player): keep stored loopback covers out of the Android Auto browser
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.
2026-10-30 15:45:15 +07:00
zarzet e33d2d7089 fix(covers): keep temporary player covers out of Loved and recents
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.
2026-10-30 15:38:42 +07:00
zarzet cd66e168f9 fix(covers): read stored statistics covers as durable references
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.
2026-10-30 15:36:00 +07:00
zarzet aab8e73b48 fix(covers): keep a stored tag cover when a read has none
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.
2026-10-30 15:19:26 +07:00
zarzet cc3613ccff fix(covers): keep desktop covers fresh and drop removed tag covers
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.
2026-10-30 15:07:30 +07:00
zarzet aad187c4d0 fix(covers): show a known tag cover and fetch changed covers on use
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.
2026-10-30 14:44:25 +07:00
zarzet 7bf3d5ee6b refactor(link): share the desktop cover reference
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.
2026-10-30 14:44:25 +07:00
zarzet c650d705af fix(player): fetch network covers when an AutoMix starts a song
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.
2026-10-30 14:44:25 +07:00
zarzet 9b6854f3c4 feat(covers): show stored network covers in cover widgets
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.
2026-10-30 14:44:25 +07:00
zarzet 197cfc0d19 fix(network): play folder covers by reference
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.
2026-10-30 14:44:25 +07:00
zarzet d36298c1af fix(link): show stored covers on mirrored playback
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.
2026-10-30 14:44:25 +07:00
zarzet c5502d4339 fix(player): show stored network covers on every play
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.
2026-10-30 14:44:25 +07:00
zarzet 079364656b feat(covers): look up, adopt and refresh stored covers
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.
2026-10-30 14:44:25 +07:00
zarzet fcf5c60ec6 test(covers): cross-check the document slot and steady the marker test
The document scan slot test only compared the stem with the function that
computes it. A new test writes a thumbnail through the Rust scan's
cache_cover and expects library_cover_slot to find that file for the same
key, then checks that the newer of two current siblings wins.

The forced-scan test compared marker mtimes 20 ms apart, which can flake
on filesystems that store whole seconds; it now checks that each forced
scan rewrites the marker's contents. The padded ID3 cover test reuses the
shared backend and ID3 helpers.
2026-10-30 14:21:07 +07:00
zarzet 991f2c539e fix(library): match cleared library covers by folder name
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.
2026-10-30 14:19:48 +07:00
zarzet 757bb14e65 fix(covers): name untimed embedded previews by their content
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.
2026-10-30 14:17:27 +07:00
zarzet 97bb845df5 fix(library): rescan local songs after clearing library covers
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.
2026-10-30 14:15:10 +07:00
zarzet 4855b1a73f fix(covers): keep embedded previews of untimed sources on disk
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.
2026-10-30 14:15:10 +07:00
zarzet 4bb348f843 fix(library): keep cover files that other stores still name
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.
2026-10-30 14:15:10 +07:00
zarzet 0b53ec64b8 fix(library): keep thumbnail paths across forced rescans
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.
2026-10-30 14:15:10 +07:00
zarzet 338e9ba83c fix(covers): key library thumbnails by 128-bit SHA-256
Scan thumbnails were named by a 32-bit djb2 hash of "path|size|mtime" (or
the document key) and an existing file was reused without checking its
source, so two songs whose keys collided showed one cover. The Android
document scan had its own copy of the same hash.

Thumbnails are now named cover_<first 128 bits of SHA-256 of the key>, in
Rust for every scan and through library_cover_slot for the Kotlin document
scan, so reuse by name is safe. Rows that name older files keep working;
those files are not looked up again and are pruned once unreferenced.

A forced rescan can touch a .regenerate marker in the cover folder:
thumbnails older than it are extracted again under the same name instead
of being reused, and the newer of a .jpg and .png sibling wins.
2026-10-30 14:15:10 +07:00
zarzet e30e213ed3 fix(link): refresh playback and details after desktop file changes 2026-10-30 13:12:05 +07:00
zarzet 3960f1383f fix(network): keep SMB HEAD 416 framing and test rejected covers
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.
2026-10-30 11:29:25 +07:00
zarzet 30ab1c4af9 fix(covers): fetch awaited covers before background rechecks
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.
2026-10-30 11:29:25 +07:00
zarzet 8b9f687c57 feat(covers): cap cover fetches and back off longer from missing covers
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.
2026-10-30 11:29:25 +07:00
zarzet b5e558bfdf fix(network): release cover connections and keep the proxy's 416 framing
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.
2026-10-30 11:29:25 +07:00
zarzet f499e0b66c feat(covers): add a durable store for network covers
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.
2026-10-30 11:29:25 +07:00
zarzet cd25a407a3 refactor(network): read network covers directly over the connection
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.
2026-10-30 11:29:25 +07:00
zarzet 05a5d94834 fix(link): keep phone covers until the Library stops showing them
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.
2026-10-30 07:42:07 +07:00
zarzet 1e620c750a fix(link): key extracted cover pictures by their audio file
The ETag and the resized copy of an embedded picture came from its
extracted copy in the temp cache: path, mtime and length. Once the cache
trimmed that copy (4000 files) or the OS purged the temp folder, the
picture was extracted again with a new mtime, so the same image got a new
ETag (clients downloaded it again) and a second resized copy that
stayed in the cache beside the first.

The stamp of an embedded picture is now the audio file's path, mtime and
length, which already named the extracted copy. Every id that resolves
to one image (album, artist or song id) still shares one ETag and one
resized copy. Cover files keep their stamp and their ETags.
2026-10-30 07:42:07 +07:00
zarzet 46b4f4fbc5 fix(link): fall back when a listed cover file is gone
getCoverArt resolved an id to a single source: a song's own cover file,
else its album's, else embedded pictures. When the listed file was gone
(a pruned or moved Library thumbnail, a stale export) it answered 404,
although the album's cover file or the picture embedded in the song
could still serve it. The phone then showed a placeholder.

The catalog now returns every fallback in order (the song's own file,
its album's file, then the songs that can embed a picture) and the
server serves the first one on disk. 404 remains for ids with none.
Responses, content types and ETags for covers that resolve today are
unchanged.
2026-10-30 07:42:07 +07:00
zarzet 800248c0f9 fix(covers): keep a missing local cover out of the error handler
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.
2026-10-30 04:17:07 +07:00
zarzet ac93828a02 refactor(covers): show screen covers through the shared helper
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.
2026-10-30 03:53:38 +07:00
zarzet 69c701ad6c refactor(covers): read every stored cover form through one helper
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.
2026-10-30 03:53:32 +07:00
zarzet b434af048f feat(link): show computer playback on the iOS 27 Lock Screen
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.
2026-10-30 03:03:49 +07:00
zarzet 808c58491b fix(player): share the iPhone home indicator inset with Playing on
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.
2026-10-30 03:03:41 +07:00
zarzet 95ecb0427c fix(home): keep sections in place while one comes or goes
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.
2026-10-30 02:02:09 +07:00
zarzet a73f63772d chore(deps): update Flutter, native and Rust dependencies 2026-10-30 01:29:33 +07:00
zarzet de7493375a fix(player): shrink Material's empty Playing on row
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).
2026-10-30 01:02:54 +07:00
zarzet da61f3afda fix(player): keep the motion cover playing after rotating
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.
2026-10-30 00:33:07 +07:00
zarzet cee3d89446 fix(search): keep Sort beside the filters on wide results
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.
2026-10-30 00:33:07 +07:00
zarzet 274cfb765c fix(library): read Opus tags with large artwork 2026-10-30 00:32:53 +07:00
zarzet c833a24212 fix(downloads): handle unsupported exclusive renames 2026-10-30 00:32:07 +07:00
zarzet 01523d29f5 fix(ffmpeg): load large metadata from temporary files 2026-10-30 00:13:27 +07:00
zarzet bf80fe0251 chore(desktop): remove beta release label 2026-10-30 00:06:52 +07:00
zarzet 2000cabd62 fix(android): resolve audio service lint warnings 2026-10-30 00:00:09 +07:00
zarzet 152bb36d2e feat(lyrics): let synced lyrics run later or earlier than playback
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.
2026-10-29 23:58:23 +07:00
zarzet 22e3536dd5 fix(android): guard media artwork against recycled bitmaps 2026-10-29 23:46:29 +07:00
zarzet d4cba0aad3 fix(player): hide internal playback UI in external mode 2026-10-29 23:28:33 +07:00