1
@override
2
Future<void> click([MediaButton button = MediaButton.media]) async {
3
  switch (button) {
4
    case MediaButton.media:
5
      if (_player.playing) {
6
        await pause();
7
      } else {
8
        await play();
9
      }
10
      break;
11
    case MediaButton.next:
12
      await skipToNext();
13
      break;
14
    case MediaButton.previous:
15
      await skipToPrevious();
16
      break;
17
  }
18
}

1
void _dispatchPlayerPlay(String reason) {
2
  _logNotificationDebug('play() dispatch reason=$reason');
3
  final startedAt = DateTime.now();
4
  unawaited(
5
    _player.play().then((_) {
6
      final elapsedMs = DateTime.now().difference(startedAt).inMilliseconds;
7
      _logNotificationDebug(
8
        'play() future resolved reason=$reason elapsed=${elapsedMs}ms',
9
      );
10
    }).catchError((Object e, StackTrace st) {
11
      debugPrint('[AudioManager] play() failed reason=$reason: $e');
12
    }),
13
  );
14
  unawaited(Future<void>.delayed(const Duration(milliseconds: 180), () {
15
    _logNotificationDebug('play() post-check reason=$reason');
16
  }));
17
}

1
@override
2
Future<void> play() async {
3
  await _ensureAudioSessionConfigured();
4
  final session = await AudioSession.instance;
5
  await session.setActive(true);
6

7
  if (_player.playing) return;
8

9
  final processing = _player.processingState;
10
  if (processing == ProcessingState.completed) {
11
    await _player.seek(Duration.zero);
12
    _dispatchPlayerPlay('completed_seek0');
13
    return;
14
  }
15

16
  if (processing == ProcessingState.idle) {
17
    if (_isOnlinePlaylist) {
18
      await _recoverOnlinePlayback('play_from_idle');
19
      return;
20
    }
21
    if (_concatenatingSource != null && _playlist.isNotEmpty) {
22
      final targetIndex = _currentIndex.clamp(0, _playlist.length - 1);
23
      _currentIndex = targetIndex;
24
      await _player.setAudioSource(_concatenatingSource!, initialIndex: targetIndex);
25
      _dispatchPlayerPlay('idle_local_reset');
26
      return;
27
    }
28
  }
29

30
  _dispatchPlayerPlay('primary');
31
}

1
bool _ensureManagedIndexForExternalResume(String source) {
2
  if (_playlist.isEmpty) return false;
3
  if (_currentIndex >= 0 && _currentIndex < _playlist.length) return true;
4

5
  int? recoveredIndex;
6
  if (_isOnlinePlaylist) {
7
    final playerIndex = _player.currentIndex;
8
    if (playerIndex != null &&
9
        playerIndex >= 0 &&
10
        playerIndex < _onlinePlayerToPlaylistIndex.length) {
11
      final mappedIndex = _onlinePlayerToPlaylistIndex[playerIndex];
12
      if (mappedIndex >= 0 && mappedIndex < _playlist.length) {
13
        recoveredIndex = mappedIndex;
14
      }
15
    }
16
  }
17

18
  recoveredIndex ??= _player.currentIndex;
19
  recoveredIndex = (recoveredIndex == null || recoveredIndex < 0 || recoveredIndex >= _playlist.length)
20
      ? 0
21
      : recoveredIndex;
22

23
  _currentIndex = recoveredIndex;
24
  _updatePlaybackState();
25
  return true;
26
}