Flutter 在flatter中，如何使用音频服务获取动态数据

这是我调用AudioService.start的代码段，但我无法启动该服务。 我正在从firebase获取音频项，并希望将这些项作为列表视图加载到audio_服务。但我无法执行此操作。我在类中定义了扩展后台服务的音频服务

 await AudioService.start(
      backgroundTaskEntrypoint: _audioPlayerTaskEntrypoint,
      androidNotificationChannelName: 'Audio Player',
      androidNotificationColor: 0xFF2196f3,
      androidNotificationIcon: 'mipmap/ic_launcher',
      params: getParams(),
    );

导入“package:audio_service/audio_service.dart”；
导入“包：just_audio/just_audio.dart”；
MediaControl播放控制=MediaControl(
androidIcon:“可绘制/ic_动作_播放_箭头”，
标签：“播放”，
动作：MediaAction.play，
);
MediaControl pauseControl=MediaControl(
androidIcon:“可拖动/ic_动作_暂停”，
标签：“暂停”，
动作：MediaAction.pause，
);
MediaControl skipToNextControl=MediaControl(
androidIcon:“可绘制/ic_操作_跳过_下一步”，
标签：“下一个”，
操作：MediaAction.skipToNext，
);
MediaControl skipToPreviousControl=MediaControl(
Androidcon:“可绘制/ic_操作_跳过_上一个”，
标签：'先前'，
操作：MediaAction.skipToPrevious，
);
MediaControl停止控制=MediaControl(
androidIcon:“可牵引/集成电路动作停止”，
标签：“停止”，
动作：MediaAction.stop，
);
类AudioPlayerTask扩展了BackgroundAudioTask{
//
var_queue=[]；
int _queueIndex=-1；
AudioPlayer_AudioPlayer=新的AudioPlayer（）；
音频处理状态_skipState；
布卢玩；
bool get hasNext=>\u queueIndex+1<\u queue.length；
bool get hasPrevious=>\u queueIndex>0；
MediaItem获取MediaItem=>\u队列[\u队列索引]；
StreamSubscription _playerStateSubscription；
StreamSubscription\u eventSubscription；
@凌驾
void onStart（映射参数）{
打印（“---------------------------------------开始”）；
_queue.clear（）；
列表mediatems=params['data']；
对于（int i=0；istate==AudioPlaybackState.completed）
.听（（陈述）{
_handlePlaybackCompleted（）；
});
_eventSubscription=\u audioPlayer.playbackEventStream.listen（（事件）{
最终缓冲状态=
event.buffering？AudioProcessingState.buffering:空；
开关（事件状态）{
案例AudioPlaybackState.paused：
_设定状态(
processingState:bufferingState？？AudioProcessingState.ready，
位置：事件位置）；
打破
case AudioPlaybackState.playing：
_设定状态(
processingState:bufferingState？？AudioProcessingState.ready，
位置：事件位置）；
打破
case AudioPlaybackState.connecting：
_设定状态(
processingState:_skipState？？Audio processingState.connecting，
位置：事件位置）；
打破
违约：
}
});
AudioServiceBackground.setQueue（_queue）；
onSkipToNext（）；
}
@凌驾
void onPlay（）{
如果（_skipState==null）{
_玩=真；
_audioPlayer.play（）；
}
}
@凌驾
void onPause（）{
_玩=假；
_audioPlayer.pause（）；
}
@凌驾
void onSkipToNext（）异步{
跳过（1）；
}
@凌驾
void onSkipToPrevious（）{
跳过（-1）；
}
无效跳过（整数偏移）异步{
int newPos=_queueIndex+offset；
如果（！（newPos>=0&&newPos<\u queue.length））{
返回；
}
如果（空==\u播放）{
_玩=真；
}否则，如果（正在播放）{
等待音频播放器。停止（）；
}
_queueIndex=newPos；
_skipState=偏移量>0
？音频处理state.skippingToNext
：AudioProcessingState.skippingToPrevious；
AudioServiceBackground.setMediaItem（mediaItem）；
wait_audioPlayer.setUrl（mediateItem.id）；
打印（mediaItem.id）；
_skipState=null；
如果（正在播放）{
onPlay（）；
}否则{
_setState（processingState:AudioProcessingState.ready）；
}
}
@凌驾
Future onStop（）异步{
_玩=假；
等待音频播放器。停止（）；
等待_audioPlayer.dispose（）；
_playerStateSubscription.cancel（）；
_eventSubscription.cancel（）；
return wait super.onStop（）；
}
@凌驾
SEEKTO无效（持续时间位置）{
_音频播放器。搜索（位置）；
}
@凌驾
void onClick（媒体按钮）{
播放暂停（）；
}
@凌驾
Future onFastForward（）异步{
wait_seekRelative（快进间隔）；
}
@凌驾
Future onRewind（）异步{
等待(倒带区间);；
}
未来相对（持续时间偏移）异步{
var newPosition=_audioPlayer.playbackEvent.position+偏移量；
if（新位置<持续时间0）{
newPosition=Duration.0；
}
if（newPosition>mediaItem.duration）{
newPosition=mediaItem.duration；
}
wait_audioPlayer.seek（_audioPlayer.playbackEvent.position+offset）；
}
_handlePlaybackCompleted（）{
如果（下一步）{
onSkipToNext（）；
}否则{
顶部（）；
}
}
无效播放暂停（）{
if（AudioServiceBackground.state.playing）
onPause（）；
其他的
onPlay（）；
}
未来状态({
音频处理状态处理状态，
持续时间位置，
持续时间缓冲位置，
})异步的{
打印（“设置状态$processingState”）；
如果（位置==null）{
position=\u audioPlayer.playbackEvent.position；
}
等待AudioServiceBackground.setState(
控件：getControls（），
systemActions:[MediaAction.seekTo]，
处理状态：
processingState？？AudioServiceBackground.state.processingState，
玩：(你玩)，
职位:职位,，
缓冲位置：缓冲位置？？位置，
速度：_audioPlayer.speed，
);
}
列表getControls（）{
如果（正在播放）{
返回[
技巧控制，
pauseControl，
停止控制，
skipToNextControl
];
}否则{
返回[
sk

import 'package:audio_service/audio_service.dart';
import 'package:just_audio/just_audio.dart';

MediaControl playControl = MediaControl(
  androidIcon: 'drawable/ic_action_play_arrow',
  label: 'Play',
  action: MediaAction.play,
);
MediaControl pauseControl = MediaControl(
  androidIcon: 'drawable/ic_action_pause',
  label: 'Pause',
  action: MediaAction.pause,
);
MediaControl skipToNextControl = MediaControl(
  androidIcon: 'drawable/ic_action_skip_next',
  label: 'Next',
  action: MediaAction.skipToNext,
);
MediaControl skipToPreviousControl = MediaControl(
  androidIcon: 'drawable/ic_action_skip_previous',
  label: 'Previous',
  action: MediaAction.skipToPrevious,
);
MediaControl stopControl = MediaControl(
  androidIcon: 'drawable/ic_action_stop',
  label: 'Stop',
  action: MediaAction.stop,
);

class AudioPlayerTask extends BackgroundAudioTask {
  //
  var _queue = <MediaItem>[];

  int _queueIndex = -1;

  AudioPlayer _audioPlayer = new AudioPlayer();
  AudioProcessingState _skipState;
  bool _playing;

  bool get hasNext => _queueIndex + 1 < _queue.length;

  bool get hasPrevious => _queueIndex > 0;

  MediaItem get mediaItem => _queue[_queueIndex];

  StreamSubscription<AudioPlaybackState> _playerStateSubscription;
  StreamSubscription<AudioPlaybackEvent> _eventSubscription;

  @override
  void onStart(Map<String, dynamic> params) {
    print("-------------------------------------started");
    _queue.clear();
    List mediaItems = params['data'];
    for (int i = 0; i < mediaItems.length; i++) {
      MediaItem mediaItem = MediaItem.fromJson(mediaItems[i]);
      _queue.add(mediaItem);
    }
    _playerStateSubscription = _audioPlayer.playbackStateStream
        .where((state) => state == AudioPlaybackState.completed)
        .listen((state) {
      _handlePlaybackCompleted();
    });
    _eventSubscription = _audioPlayer.playbackEventStream.listen((event) {
      final bufferingState =
      event.buffering ? AudioProcessingState.buffering : null;
      switch (event.state) {
        case AudioPlaybackState.paused:
          _setState(
              processingState: bufferingState ?? AudioProcessingState.ready,
              position: event.position);
          break;
        case AudioPlaybackState.playing:
          _setState(
              processingState: bufferingState ?? AudioProcessingState.ready,
              position: event.position);
          break;
        case AudioPlaybackState.connecting:
          _setState(
              processingState: _skipState ?? AudioProcessingState.connecting,
              position: event.position);
          break;
        default:
      }
    });
    AudioServiceBackground.setQueue(_queue);
    onSkipToNext();
  }

  @override
  void onPlay() {
    if (_skipState == null) {
      _playing = true;
      _audioPlayer.play();
    }
  }

  @override
  void onPause() {
    _playing = false;
    _audioPlayer.pause();
  }

  @override
  void onSkipToNext() async {
    skip(1);
  }

  @override
  void onSkipToPrevious() {
    skip(-1);
  }

  void skip(int offset) async {
    int newPos = _queueIndex + offset;
    if (!(newPos >= 0 && newPos < _queue.length)) {
      return;
    }
    if (null == _playing) {
      _playing = true;
    } else if (_playing) {
      await _audioPlayer.stop();
    }
    _queueIndex = newPos;
    _skipState = offset > 0
        ? AudioProcessingState.skippingToNext
        : AudioProcessingState.skippingToPrevious;
    AudioServiceBackground.setMediaItem(mediaItem);
    await _audioPlayer.setUrl(mediaItem.id);
    print(mediaItem.id);
    _skipState = null;
    if (_playing) {
      onPlay();
    } else {
      _setState(processingState: AudioProcessingState.ready);
    }
  }

  @override
  Future<void> onStop() async {
    _playing = false;
    await _audioPlayer.stop();
    await _audioPlayer.dispose();
    _playerStateSubscription.cancel();
    _eventSubscription.cancel();
    return await super.onStop();
  }

  @override
  void onSeekTo(Duration position) {
    _audioPlayer.seek(position);
  }

  @override
  void onClick(MediaButton button) {
    playPause();
  }

  @override
  Future<void> onFastForward() async {
    await _seekRelative(fastForwardInterval);
  }

  @override
  Future<void> onRewind() async {
    await _seekRelative(rewindInterval);
  }

  Future<void> _seekRelative(Duration offset) async {
    var newPosition = _audioPlayer.playbackEvent.position + offset;
    if (newPosition < Duration.zero) {
      newPosition = Duration.zero;
    }
    if (newPosition > mediaItem.duration) {
      newPosition = mediaItem.duration;
    }
    await _audioPlayer.seek(_audioPlayer.playbackEvent.position + offset);
  }

  _handlePlaybackCompleted() {
    if (hasNext) {
      onSkipToNext();
    } else {
      onStop();
    }
  }

  void playPause() {
    if (AudioServiceBackground.state.playing)
      onPause();
    else
      onPlay();
  }

  Future<void> _setState({
    AudioProcessingState processingState,
    Duration position,
    Duration bufferedPosition,
  }) async {
    print('SetState $processingState');
    if (position == null) {
      position = _audioPlayer.playbackEvent.position;
    }
    await AudioServiceBackground.setState(
      controls: getControls(),
      systemActions: [MediaAction.seekTo],
      processingState:
      processingState ?? AudioServiceBackground.state.processingState,
      playing: _playing,
      position: position,
      bufferedPosition: bufferedPosition ?? position,
      speed: _audioPlayer.speed,
    );
  }

  List<MediaControl> getControls() {
    if (_playing) {
      return [
        skipToPreviousControl,
        pauseControl,
        stopControl,
        skipToNextControl
      ];
    } else {
      return [
        skipToPreviousControl,
        playControl,
        stopControl,
        skipToNextControl
      ];
    }
  } this is my class
}

class AudioState {
  final List<MediaItem> queue;
  final MediaItem mediaItem;
  final PlaybackState playbackState;

  AudioState(this.queue, this.mediaItem, this.playbackState);
}





  @override
  // ignore: missing_return
  Future<Function> onAddQueueItem(MediaItem mediaItem) async{
    // queue.add(mediaItem); or somthing like this to update your queue
    await AudioServiceBackground.setQueue(queue);
    try {
      await _player.load(ConcatenatingAudioSource(
        children:
        queue.map((item) => AudioSource.uri(Uri.parse(item.id))).toList(),
      ));
      // In this example, we automatically start playing on start.
      onPlay();
    } catch (e) {
      print("Error: $e");
      onStop();
    }
  }

await AudioService.start(
                        backgroundTaskEntrypoint: audioPlayerTaskEntrypoint,
                        androidNotificationChannelName:
                            'Audio Service Demo',
                        // Enable this if you want the Android service to exit the foreground state on pause.
                        //androidStopForegroundOnPause: true,
                        androidNotificationColor: 0xFF2196f3,
                        androidNotificationIcon: 'mipmap/ic_launcher',
                        androidEnableQueue: true,
                      );
// call this func:
await AudioService.addQueueItem(m);