1
Future<void> _handlePlaybackCompleted() async {
2
  // Guard against duplicate completion notifications (can happen when
3
  // switching sources quickly) to avoid racing setAudioSource/play calls.
4
  if (_isHandlingCompletion) return;
5
  _isHandlingCompletion = true;
6
  try {
7
    if (_repeatMode == RepeatMode.one) {
8
      await seek(Duration.zero);
9
      await play();
10
    } else {
11
      await skipToNext();
12
    }
13
  } catch (e, st) {
14
    debugPrint('[AudioManager] _handlePlaybackCompleted error: $e');
15
    debugPrint('[AudioManager] _handlePlaybackCompleted stack: $st');
16
  } finally {
17
    _isHandlingCompletion = false;
18
  }
19
}

1
Future<void> playAtIndex(int index) async {
2
  if (index < 0 || index >= _playlist.length) return;
3

4
  // Cancel any ongoing fallback recovery for a previous track.
5
  _fallbackManager.cancelCurrentFallback();
6

7
  // Handle online playlist - need to resolve URL and create new audio source
8
  if (_isOnlinePlaylist && _onlineSongList != null && _urlResolver != null) {
9
    _onlineRecoveryShouldResumePlayback = true;
10
    final boardSong = _onlineSongList![index];
11
    if (_isSettingOnlinePlaylist) {
12
      final canceledToken = _onlinePlaylistSessionToken;
13
      _onlinePlaylistSessionToken++;
14
      _isSettingOnlinePlaylist = false;
15
      debugPrint(
16
          '[AudioManager][SWITCH] cancel pending online start token=$canceledToken by manual switch target=$index');
17
    }
18
    if (_isSwitchingOnlineTrack) {
19
      _queuedOnlineSwitchIndex = index;
20
      _pendingOnlineSwitchIndex = index;
21
      _updatePlaybackState();
22
      debugPrint(
23
          '[AudioManager][SWITCH] switching in progress, queue target index=$index queued=$_queuedOnlineSwitchIndex pending=$_pendingOnlineSwitchIndex current=$_currentIndex');
24
      return;
25
    }
26
    _isSwitchingOnlineTrack = true;
27
    _onlineTrackSwitchStartedAt = DateTime.now();
28
    _pendingOnlineSwitchIndex = index;
29
    _updatePlaybackState();
30
    final switchToken = ++_onlineSwitchToken;
31

32
    try {
33
      // ... resolve / cached source / network source / play
34

35
      if (switchToken != _onlineSwitchToken) {
36
        debugPrint(
37
            '[AudioManager][SWITCH] stale network switch ignored token=$switchToken latest=$_onlineSwitchToken index=$index');
38
        return;
39
      }
40

41
      _currentIndex = index;
42
      _updateNowPlayingMediaItem(mediaItems[index], force: true);
43
      _updatePlaybackState();
44
    } finally {
45
      if (switchToken == _onlineSwitchToken) {
46
        _isSwitchingOnlineTrack = false;
47
        _onlineTrackSwitchStartedAt = null;
48
        _pendingOnlineSwitchIndex = null;
49

50
        final queuedIndex = _queuedOnlineSwitchIndex;
51
        if (queuedIndex != null && queuedIndex != _currentIndex) {
52
          _queuedOnlineSwitchIndex = null;
53
          debugPrint(
54
              '[AudioManager][SWITCH] drain queued switch queued=$queuedIndex current=$_currentIndex token=$switchToken');
55
          unawaited(playAtIndex(queuedIndex));
56
        } else {
57
          _queuedOnlineSwitchIndex = null;
58
        }
59
      }
60
    }
61
  }
62
}

1
if (Platform.isIOS) {
2
  debugPrint(
3
      '[AudioManager] iOS: Full audio reset for background track switch');
4
  try {
5
    // Stop completely first
6
    await _player.stop();
7
    await Future<void>.delayed(const Duration(milliseconds: 50));
8

9
    // Re-activate audio session
10
    final session = await AudioSession.instance;
11
    await session.setActive(true);
12

13
    final fileUri = Uri.file(cachedAudio);
14
    final audioSource = _buildOnlineProgressiveSource(
15
      fileUri,
16
      song: updatedSong,
17
      duration: Duration(milliseconds: updatedSong.duration),
18
    );
19
    await _setOnlineSingleSourceForSwitch(
20
      audioSource,
21
      playlistIndex: index,
22
      reason: 'switch_ios_cached:index=$index',
23
    );
24
    debugPrint(
25
        '[AudioManager][SWITCH] iOS cached source set ok index=$index');
26

27
    final playFuture = _player.play();
28
    unawaited(playFuture.then((_) {
29
      debugPrint(
30
          '[AudioManager][SWITCH] iOS cached play completed token=$switchToken index=$index');
31
    }).catchError((Object e, StackTrace st) {
32
      debugPrint(
33
          '[AudioManager][SWITCH] iOS cached play failed token=$switchToken index=$index error=$e');
34
    }));
35
    debugPrint(
36
        '[AudioManager][SWITCH] iOS cached play requested token=$switchToken index=$index');
37
    if (switchToken != _onlineSwitchToken) {
38
      debugPrint(
39
          '[AudioManager][SWITCH] stale iOS cached switch ignored token=$switchToken latest=$_onlineSwitchToken index=$index');
40
      return;
41
    }
42
  } catch (e) {
43
    debugPrint(
44
        '[AudioManager][SWITCH] iOS background audio reset failed index=$index error=$e');
45
    rethrow;
46
  }
47
}

1
final sessionToken = ++_onlinePlaylistSessionToken;
2

3
await _player.setAudioSource(
4
  _onlineConcatenatingSource!,
5
  initialIndex: 0,
6
);
7
if (sessionToken != _onlinePlaylistSessionToken) {
8
  debugPrint(
9
      '[AudioManager][ONLINE_START] stale after setAudioSource token=$sessionToken latest=$_onlinePlaylistSessionToken ignored');
10
  return;
11
}
12

13
_updateNowPlayingMediaItem(mediaItems[_currentIndex], force: true);
14
_updatePlaybackState();
15
if (autoPlay) {
16
  await play();
17
  if (sessionToken != _onlinePlaylistSessionToken) {
18
    debugPrint(
19
        '[AudioManager][ONLINE_START] stale after play token=$sessionToken latest=$_onlinePlaylistSessionToken ignored');
20
    return;
21
  }
22
}