mirror of
https://github.com/zarzet/SpotiFLAC-Mobile.git
synced 2026-11-21 20:00:49 +01:00
perf(link): reuse desktop player window state
Map runtime queue entries lazily with a 400-entry LRU and retain the last catalog-resolved player window. Overlay enriched current metadata through a lazy singleton view keyed by base, item and index. Compare retained scalar and display-tag inputs directly so mutable extras invalidate without allocating metadata snapshots on cache hits. A 20000-song fixture maps only its 200 requested entries, including a rich current item. Sixty unchanged ticks add no mappings, metadata copies or catalog lookups; full traversal retains at most 400 base memo entries. All 109 scoped tests pass, including the existing playback-details regressions, and eager-overlay and missing-invalidation negative controls fail as expected.
This commit is contained in:
1 parent
dac6591c15
commit
269a4d97fa
4 files changed
+905
-20
No files matched your search
@@ -205,6 +205,7 @@ class LinkDesktopOps {
|
||||
final int Function() _nowMs;
|
||||
final LinkPlaybackDetails _playbackDetails;
|
||||
final _random = math.Random();
|
||||
final _playerStateCache = LinkPlayerStateCache();
|
||||
|
||||
/// The queue the last `handoff/play` started, which `handoff/append`
|
||||
/// extends.
|
||||
@@ -261,6 +262,7 @@ class LinkDesktopOps {
|
||||
index: _index(),
|
||||
autoplay: _autoplay?.call(),
|
||||
autoMix: _autoMix?.call(),
|
||||
cache: _playerStateCache,
|
||||
);
|
||||
|
||||
/// Notes the desktop's own queue, so `getPlayQueue` knows when it last
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import 'dart:async';
|
||||
import 'dart:collection';
|
||||
|
||||
import 'package:audio_service/audio_service.dart';
|
||||
import 'package:flutter/foundation.dart';
|
||||
@@ -52,6 +53,101 @@ class LinkPlayerItem {
|
||||
final Map<String, dynamic> audioMetadata;
|
||||
}
|
||||
|
||||
class _MappedPlayerItem {
|
||||
_MappedPlayerItem(this.source)
|
||||
: _extras = [for (final key in _extraKeys) source.extras?[key]],
|
||||
_displayMetadata = switch (source.extras?['displayMetadata']) {
|
||||
final Map<Object?, Object?> value => Map<Object?, Object?>.of(value),
|
||||
_ => const {},
|
||||
},
|
||||
item = LinkPlayerItem.fromMediaItem(source);
|
||||
|
||||
static const _extraKeys = [
|
||||
'source',
|
||||
'resolvedSource',
|
||||
'bit_depth',
|
||||
'sample_rate',
|
||||
'bitrate',
|
||||
'format',
|
||||
'explicit',
|
||||
];
|
||||
|
||||
final MediaItem source;
|
||||
final List<Object?> _extras;
|
||||
final Map<Object?, Object?> _displayMetadata;
|
||||
final LinkPlayerItem item;
|
||||
|
||||
bool matches(MediaItem value) {
|
||||
if (!identical(source, value)) return false;
|
||||
final extras = value.extras;
|
||||
for (var i = 0; i < _extraKeys.length; i++) {
|
||||
if (_extras[i] != extras?[_extraKeys[i]]) return false;
|
||||
}
|
||||
final displayMetadata = extras?['displayMetadata'];
|
||||
return displayMetadata is Map<Object?, Object?>
|
||||
? mapEquals(_displayMetadata, displayMetadata)
|
||||
: _displayMetadata.isEmpty;
|
||||
}
|
||||
}
|
||||
|
||||
class _MappedPlayerQueue extends ListBase<LinkPlayerItem> {
|
||||
_MappedPlayerQueue(this._source);
|
||||
|
||||
static const _maxItems = LinkPlayerState.maxQueue * 2;
|
||||
final List<MediaItem> _source;
|
||||
final _items = <int, _MappedPlayerItem>{};
|
||||
|
||||
@override
|
||||
int get length => _source.length;
|
||||
|
||||
@override
|
||||
set length(int value) => throw UnsupportedError('Immutable player queue');
|
||||
|
||||
@override
|
||||
LinkPlayerItem operator [](int index) {
|
||||
final source = _source[index];
|
||||
final cached = _items.remove(index);
|
||||
if (cached != null && cached.matches(source)) {
|
||||
_items[index] = cached;
|
||||
return cached.item;
|
||||
}
|
||||
final mapped = _MappedPlayerItem(source);
|
||||
if (_items.length >= _maxItems) _items.remove(_items.keys.first);
|
||||
_items[index] = mapped;
|
||||
return mapped.item;
|
||||
}
|
||||
|
||||
@override
|
||||
void operator []=(int index, LinkPlayerItem value) =>
|
||||
throw UnsupportedError('Immutable player queue');
|
||||
}
|
||||
|
||||
class _CurrentPlayerQueue extends ListBase<LinkPlayerItem> {
|
||||
_CurrentPlayerQueue(this._base, this._item, this._index)
|
||||
: _current = _MappedPlayerQueue([_item]);
|
||||
|
||||
final List<LinkPlayerItem> _base;
|
||||
final MediaItem _item;
|
||||
final int _index;
|
||||
final _MappedPlayerQueue _current;
|
||||
|
||||
@override
|
||||
int get length => _base.length;
|
||||
|
||||
@override
|
||||
set length(int value) => throw UnsupportedError('Immutable player queue');
|
||||
|
||||
@override
|
||||
LinkPlayerItem operator [](int index) {
|
||||
RangeError.checkValidIndex(index, this);
|
||||
return index == _index ? _current[0] : _base[index];
|
||||
}
|
||||
|
||||
@override
|
||||
void operator []=(int index, LinkPlayerItem value) =>
|
||||
throw UnsupportedError('Immutable player queue');
|
||||
}
|
||||
|
||||
/// The desktop player at one moment.
|
||||
@immutable
|
||||
class LinkPlayerSnapshot {
|
||||
@@ -139,9 +235,14 @@ class RuntimeLinkPlayerPort implements LinkPlayerPort {
|
||||
final MusicPlayerController _controller;
|
||||
List<MediaItem>? _mappedQueue;
|
||||
List<LinkPlayerItem> _mapped = const [];
|
||||
MediaItem? _mappedCurrent;
|
||||
List<LinkPlayerItem>? _currentBase;
|
||||
List<LinkPlayerItem> _currentItems = const [];
|
||||
_CurrentPlayerQueue? _currentItems;
|
||||
MediaItem? _standaloneItem;
|
||||
List<LinkPlayerItem> _standalone = const [];
|
||||
|
||||
@visibleForTesting
|
||||
int get debugMappedQueueItemCount => _mapped is _MappedPlayerQueue
|
||||
? (_mapped as _MappedPlayerQueue)._items.length
|
||||
: 0;
|
||||
|
||||
@override
|
||||
LinkPlayerSnapshot snapshot() {
|
||||
@@ -152,10 +253,10 @@ class RuntimeLinkPlayerPort implements LinkPlayerPort {
|
||||
return LinkPlayerSnapshot(updatedMs: now, volume: volume);
|
||||
}
|
||||
final queue = handler.queue.value;
|
||||
// Map the queue once per change; position ticks reuse it.
|
||||
// Map only entries read by the state window or an explicit queue request.
|
||||
if (!identical(queue, _mappedQueue)) {
|
||||
_mappedQueue = queue;
|
||||
_mapped = List.unmodifiable(queue.map(LinkPlayerItem.fromMediaItem));
|
||||
_mapped = _MappedPlayerQueue(queue);
|
||||
}
|
||||
final current = handler.mediaItem.value;
|
||||
final state = handler.playbackState.value;
|
||||
@@ -168,24 +269,28 @@ class RuntimeLinkPlayerPort implements LinkPlayerPort {
|
||||
queue[index].id != current.id) {
|
||||
index = queue.indexWhere((item) => item.id == current.id);
|
||||
if (index < 0) {
|
||||
items = [LinkPlayerItem.fromMediaItem(current)];
|
||||
if (!identical(current, _standaloneItem)) {
|
||||
_standaloneItem = current;
|
||||
_standalone = _MappedPlayerQueue([current]);
|
||||
}
|
||||
items = _standalone;
|
||||
index = 0;
|
||||
}
|
||||
}
|
||||
if (current != null &&
|
||||
identical(items, _mapped) &&
|
||||
index >= 0 &&
|
||||
index < queue.length &&
|
||||
!identical(current, queue[index])) {
|
||||
if (!identical(current, _mappedCurrent) ||
|
||||
!identical(items, _currentBase)) {
|
||||
_mappedCurrent = current;
|
||||
_currentBase = items;
|
||||
_currentItems = List.unmodifiable([
|
||||
for (var i = 0; i < items.length; i++)
|
||||
i == index ? LinkPlayerItem.fromMediaItem(current) : items[i],
|
||||
]);
|
||||
final overlay = _currentItems;
|
||||
if (overlay == null ||
|
||||
!identical(current, overlay._item) ||
|
||||
!identical(items, overlay._base) ||
|
||||
index != overlay._index) {
|
||||
_currentItems = _CurrentPlayerQueue(items, current, index);
|
||||
}
|
||||
items = _currentItems;
|
||||
items = _currentItems!;
|
||||
} else {
|
||||
_currentItems = null;
|
||||
}
|
||||
return LinkPlayerSnapshot(
|
||||
queue: items,
|
||||
@@ -333,18 +438,62 @@ TrackRef linkTrackRef(LinkPlayerItem item, {DesktopLinkCatalogIndex? index}) {
|
||||
);
|
||||
}
|
||||
|
||||
/// Retains the last queue window while its entries and catalog stay current.
|
||||
class LinkPlayerStateCache {
|
||||
List<LinkPlayerItem>? _source;
|
||||
DesktopLinkCatalogIndex? _index;
|
||||
int _start = -1;
|
||||
int _end = -1;
|
||||
List<LinkPlayerItem> _items = const [];
|
||||
List<TrackRef> _refs = const [];
|
||||
|
||||
List<TrackRef> _window(
|
||||
List<LinkPlayerItem> source,
|
||||
({int start, int end}) window,
|
||||
DesktopLinkCatalogIndex? index,
|
||||
) {
|
||||
var unchanged =
|
||||
identical(source, _source) &&
|
||||
identical(index, _index) &&
|
||||
window.start == _start &&
|
||||
window.end == _end;
|
||||
if (unchanged) {
|
||||
for (var i = window.start; i < window.end; i++) {
|
||||
if (!identical(source[i], _items[i - window.start])) {
|
||||
unchanged = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!unchanged) {
|
||||
_source = source;
|
||||
_index = index;
|
||||
_start = window.start;
|
||||
_end = window.end;
|
||||
_items = [for (var i = window.start; i < window.end; i++) source[i]];
|
||||
_refs = List.unmodifiable([
|
||||
for (final item in _items) linkTrackRef(item, index: index),
|
||||
]);
|
||||
}
|
||||
return _refs;
|
||||
}
|
||||
}
|
||||
|
||||
/// The desktop player as `player.state` and `GET state` send it.
|
||||
LinkPlayerState linkPlayerState(
|
||||
LinkPlayerSnapshot snapshot, {
|
||||
DesktopLinkCatalogIndex? index,
|
||||
bool? autoplay,
|
||||
bool? autoMix,
|
||||
LinkPlayerStateCache? cache,
|
||||
}) {
|
||||
final window = linkQueueWindow(snapshot.queue.length, snapshot.index);
|
||||
final queue = [
|
||||
for (var i = window.start; i < window.end; i++)
|
||||
linkTrackRef(snapshot.queue[i], index: index),
|
||||
];
|
||||
final queue =
|
||||
cache?._window(snapshot.queue, window, index) ??
|
||||
[
|
||||
for (var i = window.start; i < window.end; i++)
|
||||
linkTrackRef(snapshot.queue[i], index: index),
|
||||
];
|
||||
final current = snapshot.current;
|
||||
final inWindow =
|
||||
current != null &&
|
||||
|
||||
@@ -133,6 +133,53 @@ void main() {
|
||||
expect((queue.last as Map).containsKey('songId'), isFalse);
|
||||
});
|
||||
|
||||
test('state retains its queue refs until entries or catalog change', () {
|
||||
final queue = [playerItem('a'), playerItem('b')];
|
||||
player.current = snapshot(queue: queue);
|
||||
final first = ops.state();
|
||||
player.current = snapshot(queue: queue, positionMs: 48000, playing: false);
|
||||
autoplay = true;
|
||||
autoMix = true;
|
||||
final next = ops.state();
|
||||
expect(identical(next.queue, first.queue), isTrue);
|
||||
expect(identical(next.track, next.queue[1]), isTrue);
|
||||
expect(next.positionMs, 48000);
|
||||
expect(next.playing, isFalse);
|
||||
expect(next.autoplay, isTrue);
|
||||
expect(next.autoMix, isTrue);
|
||||
queue[0] = const LinkPlayerItem(
|
||||
id: 'a',
|
||||
path: '/edited.flac',
|
||||
title: 'Edited',
|
||||
artist: 'Artist',
|
||||
);
|
||||
final edited = ops.state();
|
||||
expect(edited.queue.first.title, 'Edited');
|
||||
expect(identical(edited.queue, next.queue), isFalse);
|
||||
index = DesktopLinkCatalogIndex(
|
||||
serverId: 'new-server',
|
||||
songs: [
|
||||
const LinkCatalogSong(
|
||||
id: 'l:new',
|
||||
path: '/edited.flac',
|
||||
title: 'Edited',
|
||||
artist: 'Artist',
|
||||
album: 'Catalog album',
|
||||
durationMs: 12345,
|
||||
isrc: 'EXAMPLE123',
|
||||
),
|
||||
],
|
||||
);
|
||||
final cataloged = ops.state();
|
||||
expect(cataloged.queue.first.songId, 'l:new');
|
||||
expect(cataloged.queue.first.serverId, 'new-server');
|
||||
expect(cataloged.queue.first.album, 'Catalog album');
|
||||
expect(cataloged.queue.first.durationMs, 12345);
|
||||
expect(cataloged.queue.first.isrc, 'EXAMPLE123');
|
||||
expect(first.queue.first.title, 'Title a');
|
||||
expect(() => cataloged.queue.clear(), throwsUnsupportedError);
|
||||
});
|
||||
|
||||
test(
|
||||
'handoff adopts playback modes and reports automation changes',
|
||||
() async {
|
||||
|
||||
@@ -0,0 +1,687 @@
|
||||
import 'dart:collection';
|
||||
import 'dart:math';
|
||||
|
||||
import 'package:audio_service/audio_service.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:mornye/services/link/desktop/link_catalog_index.dart';
|
||||
import 'package:mornye/services/link/desktop/link_desktop_ops.dart';
|
||||
import 'package:mornye/services/link/desktop/link_player.dart';
|
||||
import 'package:mornye/services/link/link_host_router.dart';
|
||||
import 'package:mornye/services/link/link_playback_details.dart';
|
||||
import 'package:mornye/services/link/link_protocol.dart';
|
||||
import 'package:mornye/services/music_player_service.dart';
|
||||
|
||||
import 'support/link_desktop_fakes.dart';
|
||||
|
||||
class _Handler extends BaseAudioHandler implements MusicPlayerHandler {
|
||||
@override
|
||||
Future<void> stop({bool keepResume = false}) async {}
|
||||
|
||||
@override
|
||||
dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
|
||||
|
||||
Future<void> close() async {
|
||||
await queue.close();
|
||||
await mediaItem.close();
|
||||
await playbackState.close();
|
||||
}
|
||||
}
|
||||
|
||||
class _Runtime extends MusicPlayerRuntime {
|
||||
_Runtime(this.handler);
|
||||
|
||||
@override
|
||||
final MusicPlayerHandler? handler;
|
||||
}
|
||||
|
||||
class _CountingMediaItem extends MediaItem {
|
||||
_CountingMediaItem(int index, {Map<String, dynamic>? extras, Uri? artwork})
|
||||
: super(
|
||||
id: '$index',
|
||||
title: 'Song $index',
|
||||
artist: 'Artist',
|
||||
artUri: artwork,
|
||||
extras: extras ?? {'source': '/Music/$index.flac'},
|
||||
);
|
||||
|
||||
static int titleReads = 0;
|
||||
|
||||
@override
|
||||
String get title {
|
||||
titleReads++;
|
||||
return super.title;
|
||||
}
|
||||
}
|
||||
|
||||
class _CountingIndex extends DesktopLinkCatalogIndex {
|
||||
_CountingIndex({super.serverId = 'server', super.songs = const []});
|
||||
|
||||
int lookups = 0;
|
||||
|
||||
@override
|
||||
String? songIdForMedia({required String id, required String path}) {
|
||||
lookups++;
|
||||
return super.songIdForMedia(id: id, path: path);
|
||||
}
|
||||
}
|
||||
|
||||
class _CountingMetadata extends MapBase<String, dynamic> {
|
||||
final _values = <String, dynamic>{'genre': 'Rock', 'lyrics': 'Words'};
|
||||
int keyReads = 0;
|
||||
|
||||
@override
|
||||
int get length => _values.length;
|
||||
|
||||
@override
|
||||
bool containsKey(Object? key) => _values.containsKey(key);
|
||||
|
||||
@override
|
||||
Iterable<String> get keys {
|
||||
keyReads++;
|
||||
return _values.keys;
|
||||
}
|
||||
|
||||
@override
|
||||
dynamic operator [](Object? key) => _values[key];
|
||||
|
||||
@override
|
||||
void operator []=(String key, dynamic value) => _values[key] = value;
|
||||
|
||||
@override
|
||||
void clear() => _values.clear();
|
||||
|
||||
@override
|
||||
dynamic remove(Object? key) => _values.remove(key);
|
||||
}
|
||||
|
||||
class _RecordingDetails extends LinkPlaybackDetails {
|
||||
LinkPlayerItem? item;
|
||||
|
||||
@override
|
||||
Future<Map<String, dynamic>> read(LinkPlayerItem item) async {
|
||||
this.item = item;
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
||||
void _expectMappedItem(LinkPlayerItem actual, MediaItem source) {
|
||||
final expected = LinkPlayerItem.fromMediaItem(source);
|
||||
expect(actual.id, expected.id);
|
||||
expect(actual.path, expected.path);
|
||||
expect(actual.title, expected.title);
|
||||
expect(actual.artist, expected.artist);
|
||||
expect(actual.album, expected.album);
|
||||
expect(actual.durationMs, expected.durationMs);
|
||||
expect(actual.artwork, expected.artwork);
|
||||
expect(actual.metadataSource, expected.metadataSource);
|
||||
expect(actual.audioMetadata, expected.audioMetadata);
|
||||
}
|
||||
|
||||
void main() {
|
||||
TestWidgetsFlutterBinding.ensureInitialized();
|
||||
|
||||
test('a rich current overlay maps only its 20000-song queue window', () {
|
||||
final handler = _Handler();
|
||||
final runtime = _Runtime(handler);
|
||||
addTearDown(handler.close);
|
||||
addTearDown(runtime.dispose);
|
||||
final media = List<MediaItem>.unmodifiable([
|
||||
for (var i = 0; i < 20000; i++) _CountingMediaItem(i),
|
||||
]);
|
||||
final tags = _CountingMetadata();
|
||||
final current = _CountingMediaItem(
|
||||
10000,
|
||||
artwork: Uri.file('/current.jpg'),
|
||||
extras: {
|
||||
'source': '/Music/10000.flac',
|
||||
'resolvedSource': '/received/current.flac',
|
||||
'sample_rate': 96000,
|
||||
'displayMetadata': tags,
|
||||
},
|
||||
);
|
||||
handler.queue.add(media);
|
||||
handler.mediaItem.add(current);
|
||||
handler.playbackState.add(PlaybackState(queueIndex: 10000));
|
||||
final port = RuntimeLinkPlayerPort(runtime);
|
||||
final cache = LinkPlayerStateCache();
|
||||
final index = _CountingIndex();
|
||||
_CountingMediaItem.titleReads = 0;
|
||||
final snapshot = port.snapshot();
|
||||
expect(_CountingMediaItem.titleReads, 0);
|
||||
final state = linkPlayerState(snapshot, index: index, cache: cache);
|
||||
expect(_CountingMediaItem.titleReads, 200);
|
||||
expect(port.debugMappedQueueItemCount, 199);
|
||||
expect(snapshot.current!.artwork, 'file:///current.jpg');
|
||||
expect(snapshot.current!.metadataSource, '/received/current.flac');
|
||||
expect(snapshot.current!.audioMetadata['sample_rate'], 96000);
|
||||
final metadata = snapshot.current!.audioMetadata;
|
||||
final keyReads = tags.keyReads;
|
||||
expect(keyReads, greaterThan(0));
|
||||
for (var tick = 0; tick < 60; tick++) {
|
||||
final next = port.snapshot();
|
||||
expect(next.queue, same(snapshot.queue));
|
||||
expect(next.current!.audioMetadata, same(metadata));
|
||||
expect(
|
||||
linkPlayerState(next, index: index, cache: cache).queue,
|
||||
same(state.queue),
|
||||
);
|
||||
}
|
||||
expect(tags.keyReads, keyReads);
|
||||
expect(_CountingMediaItem.titleReads, 200);
|
||||
expect(index.lookups, 200);
|
||||
expect(snapshot.queue[9999].metadataSource, isNull);
|
||||
for (var i = 0; i < snapshot.queue.length; i++) {
|
||||
expect(snapshot.queue[i].id, '$i');
|
||||
expect(port.debugMappedQueueItemCount, lessThanOrEqualTo(400));
|
||||
}
|
||||
expect(port.debugMappedQueueItemCount, 400);
|
||||
expect(tags.keyReads, keyReads);
|
||||
expect(() => snapshot.queue[0] = snapshot.current!, throwsUnsupportedError);
|
||||
});
|
||||
|
||||
test(
|
||||
'current overlays follow duplicate indices and fallback transitions',
|
||||
() {
|
||||
final handler = _Handler();
|
||||
final runtime = _Runtime(handler);
|
||||
addTearDown(handler.close);
|
||||
addTearDown(runtime.dispose);
|
||||
const first = MediaItem(id: 'same', title: 'First');
|
||||
const second = MediaItem(id: 'same', title: 'Second');
|
||||
const current = MediaItem(id: 'same', title: 'Live');
|
||||
handler.queue.add([first, second]);
|
||||
handler.mediaItem.add(current);
|
||||
handler.playbackState.add(PlaybackState(queueIndex: 0));
|
||||
final port = RuntimeLinkPlayerPort(runtime);
|
||||
final cache = LinkPlayerStateCache();
|
||||
final atFirst = port.snapshot();
|
||||
expect(atFirst.queue.map((v) => v.title), ['Live', 'Second']);
|
||||
expect(linkPlayerState(atFirst, cache: cache).index, 0);
|
||||
handler.playbackState.add(PlaybackState(queueIndex: 1));
|
||||
final atSecond = port.snapshot();
|
||||
expect(atSecond.queue.map((v) => v.title), ['First', 'Live']);
|
||||
final movedState = linkPlayerState(atSecond, cache: cache);
|
||||
expect(movedState.index, 1);
|
||||
expect(movedState.track!.title, 'Live');
|
||||
expect(movedState.queue.first.title, 'First');
|
||||
expect(atFirst.queue.map((v) => v.title), ['Live', 'Second']);
|
||||
expect(port.snapshot().queue, same(atSecond.queue));
|
||||
handler.mediaItem.add(second);
|
||||
final canonical = port.snapshot();
|
||||
expect(canonical.queue.map((v) => v.title), ['First', 'Second']);
|
||||
handler.mediaItem.add(null);
|
||||
final emptyCurrent = port.snapshot();
|
||||
expect(emptyCurrent.queue, same(canonical.queue));
|
||||
expect(emptyCurrent.current, isNull);
|
||||
expect(emptyCurrent.index, -1);
|
||||
const foreign = MediaItem(id: 'foreign', title: 'Foreign');
|
||||
handler.mediaItem.add(foreign);
|
||||
final standalone = port.snapshot();
|
||||
expect(standalone.queue.single.title, 'Foreign');
|
||||
expect(standalone.index, 0);
|
||||
handler.queue.add([]);
|
||||
expect(port.snapshot().queue, same(standalone.queue));
|
||||
handler.mediaItem.add(null);
|
||||
expect(port.snapshot().queue, isEmpty);
|
||||
handler.queue.add([first, second]);
|
||||
handler.mediaItem.add(current);
|
||||
expect(port.snapshot().queue.map((v) => v.title), ['First', 'Live']);
|
||||
},
|
||||
);
|
||||
|
||||
for (final mode in ['canonical', 'overlay', 'standalone']) {
|
||||
test('$mode mapping observes metadata edits, removal and replacement', () {
|
||||
final handler = _Handler();
|
||||
final runtime = _Runtime(handler);
|
||||
addTearDown(handler.close);
|
||||
addTearDown(runtime.dispose);
|
||||
final tags = <String, dynamic>{'genre': 'Rock', 'lyrics': 'Old words'};
|
||||
final extras = <String, dynamic>{
|
||||
'source': '/song.flac',
|
||||
'resolvedSource': '/received/song.flac',
|
||||
'bit_depth': 16,
|
||||
'sample_rate': 44100,
|
||||
'bitrate': 320,
|
||||
'format': 'flac',
|
||||
'explicit': false,
|
||||
'displayMetadata': tags,
|
||||
};
|
||||
var current = MediaItem(
|
||||
id: mode == 'standalone' ? 'foreign' : 'song',
|
||||
title: 'Song',
|
||||
artUri: Uri.file('/old.jpg'),
|
||||
extras: extras,
|
||||
);
|
||||
final queue = [
|
||||
mode == 'canonical'
|
||||
? current
|
||||
: const MediaItem(id: 'song', title: 'Queued'),
|
||||
];
|
||||
handler.queue.add(queue);
|
||||
handler.mediaItem.add(current);
|
||||
handler.playbackState.add(PlaybackState(queueIndex: 0));
|
||||
final port = RuntimeLinkPlayerPort(runtime);
|
||||
var previous = port.snapshot();
|
||||
var mapped = previous.current!;
|
||||
_expectMappedItem(mapped, current);
|
||||
void checkMutation() {
|
||||
final next = port.snapshot();
|
||||
expect(next.queue, same(previous.queue));
|
||||
expect(next.current, isNot(same(mapped)));
|
||||
mapped = next.current!;
|
||||
_expectMappedItem(mapped, current);
|
||||
previous = next;
|
||||
}
|
||||
|
||||
for (final change in {
|
||||
'source': 'EXISTS:/updated.flac',
|
||||
'resolvedSource': '/received/updated.flac',
|
||||
'bit_depth': 24,
|
||||
'sample_rate': 96000,
|
||||
'bitrate': 2400,
|
||||
'format': 'alac',
|
||||
'explicit': true,
|
||||
}.entries) {
|
||||
extras[change.key] = change.value;
|
||||
checkMutation();
|
||||
}
|
||||
tags['genre'] = 'Jazz';
|
||||
checkMutation();
|
||||
tags.remove('genre');
|
||||
checkMutation();
|
||||
extras['displayMetadata'] = {'album_artist': 'Replacement'};
|
||||
checkMutation();
|
||||
extras.remove('displayMetadata');
|
||||
checkMutation();
|
||||
for (final key in [
|
||||
'source',
|
||||
'resolvedSource',
|
||||
'bit_depth',
|
||||
'sample_rate',
|
||||
'bitrate',
|
||||
'format',
|
||||
'explicit',
|
||||
]) {
|
||||
extras.remove(key);
|
||||
checkMutation();
|
||||
}
|
||||
current = current.copyWith(
|
||||
artUri: Uri.file('/new.jpg'),
|
||||
extras: {
|
||||
'source': '/replacement.flac',
|
||||
'resolvedSource': '/received/replacement.flac',
|
||||
'sample_rate': 48000,
|
||||
'displayMetadata': {'genre': 'Replacement'},
|
||||
},
|
||||
);
|
||||
if (mode == 'canonical') queue[0] = current;
|
||||
handler.mediaItem.add(current);
|
||||
final replaced = port.snapshot();
|
||||
expect(replaced.current, isNot(same(mapped)));
|
||||
_expectMappedItem(replaced.current!, current);
|
||||
expect(port.snapshot().queue, same(replaced.queue));
|
||||
});
|
||||
}
|
||||
|
||||
test(
|
||||
'playback details read the current overlay after metadata updates',
|
||||
() async {
|
||||
final handler = _Handler();
|
||||
final runtime = _Runtime(handler);
|
||||
addTearDown(handler.close);
|
||||
addTearDown(runtime.dispose);
|
||||
final tags = <String, dynamic>{'genre': 'Rock'};
|
||||
final extras = <String, dynamic>{
|
||||
'source': '/song.flac',
|
||||
'resolvedSource': '/received/old.flac',
|
||||
'sample_rate': 44100,
|
||||
'displayMetadata': tags,
|
||||
};
|
||||
var current = MediaItem(
|
||||
id: 'song',
|
||||
title: 'Song',
|
||||
artUri: Uri.file('/old.jpg'),
|
||||
extras: extras,
|
||||
);
|
||||
handler.queue.add([const MediaItem(id: 'song', title: 'Queued')]);
|
||||
handler.mediaItem.add(current);
|
||||
handler.playbackState.add(PlaybackState(queueIndex: 0));
|
||||
final port = RuntimeLinkPlayerPort(runtime);
|
||||
final details = _RecordingDetails();
|
||||
final ops = LinkDesktopOps(
|
||||
player: port,
|
||||
downloads: FakeLinkDownloads(),
|
||||
downloadItems: () => [],
|
||||
openUrl: (_) async {},
|
||||
index: () => null,
|
||||
desktopName: () => 'Desktop',
|
||||
playbackDetails: details,
|
||||
);
|
||||
final router = LinkHostRouter();
|
||||
ops.register(router);
|
||||
Future<void> readDetails() async {
|
||||
await router.dispatch(
|
||||
LinkRequest(
|
||||
requestId: 'details',
|
||||
op: LinkOps.playbackDetails,
|
||||
deviceId: 'phone',
|
||||
args: {'track': ops.state().track!.toJson()},
|
||||
),
|
||||
);
|
||||
_expectMappedItem(details.item!, current);
|
||||
}
|
||||
|
||||
await readDetails();
|
||||
extras['resolvedSource'] = '/received/new.flac';
|
||||
extras['sample_rate'] = 96000;
|
||||
tags['genre'] = 'Jazz';
|
||||
await readDetails();
|
||||
current = current.copyWith(artUri: Uri.file('/new.jpg'));
|
||||
handler.mediaItem.add(current);
|
||||
await readDetails();
|
||||
},
|
||||
);
|
||||
|
||||
test('runtime mapping retention stays bounded through a 20000-song walk', () {
|
||||
final handler = _Handler();
|
||||
final runtime = _Runtime(handler);
|
||||
addTearDown(handler.close);
|
||||
addTearDown(runtime.dispose);
|
||||
final media = List<MediaItem>.unmodifiable([
|
||||
for (var i = 0; i < 20000; i++) _CountingMediaItem(i),
|
||||
]);
|
||||
handler.queue.add(media);
|
||||
handler.mediaItem.add(media[10000]);
|
||||
handler.playbackState.add(PlaybackState(queueIndex: 10000));
|
||||
final port = RuntimeLinkPlayerPort(runtime);
|
||||
final snapshot = port.snapshot();
|
||||
var peak = 0;
|
||||
for (var i = 0; i < snapshot.queue.length; i++) {
|
||||
expect(snapshot.queue[i].id, '$i');
|
||||
peak = max(peak, port.debugMappedQueueItemCount);
|
||||
}
|
||||
expect(peak, 400);
|
||||
expect(port.debugMappedQueueItemCount, 400);
|
||||
expect(snapshot.current!.id, '10000');
|
||||
final state = linkPlayerState(snapshot, cache: LinkPlayerStateCache());
|
||||
expect(state.index, 100);
|
||||
expect(state.track!.title, 'Song 10000');
|
||||
expect(port.debugMappedQueueItemCount, 400);
|
||||
});
|
||||
|
||||
test('cached state matches the original mapping through queue changes', () {
|
||||
final random = Random(7);
|
||||
final cache = LinkPlayerStateCache();
|
||||
var items = <LinkPlayerItem>[
|
||||
for (var i = 0; i < 500; i++)
|
||||
LinkPlayerItem(
|
||||
id: '$i',
|
||||
path: '/$i.flac',
|
||||
title: 'Song $i',
|
||||
artist: 'Artist',
|
||||
),
|
||||
];
|
||||
DesktopLinkCatalogIndex? catalog;
|
||||
for (var round = 0; round < 200; round++) {
|
||||
final at = random.nextInt(items.length + 2) - 1;
|
||||
switch (round % 6) {
|
||||
case 0:
|
||||
items = [...items];
|
||||
case 1:
|
||||
if (at >= 0 && at < items.length) {
|
||||
items[at] = LinkPlayerItem(
|
||||
id: 'edited-$round',
|
||||
path: '/edited-$round.flac',
|
||||
title: 'Edited $round',
|
||||
artist: 'Artist $round',
|
||||
album: 'Album $round',
|
||||
durationMs: round * 1000,
|
||||
);
|
||||
}
|
||||
case 2:
|
||||
items.add(
|
||||
LinkPlayerItem(
|
||||
id: '$round',
|
||||
path: '/$round.flac',
|
||||
title: 'Song $round',
|
||||
artist: 'Artist',
|
||||
),
|
||||
);
|
||||
case 3:
|
||||
if (at >= 0 && at < items.length) items.removeAt(at);
|
||||
case 4:
|
||||
items.setAll(0, items.reversed.toList());
|
||||
case 5:
|
||||
catalog = catalog == null
|
||||
? DesktopLinkCatalogIndex(
|
||||
serverId: 'server',
|
||||
songs: [
|
||||
for (final item in items)
|
||||
LinkCatalogSong(
|
||||
id: 'l:${item.id}',
|
||||
path: item.path,
|
||||
title: item.title,
|
||||
artist: item.artist,
|
||||
album: 'Catalog album',
|
||||
durationMs: 12345,
|
||||
isrc: 'EXAMPLE123',
|
||||
),
|
||||
],
|
||||
)
|
||||
: null;
|
||||
}
|
||||
final snapshot = LinkPlayerSnapshot(
|
||||
queue: items,
|
||||
index: at,
|
||||
updatedMs: round * 1000,
|
||||
positionMs: round * 400,
|
||||
playing: round.isEven,
|
||||
durationMs: round.isEven ? null : 12345,
|
||||
shuffle: round % 3 == 0,
|
||||
volume: random.nextDouble() * 1.5,
|
||||
);
|
||||
expect(
|
||||
linkPlayerState(snapshot, index: catalog, cache: cache).toJson(),
|
||||
linkPlayerState(snapshot, index: catalog).toJson(),
|
||||
reason: 'round $round',
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
test(
|
||||
'a 20000-song runtime queue maps only the window across ticks',
|
||||
() async {
|
||||
final handler = _Handler();
|
||||
final runtime = _Runtime(handler);
|
||||
addTearDown(handler.close);
|
||||
addTearDown(runtime.dispose);
|
||||
final media = List<MediaItem>.unmodifiable([
|
||||
for (var i = 0; i < 20000; i++) _CountingMediaItem(i),
|
||||
]);
|
||||
handler.queue.add(media);
|
||||
handler.mediaItem.add(media[10000]);
|
||||
handler.playbackState.add(PlaybackState(queueIndex: 10000));
|
||||
final port = RuntimeLinkPlayerPort(runtime);
|
||||
_CountingMediaItem.titleReads = 0;
|
||||
final snapshot = port.snapshot();
|
||||
expect(_CountingMediaItem.titleReads, 0);
|
||||
final cache = LinkPlayerStateCache();
|
||||
final index = _CountingIndex();
|
||||
final first = linkPlayerState(snapshot, index: index, cache: cache);
|
||||
expect(_CountingMediaItem.titleReads, 200);
|
||||
expect(index.lookups, 200);
|
||||
expect(first.queue.first.title, 'Song 9900');
|
||||
expect(first.queue.last.title, 'Song 10099');
|
||||
expect(first.index, 100);
|
||||
expect(first.track!.title, 'Song 10000');
|
||||
for (var tick = 0; tick < 60; tick++) {
|
||||
final next = port.snapshot();
|
||||
expect(identical(next.queue, snapshot.queue), isTrue);
|
||||
expect(
|
||||
identical(
|
||||
linkPlayerState(next, index: index, cache: cache).queue,
|
||||
first.queue,
|
||||
),
|
||||
isTrue,
|
||||
);
|
||||
}
|
||||
expect(_CountingMediaItem.titleReads, 200);
|
||||
expect(index.lookups, 200);
|
||||
expect(() => snapshot.queue.clear(), throwsUnsupportedError);
|
||||
expect(() => first.queue.clear(), throwsUnsupportedError);
|
||||
|
||||
final replacement = [...media];
|
||||
replacement[10005] = replacement[10005].copyWith(title: 'Edited song');
|
||||
handler.queue.add(List.unmodifiable(replacement));
|
||||
final edited = linkPlayerState(
|
||||
port.snapshot(),
|
||||
index: index,
|
||||
cache: cache,
|
||||
);
|
||||
expect(edited.queue[105].title, 'Edited song');
|
||||
expect(first.queue[105].title, 'Song 10005');
|
||||
expect(index.lookups, 400);
|
||||
expect(_CountingMediaItem.titleReads, lessThan(401));
|
||||
|
||||
final before = _CountingMediaItem.titleReads;
|
||||
handler.mediaItem.add(media[10500]);
|
||||
handler.playbackState.add(PlaybackState(queueIndex: 10500));
|
||||
final moved = linkPlayerState(
|
||||
port.snapshot(),
|
||||
index: index,
|
||||
cache: cache,
|
||||
);
|
||||
expect(moved.queue.first.title, 'Song 10400');
|
||||
expect(moved.track!.title, 'Song 10500');
|
||||
expect(_CountingMediaItem.titleReads - before, 200);
|
||||
},
|
||||
);
|
||||
|
||||
test('cached windows retain scalar, metadata and catalog invalidation', () {
|
||||
final items = <LinkPlayerItem>[
|
||||
for (var i = 0; i < 500; i++)
|
||||
LinkPlayerItem(
|
||||
id: '$i',
|
||||
path: '/$i.flac',
|
||||
title: 'Song $i',
|
||||
artist: 'Artist',
|
||||
),
|
||||
];
|
||||
final cache = LinkPlayerStateCache();
|
||||
final index = _CountingIndex();
|
||||
LinkPlayerSnapshot snapshot({
|
||||
int at = 499,
|
||||
bool playing = false,
|
||||
int position = 0,
|
||||
}) => LinkPlayerSnapshot(
|
||||
queue: items,
|
||||
index: at,
|
||||
playing: playing,
|
||||
positionMs: position,
|
||||
updatedMs: position,
|
||||
);
|
||||
final first = linkPlayerState(snapshot(), index: index, cache: cache);
|
||||
final tick = linkPlayerState(
|
||||
snapshot(playing: true, position: 5000),
|
||||
index: index,
|
||||
cache: cache,
|
||||
autoplay: true,
|
||||
autoMix: false,
|
||||
);
|
||||
expect(identical(tick.queue, first.queue), isTrue);
|
||||
expect(tick.index, 199);
|
||||
expect(tick.playing, isTrue);
|
||||
expect(tick.positionMs, 5000);
|
||||
expect(tick.autoplay, isTrue);
|
||||
expect(tick.autoMix, isFalse);
|
||||
expect(index.lookups, 200);
|
||||
|
||||
items[498] = const LinkPlayerItem(
|
||||
id: '498',
|
||||
path: '/edited.flac',
|
||||
title: 'Edited',
|
||||
artist: 'Edited artist',
|
||||
album: 'Edited album',
|
||||
durationMs: 1234,
|
||||
);
|
||||
final edited = linkPlayerState(snapshot(), index: index, cache: cache);
|
||||
expect(edited.queue[198].toJson(), {
|
||||
'title': 'Edited',
|
||||
'artist': 'Edited artist',
|
||||
'album': 'Edited album',
|
||||
'durationMs': 1234,
|
||||
'matchKey': 'edited|edited artist',
|
||||
});
|
||||
final refreshedIndex = _CountingIndex(
|
||||
songs: [
|
||||
const LinkCatalogSong(
|
||||
id: 'l:edited',
|
||||
path: '/edited.flac',
|
||||
title: 'Edited',
|
||||
artist: 'Edited artist',
|
||||
album: 'Catalog album',
|
||||
durationMs: 4321,
|
||||
isrc: 'EXAMPLE123',
|
||||
),
|
||||
],
|
||||
);
|
||||
final refreshed = linkPlayerState(
|
||||
snapshot(),
|
||||
index: refreshedIndex,
|
||||
cache: cache,
|
||||
);
|
||||
expect(refreshed.queue[198].songId, 'l:edited');
|
||||
expect(refreshed.queue[198].serverId, 'server');
|
||||
expect(refreshed.queue[198].isrc, 'EXAMPLE123');
|
||||
expect(refreshed.queue[198].album, 'Edited album');
|
||||
expect(refreshed.queue[198].durationMs, 1234);
|
||||
expect(refreshedIndex.lookups, 200);
|
||||
final uncataloged = linkPlayerState(snapshot(), cache: cache);
|
||||
expect(uncataloged.queue[198].songId, isNull);
|
||||
expect(uncataloged.queue[198].isrc, isNull);
|
||||
expect(linkPlayerState(snapshot(at: -1), cache: cache).track, isNull);
|
||||
items.clear();
|
||||
final empty = linkPlayerState(snapshot(), cache: cache);
|
||||
expect(empty.queue, isEmpty);
|
||||
expect(empty.index, -1);
|
||||
expect(empty.track, isNull);
|
||||
});
|
||||
|
||||
test(
|
||||
'runtime queue observes source edits and standalone current items',
|
||||
() async {
|
||||
final handler = _Handler();
|
||||
final runtime = _Runtime(handler);
|
||||
addTearDown(handler.close);
|
||||
addTearDown(runtime.dispose);
|
||||
final item = _CountingMediaItem(1);
|
||||
handler.queue.add([item]);
|
||||
handler.mediaItem.add(item);
|
||||
handler.playbackState.add(PlaybackState(queueIndex: 0));
|
||||
final port = RuntimeLinkPlayerPort(runtime);
|
||||
final cache = LinkPlayerStateCache();
|
||||
final first = port.snapshot();
|
||||
linkPlayerState(first, cache: cache);
|
||||
item.extras!['source'] = 'EXISTS:/edited.flac';
|
||||
final edited = port.snapshot();
|
||||
expect(identical(edited.queue, first.queue), isTrue);
|
||||
expect(edited.current!.path, '/edited.flac');
|
||||
final foreign = const MediaItem(
|
||||
id: 'foreign',
|
||||
title: 'Foreign',
|
||||
duration: Duration(seconds: 9),
|
||||
);
|
||||
handler.mediaItem.add(foreign);
|
||||
final standalone = port.snapshot();
|
||||
expect(standalone.queue.length, 1);
|
||||
expect(standalone.index, 0);
|
||||
expect(standalone.current!.title, 'Foreign');
|
||||
expect(identical(port.snapshot().queue, standalone.queue), isTrue);
|
||||
handler.mediaItem.add(foreign.copyWith(title: 'Edited foreign'));
|
||||
expect(port.snapshot().current!.title, 'Edited foreign');
|
||||
handler.mediaItem.add(null);
|
||||
expect(port.snapshot().index, -1);
|
||||
expect(RuntimeLinkPlayerPort(_Runtime(null)).snapshot().queue, isEmpty);
|
||||
},
|
||||
);
|
||||
}
|
||||
Reference in new issue
Block a user