Authorize Last.fm accounts in the system browser and store sessions in OS secure storage. Add desktop Playback settings for scrobbling and Now Playing, including localized status and recovery controls.
Observe the local full player, measure actual listening time across pause and seek, distinguish repeats and transitions, and persist qualified listens before submitting account-scoped batches. Keep previews and remote Link sessions outside submission.
Validation: 281 Flutter tests passed, analyzer and pinned formatter clean, workflow lint passed, macOS debug build succeeded, and the signed Last.fm API handshake was verified. Build credentials are supplied locally or through Actions secrets.
Keep the primary word clock alive through the existing 540 ms lift in both themes. Only Mornye needs the glow tail; translated and romanized supplements still stop after their color sweep.
A short final word regression fails on the old Material clock at 200 ms and passes with this fix. All 33 focused clock, repaint, scroll continuity and translated-word tests pass, including reduced motion and settled-clock cases.
Decode square-cropped extension icons from their intrinsic shorter edge, preserving proportions and retaining enough pixels for the crop without decoder upscaling. Keep source loading, fallbacks and layout unchanged, and key decoded images by source and physical extent.
Real file and HTTP bitmap tests cover wide, tall, square and small sources at all icon sizes and live density changes. The Store regression catches the old 100x25 decode where a 400x100 bitmap is required. All 68 scoped tests pass with clean lib/test analysis.
Use the short screen side for shared player artwork so rotation reuses the portrait decode. A DPR 3 400x900 test requests 1200 pixels in both orientations instead of 2700 in landscape.
Decode extension icons at their displayed width and density while retaining the source aspect ratio and existing fallback layout.
Avoid the scheduler idle-task retry loop during animations. Wait on existing frames before preloading Search, and retain the last visible MediaQuery size for hidden tabs while continuing accessibility updates.
Ten hidden resize updates now trigger zero size-dependent builds instead of ten. Host regressions verify retained scroll, focus, tickers, disposal and idle completion.
Use the measured first row for uniform desktop tables so long jumps avoid building every skipped row. Keep custom actions, album rows and large text on variable layout.
A jump across 5,000 songs builds fewer than 40 rows instead of about 4,980. Pixel comparisons match both styles at 100% and 200% text scaling.
Keep normalized collection match keys and filtered suggestions across page rebuilds. Snapshot candidate identities and history membership so edits and in-place list changes invalidate derived results, and sort playlist seeds once per collection snapshot.
Host widget checks reduce match-field reads from 3000 to zero over five rebuilds of a 200-track collection. All 170 scoped tests pass, with clean lib/test analysis and formatting.
DesktopScrollArrows kept hover in setState, so each pointer enter and
exit called the builder again and rebuilt the shelf's ListView and every
visible card (Home shelves, artist discography, search shelves). Moving
the pointer down Home crossed each shelf twice.
Hover now lives in a ValueNotifier and only the arrow layer listens. When
not hovered it is a zero-size child, which paints and hits nothing, as
the missing child did before.
Measured in test/desktop_scroll_arrows_test.dart with six visible cards
that keep their own hover state: hovering one card rebuilt all six
before, and rebuilds only the hovered card now; the shelf builder runs
once across enter, move and exit.
Coalesce log bursts to one frame and cancel pending callbacks on disposal. A 500-entry log initially mounts only visible rows; large metadata reviews avoid shrink-wrapping every row.
Carry unfinished row displacement into the next stagger and active-row transition. Regressions reproduce a 33.60 px jump on the old code. Keep the intended upward animation in both Material and Mornye.
Offer an explicit keyring-free storage choice in setup and extension settings. Keep the same extension key locally with owner-only permissions and explain the credential exposure.
Preserve existing encrypted data and serialize storage changes with startup. Verify keyring persistence before removing the local key when returning to secure storage.
Validation: 57 Flutter tests passed, scoped analyzer clean, formatter and git diff checks passed.
Add FLAC auto-conversion with maximum bit depth and sample rate in foreground and Android background downloads. Preserve lower source rates, artwork, metadata and output quality.
Keep 48 kHz available for mixed-source batch conversion and add 160 kbps to manual, batch and automatic conversion.
Validation: 122 Flutter tests and 26 Android JVM tests passed. Analysis of lib and test passed.
On Android, the audio info sheet showed the default low-latency PCM rate,
bit depth and buffer as the output of a Bluetooth route, and computed
resampling from them. Android does not report the negotiated A2DP or LE
Audio codec format, so for Bluetooth, LE and hearing aid routes the sheet
now says so, labels the PCM values as system defaults, and shows no
resampling. The sheet also reads the route again when the app returns to
the foreground, so a route changed in Settings shows at once.
The Material full-screen cover (the default) faded into its blurred
surface through one ShaderMask over the whole cover box. A shader mask
layer renders its children offscreen at the size of their paint bounds,
so every raster of the frame, 30 times a second while playing, drew the
whole cover (about 1.4 MP on a 1080 x 2340 phone) into an offscreen
target and composited it back, although the gradient is pure white over
the top 72% of the box.
The Hero now holds two copies of the same artwork (one provider, one
decode). The rows above the fade are clipped and drawn directly; the
band from one device pixel above the first faded row down goes through
a mask layer whose rect is that band, with the same gradient laid over
the whole box and the copy clipped to the band. Both copies stay inside
the Hero and the lyrics AnimatedOpacity, so the opening flight and the
lyrics fade keep their look and timing.
Measured in the layer tree at 1080 x 2340, 2.625x: the masked rect drops
from 411 x 499 dp to 411 x 140 dp (28.1% of the box, 72% less offscreen
area). Captures against the old tree at four sizes and dprs, three covers
(opaque, noise, translucent noise), through opening, drag, settle,
lyrics fade and both closes stay within one level per channel, except
two levels during the 300 ms lyrics fade, where the opacity now reaches
the upper rows directly instead of through an 8-bit offscreen copy.
Material phone and tablet collection headers (album, playlist, local and
downloaded album, folder, extension and mix pages) blurred a 1.5 MP cover
with sigma 32 on every composited frame: every scroll frame while the
header collapses and 30 frames a second while music plays, since the
mini player wave keeps drawing. The blur input never changes between
those frames; the pinned flexible space only moves it.
The header now wraps its background in SettledBlur: the first frame and
the unchanged one after it blur live as before, then a quarter
resolution image (about 0.4 MB at 1080 x 2340) is drawn until the cover,
theme, size or pixel ratio changes. Scrims, gradient and content are
unchanged.
Host test on a 411 x 891 dp phone with a ticking mini player: 91 frames
including 30 collapse frames composite the live blur 2 times instead of
91. Settled page against the live blur: mean channel difference 0.09
(light) and 0.07 (dark), largest 7 out of 255.
Impeller has no raster cache, so an ImageFiltered blur runs its offscreen
pass on every composited frame even when nothing under it changed. The
new widget blurs live on the frame its child changes, then rasterizes the
blurred child once at a quarter of the physical resolution (owner
approved for wide blurs) and draws that image until an input changes.
A frame settles it only when the live layer was retained unchanged, so a
fade or opacity animation inside a nested layer, which never reports a
repaint upward, keeps it live until it ends. A new child widget, sigma,
resolution, device pixel ratio, size or any repaint below drops the image.
Textures and platform views stay live. Images are disposed on change,
detach and dispose. It adds no frames on a still screen beyond the one
that swaps in the image.
Host tests: one image per settled input across 60 frames of movement and
a ticking sibling; each input change re-settles; a 500 ms fade settles
only after it ends; mean channel difference to the live blur 0.37 (1x)
and 0.26 (3x) out of 255, against 9.8 for a quarter smaller sigma.
LibraryDirectoryView rebuilt a TrackTableRow, a quality label and the id
map for every song of the open folder on each build, and an id set for
pruning the selection, so a click in a flat folder with thousands of
files walked all of them.
The view now keeps the rows and the id map while the folder's song list
and the quality label mode stay the same, and the id set while the list
stays the same. The artwork widget reads its colors from the theme, so
a theme change still repaints it.
Measured with a 3,000-song folder (widget test): a selection click
re-created 3,000 rows before and none now; a quality label change or a
reload still rebuilds them all.
Before the menu items were kept between builds, every rebuild sent a
new menu, so a hot reload that edited the menu code showed the edit
right away. The kept items would otherwise stay until something they
show changed. Hot reload now drops them, as it did before.
The MaterialApp builder read MediaQuery.of to copy displayFeatures and
navigationMode, a full MediaQuery dependency, so every resize frame
(60 to 120 Hz during a live resize, and every frame of the mini player
window animation) reran it and rebuilt the drop target, playback
feedback, scaffold messenger and the desktop shortcut layer. On macOS
that rebuilt the menu bar too.
The copy now lives in a small widget that reads MediaQuery in its own
build and wraps the glass preparation and the UI scaler as before, so
those two rebuild on the same changes as before while the app content
passes through unchanged.
The shortcut layer also read the window width with MediaQuery.sizeOf
from its commands. Called outside build, that still registers a
dependency, so after the first Escape or Back every resize rebuilt the
layer. It now reads the nearest MediaQuery without depending on it,
the same value at call time.
Measured in test/desktop_menu_bar_rebuild_test.dart (host): 10 resize
frames plus 10 mini player frames sent 20 menus before and 0 now, and
the shortcut layer keeps its Shortcuts widget across them on macOS,
Windows and Linux.
PlatformMenuItem has no ==, so every rebuild of the menu bar built
about 40 new items and PlatformMenuBar re-serialized all of them,
re-registered every callback and sent Menu.setMenus, which makes the
macOS plugin rebuild NSApp.mainMenu on the platform thread. That
happened on every rebuild of the app builder and on every frame of a
theme animation (the menu bar depends on Theme through isMornye).
The menu bar now keeps its item list and rebuilds it only when
something the items show changes: the app and Material localizations,
the Mornye style, whether the player UI and the Store show, and the
window mode. The callbacks read focus and the player at call time, so
reusing them runs the same commands.
desktopShortcutBindings also returns one unmodifiable map per platform,
so Shortcuts no longer drops its index and notifies on every rebuild
(SingleActivator and the intents have no ==).
Measured in test/desktop_menu_bar_rebuild_test.dart (host, 100 ms
test frames): a light to dark theme change sent 4 menus before and at
most 1 now (PlatformMenuBar's first update after mounting), the theme
change back 0; a locale change sent 3 before and 1 now.
A Loved or playlist entry of a network song will keep its cover as a
network:// reference, which only this device's cover store reads. Such
a track can reach the download queue (a tap on an entry without a
download, Download all), where the queue tiles load the cover over http,
the request payload hands it to the backend as a cover URL to fetch and
embed, and post-processing hooks receive it.
The queue now stores such a track without that cover, so the backend
falls back to the provider's cover. Other tracks are queued unchanged
(the same instance). The quality picker loads its cover with
Image.network, so it now gets only an http cover; a local path showed
the same placeholder there before.
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.
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.
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.
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.
Advance displayed timestamps at media-second boundaries between engine reports, respecting playback speed, pause, buffering, scrubbing and visibility. Retain and persist seeks on restored sessions before loading the source, including a zero-second target.
Validation: 247 Flutter tests, targeted analyzer, formatter checks and git diff --check.
Lazy lists build rows again as they scroll back into view, and the
first ten replayed the stagger each time while later ones never had it:
on a 14-song album, songs 12 and 13 sprang in on every scroll and the
last did not. Rows built while the list is scrolled now appear at once,
so only the reveal at the top animates.
Material's portrait player added the "Playing on" row under its buttons
only while a computer played, so the controls jumped up when one took
over. The row is now kept while empty, 36dp tall like the one-line label
it holds, without the extra gap below. Mornye's larger cover and phones
under 640dp tall, whose lyrics need the room, keep the old layout.
The phone already showed and drove the computer once the computer
started playing, but the computer kept its own paused player while a
phone played, and pressing play there played on both.
The computer now follows a connected phone that starts playing while
it does not: its player bar and Now Playing show the phone's song,
position and queue, its controls drive the phone, and the bar names the
phone. Songs picked or queued on the computer play there and end
following.
Only one device plays at a time. The computer starting pauses the
phones that play; the phone starting pauses the computer. A device
paused this way follows the one that took over (the phone only with its
follow option on).
The phone's mirror of the computer moves into a shared
LinkMirroredPlayback, which the computer's LinkPhonePlayback extends.
The Material player's lyrics toggle and audio output button now match
the shuffle and repeat group between them: filled 56 by 48dp expressive
pills on surfaceContainerHigh, the lyrics toggle on primaryContainer
while open. ExpressiveIconButton takes a width for pills, and the audio
output button can fill one, wrapping the native route picker on iOS.