diff --git a/lib/l10n/arb/app_en.arb b/lib/l10n/arb/app_en.arb index 3a5101a9f..4664e74a5 100644 --- a/lib/l10n/arb/app_en.arb +++ b/lib/l10n/arb/app_en.arb @@ -7821,6 +7821,14 @@ "description": "Selected state of the compact favorite action" }, "autoMixDescription": "Blend songs with beat matching and pitch-preserving tempo adjustment. Uses crossfade when beats cannot be matched.", + "gaplessPlayback": "Gapless playback", + "@gaplessPlayback": { + "description": "Playback settings switch that starts the next song the moment one ends" + }, + "gaplessPlaybackDescription": "Start the next song the moment one ends, without silence between them. AutoMix replaces it while on.", + "@gaplessPlaybackDescription": { + "description": "Subtitle of the Gapless playback switch" + }, "playerCoverStyle": "Cover art", "@playerCoverStyle": { "description": "Settings section choosing how the player shows cover art" diff --git a/lib/models/settings.dart b/lib/models/settings.dart index f47db1b66..35965c47a 100644 --- a/lib/models/settings.dart +++ b/lib/models/settings.dart @@ -60,6 +60,8 @@ class AppSettings { final String playbackNormalizationMode; // 'track' or 'album' final bool pauseOnMute; final bool playOnHeadphonesConnected; + // Start the next song the moment one ends; AutoMix replaces it while on. + final bool gaplessPlayback; final bool autoMix; @JsonKey(fromJson: autoMixDurationFromJson) final int autoMixDuration; @@ -261,6 +263,7 @@ class AppSettings { this.playbackNormalizationMode = 'track', this.pauseOnMute = true, this.playOnHeadphonesConnected = false, + this.gaplessPlayback = true, this.autoMix = false, this.autoMixDuration = 0, this.autoMixEffect = AutoMixEffect.auto, @@ -405,6 +408,7 @@ class AppSettings { String? playbackNormalizationMode, bool? pauseOnMute, bool? playOnHeadphonesConnected, + bool? gaplessPlayback, bool? autoMix, int? autoMixDuration, AutoMixEffect? autoMixEffect, @@ -534,6 +538,7 @@ class AppSettings { pauseOnMute: pauseOnMute ?? this.pauseOnMute, playOnHeadphonesConnected: playOnHeadphonesConnected ?? this.playOnHeadphonesConnected, + gaplessPlayback: gaplessPlayback ?? this.gaplessPlayback, autoMix: autoMix ?? this.autoMix, autoMixDuration: autoMixDuration ?? this.autoMixDuration, autoMixEffect: autoMixEffect ?? this.autoMixEffect, diff --git a/lib/models/settings.g.dart b/lib/models/settings.g.dart index fdc3930b2..a2b6de76d 100644 --- a/lib/models/settings.g.dart +++ b/lib/models/settings.g.dart @@ -40,6 +40,7 @@ AppSettings _$AppSettingsFromJson(Map json) => AppSettings( pauseOnMute: json['pauseOnMute'] as bool? ?? true, playOnHeadphonesConnected: json['playOnHeadphonesConnected'] as bool? ?? false, + gaplessPlayback: json['gaplessPlayback'] as bool? ?? true, autoMix: json['autoMix'] as bool? ?? false, autoMixDuration: json['autoMixDuration'] == null ? 0 @@ -203,6 +204,7 @@ Map _$AppSettingsToJson( 'playbackNormalizationMode': instance.playbackNormalizationMode, 'pauseOnMute': instance.pauseOnMute, 'playOnHeadphonesConnected': instance.playOnHeadphonesConnected, + 'gaplessPlayback': instance.gaplessPlayback, 'autoMix': instance.autoMix, 'autoMixDuration': instance.autoMixDuration, 'autoMixEffect': _$AutoMixEffectEnumMap[instance.autoMixEffect]!, diff --git a/lib/providers/settings_provider.dart b/lib/providers/settings_provider.dart index 6b4e194d5..225ede01a 100644 --- a/lib/providers/settings_provider.dart +++ b/lib/providers/settings_provider.dart @@ -626,6 +626,9 @@ class SettingsNotifier extends Notifier { void setPlayOnHeadphonesConnected(bool enabled) => _commit(state.copyWith(playOnHeadphonesConnected: enabled)); + void setGaplessPlayback(bool enabled) => + _commit(state.copyWith(gaplessPlayback: enabled)); + void setAutoMix(bool enabled) => _commit(state.copyWith(autoMix: enabled)); void setAutoMixDuration(int seconds) => _commit( diff --git a/lib/screens/settings/playback_settings_page.dart b/lib/screens/settings/playback_settings_page.dart index 7ec749a6e..e2ee04142 100644 --- a/lib/screens/settings/playback_settings_page.dart +++ b/lib/screens/settings/playback_settings_page.dart @@ -221,6 +221,20 @@ class _PlaybackSettingsPageState extends ConsumerState { enabled: settings.playerMode == 'internal', ), ], + SettingsSwitchItem( + icon: Icons.linear_scale, + title: context.l10n.gaplessPlayback, + subtitle: context.l10n.gaplessPlaybackDescription, + value: settings.gaplessPlayback && !settings.autoMix, + enabled: + settings.playerMode == 'internal' && + !settings.autoMix && + !settings.usbBitPerfect && + !(isDesktopPlatform && settings.exclusiveOutput), + onChanged: (value) => ref + .read(settingsProvider.notifier) + .setGaplessPlayback(value), + ), SettingsSwitchItem( icon: Icons.compare_arrows, title: 'AutoMix', diff --git a/lib/services/exclusive_output_deck.dart b/lib/services/exclusive_output_deck.dart index 7c17a00bb..4eeeaa09d 100644 --- a/lib/services/exclusive_output_deck.dart +++ b/lib/services/exclusive_output_deck.dart @@ -205,6 +205,9 @@ class ExclusiveOutputDeck implements PlaybackDeck { @override Future stop() => _active.stop(); @override + Future setNextDeck(PlaybackDeck? next) => + _active.setNextDeck(next is ExclusiveOutputDeck ? next._active : next); + @override Future getCurrentPosition() => _active.getCurrentPosition(); @override Future getDuration() => _active.getDuration(); diff --git a/lib/services/media_kit_playback_deck.dart b/lib/services/media_kit_playback_deck.dart index 7b6d05db8..7c91d341a 100644 --- a/lib/services/media_kit_playback_deck.dart +++ b/lib/services/media_kit_playback_deck.dart @@ -543,6 +543,11 @@ class MediaKitPlaybackDeck implements PlaybackDeck { _setState(PlaybackDeckState.stopped); } + /// Each deck owns its own libmpv instance, which cannot hand its output to + /// another; the next deck starts on the completion event instead. + @override + Future setNextDeck(PlaybackDeck? next) async => false; + @override Future getCurrentPosition() async { // Asked directly: media_kit's cached position trails a pause or seek. diff --git a/lib/services/music_playback_deck.dart b/lib/services/music_playback_deck.dart index 8645ac671..f7200b3da 100644 --- a/lib/services/music_playback_deck.dart +++ b/lib/services/music_playback_deck.dart @@ -111,6 +111,10 @@ class AudioplayersPlaybackDeck implements PlaybackDeck { (Platform.isAndroid || Platform.isIOS || (isDesktopPlatform && Platform.isMacOS)), + _platformChainsPlayers = + Platform.isAndroid || + Platform.isIOS || + (isDesktopPlatform && Platform.isMacOS), _nativeAvailable = nativeAvailable ?? Platform.isAndroid { playbackEqualizer.addListener(_equalizerChanged); playbackOutputVolume.addListener(_outputVolumeChanged); @@ -139,12 +143,18 @@ class AudioplayersPlaybackDeck implements PlaybackDeck { ]); } + /// Forces [setNextDeck] support, for tests on any host. + @visibleForTesting + static bool? debugChainsPlayers; + static const _channel = MethodChannel('com.zarz.mornye/usb_pcm'); static const _events = EventChannel('com.zarz.mornye/usb_pcm/events'); static Stream? _nativeEvents; static int _nextToken = 0; final AudioPlayer _ordinary; final bool _equalizerAvailable; + final bool _platformChainsPlayers; + bool get _chainsPlayers => debugChainsPlayers ?? _platformChainsPlayers; bool _equalizerDisposed = false; static const _effects = MethodChannel('xyz.luan/audioplayers'); bool _equalizerSent = false; @@ -550,6 +560,29 @@ class AudioplayersPlaybackDeck implements PlaybackDeck { if (!_disposed && token == _token && _direct) _positions.add(position); } + @override + Future setNextDeck(PlaybackDeck? next) async { + // The forks chain their own players: Android with + // MediaPlayer.setNextMediaPlayer, Darwin from the end notification. + if (_direct || !_chainsPlayers) return false; + final player = next is AudioplayersPlaybackDeck && !next._direct + ? next._ordinary + : null; + if (next != null && player == null) return false; + try { + await _effects.invokeMethod('setNextPlayer', { + 'playerId': _ordinary.playerId, + 'nextPlayerId': ?player?.playerId, + }); + return player != null; + } on PlatformException catch (error) { + _log.w('Next player link unavailable: $error'); + return false; + } on MissingPluginException { + return false; + } + } + @override Future getCurrentPosition() async { if (!_direct) return _ordinary.getCurrentPosition(); diff --git a/lib/services/music_player_gapless.dart b/lib/services/music_player_gapless.dart new file mode 100644 index 000000000..afe3ba8e0 --- /dev/null +++ b/lib/services/music_player_gapless.dart @@ -0,0 +1,262 @@ +part of 'music_player_service.dart'; + +/// Gapless playback: loads the next song on a second deck shortly before the +/// current one ends and starts it the moment the current one completes, +/// chained natively where the engine can (see [PlaybackDeck.setNextDeck]). +/// AutoMix replaces it while on. Repeat one, USB output and exclusive output +/// keep the ordinary transition, which loads the next song after the end. +class _MusicGapless { + _MusicGapless(this.handler); + + /// How long before the end the next song loads. + static const lead = Duration(seconds: 30); + + final MusicPlayerHandler handler; + final _pins = {}; + PlaybackDeck? _prepared; + PlayableMedia? _next; + String? _nextPath; + String? _nextArtwork; + Duration? _nextDuration; + double _nextVolume = 1; + bool _nextIsCopy = false; + int _nextIndex = -1; + int _queueRevision = -1; + int _playGeneration = -1; + int _generation = 0; + String? _attempt; + bool _preparing = false; + + Set get pinnedPaths => _pins; + + bool get _enabled { + final settings = handler._settings; + return settings.gaplessPlayback && + !settings.autoMix && + !settings.usbBitPerfect && + // A second deck cannot open a device held in exclusive mode. + !playbackExclusiveOutput.value && + !handler._player.isDirect && + !handler._disposed && + handler._sourceReady && + handler._repeatMode != AudioServiceRepeatMode.one; + } + + bool _current(int generation) => + generation == _generation && + _enabled && + _playGeneration == handler._playRequestGeneration && + _queueRevision == handler._sessionQueueRevision; + + void onPosition(Duration position) { + if (_preparing) return; + if (_prepared != null) { + if (!_current(_generation)) unawaited(cancel()); + return; + } + if (!_enabled) return; + final duration = handler.mediaItem.value?.duration; + if (duration == null || + duration <= Duration.zero || + duration - position > lead) { + return; + } + final key = + '${handler._playRequestGeneration}:${handler._sessionQueueRevision}'; + if (_attempt == key) return; + _attempt = key; + unawaited(_prepare()); + } + + Future _prepare() async { + _preparing = true; + final generation = ++_generation; + _playGeneration = handler._playRequestGeneration; + _queueRevision = handler._sessionQueueRevision; + final index = handler._index; + final nextIndex = index + 1 < handler._media.length + ? index + 1 + : handler._repeatMode == AudioServiceRepeatMode.all + ? handler._repeatPassStart() + : -1; + PlaybackDeck? deck; + ContentUriPlaybackLease? lease; + try { + if (index < 0 || nextIndex < 0 || nextIndex == index) return; + final next = handler._media[nextIndex]; + // DSD needs the USB output, which the ordinary transition opens. + if (MusicPlayerHandler._requiresDsd(next)) return; + if (handler._dependencies.isAndroid && next.isContentUri) { + try { + lease = await PlatformBridge.openContentUriPlaybackLease(next.source); + } catch (error) { + _log.w('Gapless SAF lease unavailable: $error'); + } + if (!_current(generation)) return; + } + final path = lease?.path ?? await handler._resolveSource(next); + if (path == null || !_current(generation)) return; + final isCopy = next.isContentUri && lease == null; + if (isCopy) _pins.add(path); + String? artwork; + if (next.networkArtworkSource case final source?) { + try { + artwork = await handler._dependencies.resolveNetworkSource(source); + } catch (_) { + // Cover failure must not prevent audio playback. + } + if (!_current(generation)) return; + } + final volume = await handler._normalizationVolumeFor( + path, + cacheKey: next.isContentUri ? next.source : null, + displayName: lease?.displayName, + ); + if (!_current(generation)) return; + deck = handler._dependencies.createDeck( + 'music-gapless-$generation-${DateTime.now().microsecondsSinceEpoch}', + ); + handler._listenToPlayer(deck); + await deck.configureOutput(); + await deck.setVolume(volume); + if (!_current(generation)) return; + if (next.isNetwork || + const {'http', 'https'}.contains(Uri.tryParse(path)?.scheme)) { + await deck.setNetworkSource( + path, + arriving: handler._runtime.streamsArrivingFile(path), + ); + } else { + await deck.setFileSource(path); + } + if (!_current(generation)) return; + final duration = await deck.getDuration(); + if (!_current(generation)) return; + final chained = await handler._player.setNextDeck(deck); + if (!_current(generation)) { + if (chained) await handler._player.setNextDeck(null); + return; + } + _prepared = deck; + deck = null; + _next = next; + _nextIndex = nextIndex; + _nextPath = path; + _nextArtwork = artwork; + _nextDuration = duration != null && duration > Duration.zero + ? duration + : next.duration; + _nextVolume = volume; + _nextIsCopy = isCopy; + _log.d('Gapless prepared (${chained ? 'native' : 'on completion'})'); + } catch (error) { + _log.w('Gapless preparation skipped: $error'); + } finally { + if (lease != null) { + await PlatformBridge.closeContentUriPlaybackLease(lease.token); + } + if (deck != null) await handler._disposeDeck(deck); + if (generation == _generation) { + _preparing = false; + if (_prepared == null) _pins.clear(); + } + await handler._cleanupPendingResolvedPaths(); + } + } + + /// Makes the prepared song current as the current one completes. False + /// leaves the ordinary transition to the caller. + Future handoff() async { + final incoming = _prepared; + final next = _next; + if (incoming == null || next == null) return false; + if (!_current(_generation) || + _nextIndex >= handler._media.length || + !identical(handler._media[_nextIndex], next)) { + await cancel(); + return false; + } + final generation = _generation; + final playGeneration = handler._playRequestGeneration; + try { + // A natively chained deck already plays; this confirms its state. + await incoming.resume(); + } catch (error) { + _log.w('Gapless start failed: $error'); + if (generation == _generation) await cancel(); + return playGeneration != handler._playRequestGeneration; + } + // Another request (Next, a new queue) took over meanwhile. + if (generation != _generation) { + return playGeneration != handler._playRequestGeneration; + } + final outgoing = handler._player; + final path = _nextPath; + _prepared = null; + _next = null; + _pins.clear(); + handler._player = incoming; + // An index at or before the current one wraps to a new repeat-all pass. + final index = _nextIndex > handler._index + ? _nextIndex + : handler._beginRepeatPass(_nextIndex); + handler._index = index; + final current = ++handler._playRequestGeneration; + handler._serverDiedReloads = 0; + handler._playbackAutomation.cancelPendingActions(); + handler._recordPlayHistory(index); + handler._normalizationVolume = _nextVolume; + handler._activeResolvedPath = _nextIsCopy ? path : null; + handler._pendingRestorePosition = null; + handler._runtime.personalization.begin(_learningTrack(next)); + handler.mediaItem.add( + handler + ._toMediaItem( + next, + resolvedSource: _nextIsCopy ? path : null, + resolvedArtwork: _nextArtwork, + ) + .copyWith(duration: _nextDuration), + ); + handler._lastBroadcastPosition = Duration.zero; + handler._lastPositionBroadcastAt = null; + handler._broadcastPosition(Duration.zero, force: true); + handler._broadcastState(playerState: PlaybackDeckState.playing); + handler._lastPeriodicPersistAt = DateTime.now(); + unawaited(handler._persistSession(position: Duration.zero)); + if (!next.isNetwork) { + unawaited(handler._recoverEmbeddedArtwork(next, current)); + } + if (next.source.startsWith('network://')) { + unawaited(handler._loadNetworkMetadata(next, current)); + } + unawaited(handler._ensureDurationKnown(next, current)); + unawaited(handler._autoplay.fill()); + _log.d('Gapless transition'); + await handler._disposeDeck(outgoing); + await handler._cleanupPendingResolvedPaths(); + return true; + } + + Future cancel() async { + _generation++; + _preparing = false; + _attempt = null; + final prepared = _prepared; + _prepared = null; + _next = null; + _nextPath = null; + _nextArtwork = null; + _pins.clear(); + if (prepared == null) return; + try { + await handler._player.setNextDeck(null); + } catch (error) { + _log.w('Gapless unlink failed: $error'); + } + await handler._disposeDeck(prepared); + await handler._cleanupPendingResolvedPaths(); + } + + Future dispose() => cancel(); +} diff --git a/lib/services/music_player_service.dart b/lib/services/music_player_service.dart index d15901e7a..7396d295b 100644 --- a/lib/services/music_player_service.dart +++ b/lib/services/music_player_service.dart @@ -49,6 +49,7 @@ export 'playback_session_restore.dart'; part 'music_player_automix.dart'; part 'music_player_autoplay.dart'; +part 'music_player_gapless.dart'; final _log = AppLogger('MusicPlayer'); @@ -116,6 +117,7 @@ class MusicPlayerHandler extends BaseAudioHandler AppSettings get _settings => _runtime.settings; late PlaybackDeck _player; late final _MusicAutoMix _autoMix; + late final _MusicGapless _gapless = _MusicGapless(this); late final _MusicAutoplay _autoplay; late final MusicHaptics _haptics; bool _completing = false; @@ -198,6 +200,12 @@ class MusicPlayerHandler extends BaseAudioHandler previous.exclusiveOutput != settings.exclusiveOutput) { unawaited(_autoMix.cancel()); } + if (previous.gaplessPlayback != settings.gaplessPlayback || + previous.autoMix != settings.autoMix || + previous.usbBitPerfect != settings.usbBitPerfect || + previous.exclusiveOutput != settings.exclusiveOutput) { + unawaited(_gapless.cancel()); + } // USB changes apply at the next source boundary, without raising volume. if ((previous.playerMode == 'internal') != (settings.playerMode == 'internal') || @@ -239,7 +247,9 @@ class MusicPlayerHandler extends BaseAudioHandler copy: PlatformBridge.copyContentUriToTemp, isDisposed: () => _disposed, isPinned: (path) => - path == _activeResolvedPath || _autoMix.pinnedPaths.contains(path), + path == _activeResolvedPath || + _autoMix.pinnedPaths.contains(path) || + _gapless.pinnedPaths.contains(path), onResolveError: (error) => _log.e('Failed to resolve content URI for playback: $error'), onDeleteError: (error) => @@ -518,7 +528,7 @@ class MusicPlayerHandler extends BaseAudioHandler unawaited( _serializeSourceChange(() async { if (_disposed || generation != _playRequestGeneration) return; - await _autoMix.cancel(); + await _cancelTransitions(); if (_disposed || generation != _playRequestGeneration) return; await player.stop(); }).catchError((Object error) { @@ -555,6 +565,12 @@ class MusicPlayerHandler extends BaseAudioHandler return true; } + /// Drops a prepared AutoMix or gapless transition. + Future _cancelTransitions() async { + await _autoMix.cancel(); + await _gapless.cancel(); + } + Future _disposeDeck(PlaybackDeck player) async { final subscriptions = _playerSubscriptions.remove(player); if (subscriptions == null) return; @@ -907,6 +923,7 @@ class MusicPlayerHandler extends BaseAudioHandler if (!_sourceReady || _switchingGeneration != 0) return; _broadcastPosition(position); _autoMix.onPosition(position); + _gapless.onPosition(position); unawaited(_autoplay.fill()); if (_restoringSession || _player.state != PlaybackDeckState.playing || @@ -980,7 +997,7 @@ class MusicPlayerHandler extends BaseAudioHandler final normalizationGeneration = ++_normalizationGeneration; if (index < 0 || index >= _media.length) return; unawaited(() async { - await _autoMix.cancel(); + await _cancelTransitions(); if (generation != _playRequestGeneration || index != _index || index >= _media.length || @@ -1396,7 +1413,7 @@ class MusicPlayerHandler extends BaseAudioHandler ..clear() ..addAll(history); _markSessionQueueChanged(); - unawaited(_autoMix.cancel()); + unawaited(_cancelTransitions()); queue.add(List.unmodifiable(_queueItems)); _broadcastState(); unawaited(_persistSession(position: playbackState.value.position)); @@ -1439,7 +1456,7 @@ class MusicPlayerHandler extends BaseAudioHandler await _serializeSourceChange(() async { try { if (!_isCurrentPlayRequest(generation, media)) return; - await _autoMix.cancel(); + await _cancelTransitions(); if (!_isCurrentPlayRequest(generation, media)) return; // Retire the audible source before publishing another song's title. await _player.stop(); @@ -1463,6 +1480,12 @@ class MusicPlayerHandler extends BaseAudioHandler return operation; } + static bool _requiresDsd(PlayableMedia media) => + media.bitDepth == 1 || + const ['dsf', 'dff'].contains(media.format?.toLowerCase()) || + media.source.toLowerCase().endsWith('.dsf') || + media.source.toLowerCase().endsWith('.dff'); + Future _startResolvedSource( String path, int generation, @@ -1487,11 +1510,7 @@ class MusicPlayerHandler extends BaseAudioHandler allowFixedVolume: _settings.usbAllowFixedVolume, dapExclusive: _settings.dapExclusive, allowDop: _settings.usbDsdOverPcm, - requiresDsd: - media.bitDepth == 1 || - const ['dsf', 'dff'].contains(media.format?.toLowerCase()) || - media.source.toLowerCase().endsWith('.dsf') || - media.source.toLowerCase().endsWith('.dff'), + requiresDsd: _requiresDsd(media), ); } if (!_isCurrentPlayRequest(generation, media)) return; @@ -1839,6 +1858,8 @@ class MusicPlayerHandler extends BaseAudioHandler Future _handlePlayerComplete() async { if (_completing) return; if (_shouldIgnoreComplete) { + // A natively chained next song must not keep playing unseen. + unawaited(_gapless.cancel()); if (_userPaused || _interruptionActive) { _broadcastState(playerState: PlaybackDeckState.paused); } @@ -1848,6 +1869,7 @@ class MusicPlayerHandler extends BaseAudioHandler _completing = true; try { _runtime.personalization.finish(); + if (await _gapless.handoff()) return; await _onComplete(); } finally { _completing = false; @@ -1973,7 +1995,7 @@ class MusicPlayerHandler extends BaseAudioHandler _switchingGeneration = 0; _userPaused = true; await _player.cancelPreparation(); - await _autoMix.cancel(); + await _cancelTransitions(); await _serializeSourceChange(() async { if (generation != _playRequestGeneration || _disposed) return; await _player.pause(); @@ -1999,7 +2021,7 @@ class MusicPlayerHandler extends BaseAudioHandler Future setShuffleMode(AudioServiceShuffleMode shuffleMode) async { final generation = ++_shuffleRequestGeneration; final enabled = shuffleMode == AudioServiceShuffleMode.all; - await _autoMix.cancel(); + await _cancelTransitions(); if (generation != _shuffleRequestGeneration || _disposed || enabled == _shuffle) { @@ -2023,7 +2045,7 @@ class MusicPlayerHandler extends BaseAudioHandler @override Future setRepeatMode(AudioServiceRepeatMode repeatMode) async { - await _autoMix.cancel(); + await _cancelTransitions(); // Group repeat has no meaning for a flat queue; treat it as all. _repeatMode = repeatMode == AudioServiceRepeatMode.group ? AudioServiceRepeatMode.all @@ -2048,7 +2070,7 @@ class MusicPlayerHandler extends BaseAudioHandler _switchingGeneration = 0; _userPaused = true; await _player.cancelPreparation(); - await _autoMix.cancel(); + await _cancelTransitions(); await _serializeSourceChange(() => _stopSession(generation)); } @@ -2090,7 +2112,7 @@ class MusicPlayerHandler extends BaseAudioHandler @override Future skipToPrevious() async { - await _autoMix.cancel(); + await _cancelTransitions(); if (playbackState.value.position > const Duration(seconds: 3)) { await _player.seek(Duration.zero); _broadcastPosition(Duration.zero, force: true); @@ -2272,6 +2294,7 @@ class MusicPlayerHandler extends BaseAudioHandler await _player.cancelPreparation(); await _sourceChangeTail; await _autoMix.dispose(); + await _gapless.dispose(); _haptics.dispose(); for (final sub in _subscriptions) { await sub.cancel(); diff --git a/lib/services/playback_deck.dart b/lib/services/playback_deck.dart index 6c30f69f4..0dd8c7477 100644 --- a/lib/services/playback_deck.dart +++ b/lib/services/playback_deck.dart @@ -135,6 +135,13 @@ abstract interface class PlaybackDeck { Future seek(Duration position); Future stop(); + /// Has the engine start [next], a paused deck holding a loaded source, the + /// moment this deck's source ends, so the two songs join without a gap. + /// [resume] on [next] afterwards only confirms the state. Returns false + /// when the engine cannot chain these decks; [next] then waits for + /// [resume]. Null unlinks a deck set earlier. + Future setNextDeck(PlaybackDeck? next); + Future getCurrentPosition(); Future getDuration(); diff --git a/lib/utils/settings_search_catalog.dart b/lib/utils/settings_search_catalog.dart index a43af3fc1..7c5ca74a6 100644 --- a/lib/utils/settings_search_catalog.dart +++ b/lib/utils/settings_search_catalog.dart @@ -339,6 +339,12 @@ class SettingsSearchCatalog { subtitle: l10n.playbackOnHeadphonesConnectedDescription, keywords: const ['earphone', 'headphone', 'bluetooth', 'connect'], ), + SettingsSearchEntry( + icon: Icons.linear_scale, + title: l10n.gaplessPlayback, + subtitle: l10n.gaplessPlaybackDescription, + keywords: const ['gapless', 'gap', 'silence', 'transition', 'album'], + ), SettingsSearchEntry( icon: Icons.compare_arrows, title: 'AutoMix', diff --git a/test/exclusive_output_deck_test.dart b/test/exclusive_output_deck_test.dart index f6fa8e031..018c71711 100644 --- a/test/exclusive_output_deck_test.dart +++ b/test/exclusive_output_deck_test.dart @@ -76,6 +76,8 @@ class _Deck implements PlaybackDeck { state = PlaybackDeckState.stopped; } + @override + Future setNextDeck(PlaybackDeck? next) async => false; @override Future getCurrentPosition() async => position; @override diff --git a/test/music_player_gapless_test.dart b/test/music_player_gapless_test.dart new file mode 100644 index 000000000..c311cf835 --- /dev/null +++ b/test/music_player_gapless_test.dart @@ -0,0 +1,129 @@ +import 'package:audio_service/audio_service.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:mornye/models/settings.dart'; +import 'package:mornye/services/music_playback_deck.dart'; + +import 'support/music_player_automix_harness.dart'; + +const _tracks = testTracks; +const _until = waitUntil; + +Iterable get _gaplessDecks => + native.live.where((id) => id.startsWith('music-gapless-')); + +/// Plays [_tracks] from 45 of 60 seconds, inside the preparation lead. +Future _playNearTheEnd() async { + await handler.setQueueAndPlay(_tracks); + await _until(() => handler.mediaItem.value?.duration != null); + await handler.seek(const Duration(seconds: 45)); +} + +void main() { + setUpMusicPlayerHarness(); + tearDown(() => AudioplayersPlaybackDeck.debugChainsPlayers = null); + + test('Gapless playback is on by default and persists when turned off', () { + expect(const AppSettings().gaplessPlayback, isTrue); + expect(AppSettings.fromJson({}).gaplessPlayback, isTrue); + final off = const AppSettings().copyWith(gaplessPlayback: false); + expect(AppSettings.fromJson(off.toJson()).gaplessPlayback, isFalse); + }); + + test('the next song loads before the end and starts on completion', () async { + setGaplessEnabled(true); + await _playNearTheEnd(); + await _until(() => _gaplessDecks.length == 1); + final next = _gaplessDecks.single; + await _until(() => native.sources[next] == '/two.flac'); + expect(native.playing, {'music-player'}); + + await native.complete('music-player'); + await _until(() => handler.mediaItem.value?.id == 'two'); + expect(native.playing, {next}); + expect(native.live, {next}); + // The prepared deck played; nothing loaded the song again. + expect(native.calls.where((call) => call.$2 == 'setSourceUrl').length, 2); + expect(handler.playbackState.value.playing, isTrue); + expect(handler.queue.value.map((item) => item.id), ['one', 'two', 'three']); + }); + + test('chained players hand over natively', () async { + AudioplayersPlaybackDeck.debugChainsPlayers = true; + setGaplessEnabled(true); + await _playNearTheEnd(); + await _until(() => native.nextPlayers['music-player'] != null); + final next = native.nextPlayers['music-player']!; + expect(native.playing, {'music-player'}); + + await native.complete('music-player'); + await _until(() => handler.mediaItem.value?.id == 'two'); + expect(native.playing, {next}); + expect(native.live, {next}); + }); + + test('repeat all joins the last song to the first', () async { + setGaplessEnabled(true); + await handler.setRepeatMode(AudioServiceRepeatMode.all); + await handler.setQueueAndPlay(_tracks, initialIndex: 2); + await _until(() => handler.mediaItem.value?.duration != null); + await handler.seek(const Duration(seconds: 45)); + await _until(() => _gaplessDecks.length == 1); + final next = _gaplessDecks.single; + await _until(() => native.sources[next] == '/one.flac'); + + await native.complete('music-player'); + await _until(() => handler.mediaItem.value?.id == 'one'); + expect(native.playing, {next}); + }); + + test('a queue change drops the prepared song and its link', () async { + AudioplayersPlaybackDeck.debugChainsPlayers = true; + setGaplessEnabled(true); + await _playNearTheEnd(); + await _until(() => native.nextPlayers['music-player'] != null); + final next = native.nextPlayers['music-player']!; + + await handler.setRepeatMode(AudioServiceRepeatMode.one); + await _until(() => !native.live.contains(next)); + expect(native.nextPlayers, isEmpty); + + // Repeat one keeps the ordinary transition. + await native.complete('music-player'); + await _until( + () => + native.resumedSources + .where((source) => source == '/one.flac') + .length == + 2, + ); + expect(handler.mediaItem.value?.id, 'one'); + expect(_gaplessDecks, isEmpty); + }); + + test('turning gapless off drops the prepared song', () async { + setGaplessEnabled(true); + await _playNearTheEnd(); + await _until(() => _gaplessDecks.length == 1); + + setGaplessEnabled(false); + await _until(() => _gaplessDecks.isEmpty); + await native.complete('music-player'); + await _until(() => handler.mediaItem.value?.id == 'two'); + expect(native.sources['music-player'], '/two.flac'); + }); + + test('AutoMix replaces gapless playback', () async { + setGaplessEnabled(true); + setAutoMixEnabled(true); + await _playNearTheEnd(); + await Future.delayed(const Duration(milliseconds: 600)); + expect(_gaplessDecks, isEmpty); + }); + + test('a song far from its end does not load the next one', () async { + setGaplessEnabled(true); + await handler.setQueueAndPlay(_tracks); + await Future.delayed(const Duration(milliseconds: 600)); + expect(_gaplessDecks, isEmpty); + }); +} diff --git a/test/playback_automation_settings_test.dart b/test/playback_automation_settings_test.dart index 08285cd97..629416f38 100644 --- a/test/playback_automation_settings_test.dart +++ b/test/playback_automation_settings_test.dart @@ -102,5 +102,67 @@ void main() { isTrue, ); }); + + testWidgets('Gapless playback yields to AutoMix ($mornye)', (tester) async { + SharedPreferences.setMockInitialValues({}); + tester.view.physicalSize = const Size(390, 844); + tester.view.devicePixelRatio = 1; + addTearDown(tester.view.reset); + final container = ProviderContainer( + overrides: [ + initialSettingsProvider.overrideWithValue(const AppSettings()), + ], + ); + addTearDown(container.dispose); + await tester.pumpWidget( + UncontrolledProviderScope( + container: container, + child: MaterialApp( + theme: mornye + ? MornyeTheme.build(Brightness.dark, accent: MornyeAccent.blue) + : AppTheme.light(), + locale: const Locale('en'), + localizationsDelegates: AppLocalizations.localizationsDelegates, + supportedLocales: AppLocalizations.supportedLocales, + home: const PlaybackSettingsPage(), + ), + ), + ); + final gapless = find.text('Gapless playback'); + await tester.scrollUntilVisible( + gapless, + 200, + scrollable: find.byType(Scrollable).first, + ); + await tester.pumpAndSettle(); + SettingsSwitchItem item() => tester.widget( + find.byWidgetPredicate( + (widget) => + widget is SettingsSwitchItem && + widget.title == 'Gapless playback', + ), + ); + expect(item().value, isTrue); + await tester.tap(gapless); + await tester.pumpAndSettle(); + expect(container.read(settingsProvider).gaplessPlayback, isFalse); + + container.read(settingsProvider.notifier).setGaplessPlayback(true); + container.read(settingsProvider.notifier).setAutoMix(true); + await tester.pumpAndSettle(); + expect(item().enabled, isFalse); + expect(item().value, isFalse); + expect(tester.takeException(), isNull); + + final catalog = SettingsSearchCatalog( + AppLocalizations.of(tester.element(gapless)), + ); + expect( + catalog.playback.any( + (entry) => entry.matches(SettingsSearchQuery('gapless')), + ), + isTrue, + ); + }); } } diff --git a/test/preview_player_runtime_test.dart b/test/preview_player_runtime_test.dart index d9732bd84..022442395 100644 --- a/test/preview_player_runtime_test.dart +++ b/test/preview_player_runtime_test.dart @@ -219,6 +219,8 @@ class _PreviewDeck implements PlaybackDeck { @override Future stop() async => calls.add('stop'); @override + Future setNextDeck(PlaybackDeck? next) async => false; + @override Future getCurrentPosition() async => Duration.zero; @override Future getDuration() async => null; diff --git a/test/support/music_player_automix_harness.dart b/test/support/music_player_automix_harness.dart index e6a20ff99..0071c4996 100644 --- a/test/support/music_player_automix_harness.dart +++ b/test/support/music_player_automix_harness.dart @@ -103,8 +103,20 @@ class AudioNative { final rates = {}; final ignoredSeeks = {}; final missingPositions = {}; + final nextPlayers = {}; bool emitsDuration = true; + /// Ends [id]'s song the way the forks do: a chained next player starts + /// first, then completion is reported. + Future complete(String id) async { + final next = nextPlayers.remove(id); + if (next != null) { + playing.add(next); + resumedSources.add(sources[next]!); + } + await event(id, 'audio.onComplete'); + } + int currentPosition(String id) => (positions[id] ?? 0) + (stalled.contains(id) @@ -159,6 +171,13 @@ class AudioNative { clocks[id]?.reset(); } unawaited(event(id, 'audio.onSeekComplete')); + case 'setNextPlayer': + final next = args['nextPlayerId'] as String?; + if (next == null) { + nextPlayers.remove(id); + } else { + nextPlayers[id] = next; + } case 'setPlaybackRate': positions[id] = currentPosition(id); clocks[id]?.reset(); @@ -182,6 +201,7 @@ class AudioNative { playing.remove(id); clocks[id]?.stop(); case 'release': + nextPlayers.remove(id); releases[id] = (releases[id] ?? 0) + 1; playing.remove(id); sources.remove(id); @@ -287,6 +307,10 @@ void setAutoMixOptions(AutoMixOptions options) => musicPlayerRuntime.configure( ), ); +void setGaplessEnabled(bool enabled) => musicPlayerRuntime.configure( + musicPlayerRuntime.settings.copyWith(gaplessPlayback: enabled), +); + void setUsbBitPerfectEnabled(bool enabled) => musicPlayerRuntime.configure( musicPlayerRuntime.settings.copyWith(usbBitPerfect: enabled), ); @@ -321,6 +345,8 @@ void _setUpPlayer() { ); setAutoMixEnabled(false); setAutoMixOptions(const AutoMixOptions()); + // Gapless tests opt in; others keep the ordinary transition. + setGaplessEnabled(false); setUsbBitPerfectEnabled(false); setAutoplayEnabled(false); native = AudioNative(time.stopwatch)..install(); diff --git a/third_party/audioplayers_android/MORNYE_PATCHES.md b/third_party/audioplayers_android/MORNYE_PATCHES.md index a541ed8eb..60e9d0388 100644 --- a/third_party/audioplayers_android/MORNYE_PATCHES.md +++ b/third_party/audioplayers_android/MORNYE_PATCHES.md @@ -42,6 +42,16 @@ Dart caller is `lib/services/music_playback_deck.dart` in the app. relying on `setPlaybackParams` (or, before API 23, `setRate(1.0)`) to start output. +### Next player + +A `setNextPlayer` method with an optional `nextPlayerId` links two players +for gapless playback. `WrappedPlayer.setNext` requires both to hold a +prepared source and calls `MediaPlayer.setNextMediaPlayer`, so the platform +starts the next player as the current one completes. `onCompletion` then +marks the next player as playing before reporting completion, so a later +`resume` from Dart confirms its state without restarting it. A new source +or a release drops the link; no `nextPlayerId` unlinks it. + ### Error state `WrappedPlayer.onError` now marks the player as not prepared and not playing, diff --git a/third_party/audioplayers_android/README.md b/third_party/audioplayers_android/README.md index 6882cc4fc..b8bc158c7 100644 --- a/third_party/audioplayers_android/README.md +++ b/third_party/audioplayers_android/README.md @@ -28,6 +28,9 @@ bit-perfect paths bypass these effects. API reference: https://developer.android.com/reference/android/media/audiofx/DynamicsProcessing +A `setNextPlayer` method links a prepared player to start the moment another +completes, through `MediaPlayer.setNextMediaPlayer`, for gapless playback. + ## Usage This package is [endorsed](https://flutter.dev/docs/development/packages-and-plugins/developing-packages#endorsed-federated-plugin), diff --git a/third_party/audioplayers_android/android/src/main/kotlin/xyz/luan/audioplayers/AudioplayersPlugin.kt b/third_party/audioplayers_android/android/src/main/kotlin/xyz/luan/audioplayers/AudioplayersPlugin.kt index a200788ac..ef2578f32 100644 --- a/third_party/audioplayers_android/android/src/main/kotlin/xyz/luan/audioplayers/AudioplayersPlugin.kt +++ b/third_party/audioplayers_android/android/src/main/kotlin/xyz/luan/audioplayers/AudioplayersPlugin.kt @@ -139,6 +139,11 @@ class AudioplayersPlugin : FlutterPlugin { player.source = BytesSource(bytes) } + "setNextPlayer" -> { + val nextId = call.argument("nextPlayerId") + player.setNext(nextId?.let { getPlayer(it) }) + } + "resume" -> player.play() "pause" -> player.pause() "stop" -> player.stop() diff --git a/third_party/audioplayers_android/android/src/main/kotlin/xyz/luan/audioplayers/player/MediaPlayerWrapper.kt b/third_party/audioplayers_android/android/src/main/kotlin/xyz/luan/audioplayers/player/MediaPlayerWrapper.kt index 173f1e758..89028d7cf 100644 --- a/third_party/audioplayers_android/android/src/main/kotlin/xyz/luan/audioplayers/player/MediaPlayerWrapper.kt +++ b/third_party/audioplayers_android/android/src/main/kotlin/xyz/luan/audioplayers/player/MediaPlayerWrapper.kt @@ -30,6 +30,11 @@ class MediaPlayerWrapper( } } + /** MediaPlayer starts [next] the moment this player completes; null unlinks. */ + fun setNext(next: MediaPlayerWrapper?) { + mediaPlayer.setNextMediaPlayer(next?.mediaPlayer) + } + private fun createMediaPlayer(wrappedPlayer: WrappedPlayer): MediaPlayer { val mediaPlayer = MediaPlayer().apply { setOnPreparedListener { wrappedPlayer.onPrepared() } diff --git a/third_party/audioplayers_android/android/src/main/kotlin/xyz/luan/audioplayers/player/WrappedPlayer.kt b/third_party/audioplayers_android/android/src/main/kotlin/xyz/luan/audioplayers/player/WrappedPlayer.kt index 45882647c..48f265238 100644 --- a/third_party/audioplayers_android/android/src/main/kotlin/xyz/luan/audioplayers/player/WrappedPlayer.kt +++ b/third_party/audioplayers_android/android/src/main/kotlin/xyz/luan/audioplayers/player/WrappedPlayer.kt @@ -24,14 +24,46 @@ class WrappedPlayer internal constructor( ) { private var player: PlayerWrapper? = null + /** The player MediaPlayer starts the moment this one completes. */ + private var next: WrappedPlayer? = null + fun setEqualizer(configuration: Map) { val output = player as? MediaPlayerWrapper if (output != null) output.setEqualizer(configuration) } + /** + * Chains [player], prepared and paused, to start as this source ends, + * without a gap. Null unlinks it. + */ + fun setNext(player: WrappedPlayer?) { + val current = this.player as? MediaPlayerWrapper + if (player == null) { + next = null + if (!released && current != null) current.setNext(null) + return + } + check(!released && prepared && current != null) { "This player has no prepared source" } + val following = player.player as? MediaPlayerWrapper + check(!player.released && player.prepared && following != null) { + "The next player has no prepared source" + } + current.setNext(following) + next = player + } + + /** MediaPlayer started this player as the previous one completed. */ + private fun continueAfterPrevious() { + if (released || !prepared || playing) return + playing = true + requestFocusAndStart() + } + var source: Source? = null set(value) { if (field != value) { + // Resetting MediaPlayer drops its link to the next player. + next = null if (value != null) { val player = getOrCreatePlayer() player.setSource(value) @@ -304,6 +336,9 @@ class WrappedPlayer internal constructor( } fun onCompletion() { + val following = next + next = null + following?.continueAfterPrevious() if (releaseMode != ReleaseMode.LOOP) { stop() } diff --git a/third_party/audioplayers_darwin/MORNYE_PATCHES.md b/third_party/audioplayers_darwin/MORNYE_PATCHES.md index 4a293b2eb..115b5f543 100644 --- a/third_party/audioplayers_darwin/MORNYE_PATCHES.md +++ b/third_party/audioplayers_darwin/MORNYE_PATCHES.md @@ -74,6 +74,15 @@ cancelled preparation as a completed method call without a playback error. The `getDuration` branch returns after delivering its duration so the same method call cannot receive the default result a second time. +### Next player + +A `setNextPlayer` method with an optional `nextPlayerId` sets +`WrappedMediaPlayer.next` (weak) for gapless playback. Linking prerolls the +next player's loaded item. When the current item ends, the completion +handler resumes the next player before anything else, then reports +completion. Replacing or releasing the current item clears the link; no +`nextPlayerId` unlinks it. + ## Tests `tests/EqualizerDSPTests.swift` is a standalone `@main` program for the DSP. @@ -105,8 +114,9 @@ The same sources can be compiled with the iOS simulator SDK and run with `simctl spawn` to check the shared iOS implementation. `tests/SourceLifecycleTests.swift` uses a deferred AVPlayer for cancellation and -real generated WAV files for successful preparation, failed preparation and -stale completion delivery. It does not need an external music fixture: +real generated WAV files for successful preparation, failed preparation, +stale completion delivery and a linked next player starting on completion. +It does not need an external music fixture: ```bash cd third_party/audioplayers_darwin diff --git a/third_party/audioplayers_darwin/darwin/audioplayers_darwin/Sources/audioplayers_darwin/AudioplayersDarwinPlugin.swift b/third_party/audioplayers_darwin/darwin/audioplayers_darwin/Sources/audioplayers_darwin/AudioplayersDarwinPlugin.swift index 34d9ca18a..0a5aa9a60 100644 --- a/third_party/audioplayers_darwin/darwin/audioplayers_darwin/Sources/audioplayers_darwin/AudioplayersDarwinPlugin.swift +++ b/third_party/audioplayers_darwin/darwin/audioplayers_darwin/Sources/audioplayers_darwin/AudioplayersDarwinPlugin.swift @@ -221,6 +221,9 @@ public class AudioplayersDarwinPlugin: NSObject, FlutterPlugin { result(FlutterError(code: "DarwinAudioError", message: "Equalizer is unavailable for this source", details: error.localizedDescription)) return } + } else if method == "setNextPlayer" { + let nextId = args["nextPlayerId"] as? String + player.next = nextId.flatMap { self.getPlayer(playerId: $0) } } else if method == "pause" { player.pause() } else if method == "resume" { diff --git a/third_party/audioplayers_darwin/darwin/audioplayers_darwin/Sources/audioplayers_darwin/WrappedMediaPlayer.swift b/third_party/audioplayers_darwin/darwin/audioplayers_darwin/Sources/audioplayers_darwin/WrappedMediaPlayer.swift index 256dc10d3..a14175ad0 100644 --- a/third_party/audioplayers_darwin/darwin/audioplayers_darwin/Sources/audioplayers_darwin/WrappedMediaPlayer.swift +++ b/third_party/audioplayers_darwin/darwin/audioplayers_darwin/Sources/audioplayers_darwin/WrappedMediaPlayer.swift @@ -25,6 +25,12 @@ enum ReleaseMode: String { private(set) var isPlaying: Bool var releaseMode: ReleaseMode + /// Started the moment this player's item ends, without a gap. Cleared + /// with the item. + weak var next: WrappedMediaPlayer? { + didSet { next?.prerollForStart() } + } + private var reference: AudioplayersDarwinPlugin private var player: AVPlayer private var equalizer = EqualizerAudioTap() @@ -134,6 +140,18 @@ enum ReleaseMode: String { updateDuration() } + /// Fills the render pipeline of a paused, loaded item so a later + /// [resume] starts at once. + func prerollForStart() { + // preroll raises an exception unless the player itself is ready. + guard !isPlaying, player.rate == 0, player.status == .readyToPlay, + player.currentItem?.status == .readyToPlay + else { + return + } + player.preroll(atRate: Float(playbackRate)) { _ in } + } + func setVolume(volume: Double) { self.volume = volume player.volume = Float(volume) @@ -291,6 +309,7 @@ enum ReleaseMode: String { } private func reset() { + next = nil finishPlayerItemPreparation(.failure(CancellationError())) if let cObserver = completionObserver { NotificationCenter.default.removeObserver(cObserver.observer) @@ -313,6 +332,11 @@ enum ReleaseMode: String { private func onSoundComplete(_ playerItem: AVPlayerItem) async { guard isPlaying, player.currentItem === playerItem else { return } + // Start the next song before anything else, so it follows without a gap. + if let following = next { + next = nil + if !following.isPlaying { following.resume() } + } reference.controlAudioSession() eventHandler.onComplete() diff --git a/third_party/audioplayers_darwin/tests/SourceLifecycleTests.swift b/third_party/audioplayers_darwin/tests/SourceLifecycleTests.swift index f50c09a63..0ab94879b 100644 --- a/third_party/audioplayers_darwin/tests/SourceLifecycleTests.swift +++ b/third_party/audioplayers_darwin/tests/SourceLifecycleTests.swift @@ -116,6 +116,53 @@ final class DeferredPlayer: AVPlayer { await wrapper.dispose() } + @MainActor static func testNextPlayerStartsOnCompletion() async throws { + let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) + try FileManager.default.createDirectory(at: root, withIntermediateDirectories: false) + defer { try? FileManager.default.removeItem(at: root) } + let firstURL = root.appendingPathComponent("first.wav") + let secondURL = root.appendingPathComponent("second.wav") + try writeSilence(to: firstURL) + try writeSilence(to: secondURL) + + let plugin = AudioplayersDarwinPlugin() + func makePlayer() -> (WrappedMediaPlayer, AudioPlayersStreamHandler, AVPlayer) { + let native = AVPlayer() + native.isMuted = true + let events = AudioPlayersStreamHandler() + return ( + WrappedMediaPlayer(reference: plugin, eventHandler: events, player: native), events, native + ) + } + let (current, currentEvents, currentNative) = makePlayer() + let (following, followingEvents, _) = makePlayer() + try await current.setSourceUrl(url: firstURL.path, isLocal: true) + try await following.setSourceUrl(url: secondURL.path, isLocal: true) + current.next = following + guard current.next === following, !following.isPlaying else { + throw Failure.message("Linking started the next player") + } + + // A new source drops the link. + try await current.setSourceUrl(url: secondURL.path, isLocal: true) + guard current.next == nil else { + throw Failure.message("A new source kept the link to the next player") + } + try await current.setSourceUrl(url: firstURL.path, isLocal: true) + current.next = following + current.resume() + NotificationCenter.default.post( + name: .AVPlayerItemDidPlayToEndTime, object: currentNative.currentItem) + try await waitFor("The next player did not start as the current one completed") { + following.isPlaying && currentEvents.completedCount == 1 + } + guard current.next == nil, followingEvents.completedCount == 0 else { + throw Failure.message("Completion kept the link or completed the next player") + } + await current.dispose() + await following.dispose() + } + @MainActor static func main() async { do { let native = DeferredPlayer() @@ -144,6 +191,8 @@ final class DeferredPlayer: AVPlayer { print("PASS: replacing and disposing loading sources completes cancelled preparation") try await testNativePreparationAndStaleCompletion() print("PASS: native preparation succeeds or fails once, and ignores old completion events") + try await testNextPlayerStartsOnCompletion() + print("PASS: a linked next player starts as the current one completes") } catch { print("FAIL: \(error)") exit(1)