如何用audio_service显示安卓系统当前正在播放的音频？

dependencies:
  audio_service: ^0.18.0

import 'package:audio_service/audio_service.dart';

class AudioPlayerTask extends BackgroundAudioTask {
  // 实现音频播放逻辑
  // ...
}

import 'package:audio_service/audio_service.dart';

void main() {
  AudioServiceBackground.run(() => AudioPlayerTask());
}

import 'package:audio_service/audio_service.dart';
import 'package:audio_session/audio_session.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:just_audio/just_audio.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: const Text('Audio Service Example')),
        body: Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: <Widget>[
              RaisedButton(
                child: Text('Start Audio Service'),
                onPressed: () {
                  AudioService.start(
                    backgroundTaskEntrypoint: _audioPlayerTaskEntrypoint,
                    androidNotificationChannelName: 'Audio Service Demo',
                    androidNotificationColor: 0xFF2196f3,
                    androidNotificationIcon: 'mipmap/ic_launcher',
                    androidEnableQueue: true,
                  );
                },
              ),
              RaisedButton(
                child: Text('Stop Audio Service'),
                onPressed: () {
                  AudioService.stop();
                },
              ),
            ],
          ),
        ),
      ),
    );
  }
}

void _audioPlayerTaskEntrypoint() async {
  AudioServiceBackground.run(() => AudioPlayerTask());
}

class AudioPlayerTask extends BackgroundAudioTask {
  AudioPlayer _audioPlayer = AudioPlayer();
  AudioProcessingState _skipState;
  Seeker _seeker;

  @override
  Future<void> onStart(Map<String, dynamic> params) async {
    final session = await AudioSession.instance;
    await session.configure(AudioSessionConfiguration.speech());
    _seeker = Seeker(_audioPlayer);
    _audioPlayer.playbackEventStream.listen((event) {
      _broadcastState(event.processingState);
    });
    _audioPlayer.processingStateStream.listen((state) {
      _broadcastState(state);
    });
    _audioPlayer.playerStateStream.listen((state) {
      _broadcastState(_audioPlayer.processingState);
    });
    _audioPlayer.durationStream.listen((duration) {
      _broadcastState(_audioPlayer.processingState);
    });
    _audioPlayer.currentIndexStream.listen((index) {
      _broadcastState(_audioPlayer.processingState);
    });
    _audioPlayer.sequenceStateStream.listen((state) {
      _broadcastState(_audioPlayer.processingState);
    });
    _audioPlayer.bufferedPositionStream.listen((position) {
      _broadcastState(_audioPlayer.processingState);
    });
    _audioPlayer.positionStream.listen((position) {
      _broadcastState(_audioPlayer.processingState);
    });
    _audioPlayer.load(AudioSource.uri(Uri.parse('https://example.com/audio.mp3')));
    _audioPlayer.play();
    _broadcastState(_audioPlayer.processingState);
  }

  @override
  Future<void> onStop() async {
    _audioPlayer.dispose();
    await super.onStop();
  }

  @override
  Future<void> onPlay() => _audioPlayer.play();

  @override
  Future<void> onPause() => _audioPlayer.pause();

  @override
  Future<void> onSeekTo(Duration position) => _audioPlayer.seek(position);

  void _broadcastState(AudioProcessingState state) {
    AudioServiceBackground.setState(
      controls: [
        MediaControl.skipToPrevious,
        if (state == AudioProcessingState.playing) ...[
          MediaControl.pause,
          MediaControl.stop,
        ],
        if (state == AudioProcessingState.paused ||
            state == AudioProcessingState.completed) ...[
          MediaControl.play,
          MediaControl.stop,
        ],
        MediaControl.skipToNext,
      ],
      systemActions: const {
        MediaAction.seek,
      },
      processingState: state,
      playing: state != AudioProcessingState.none &&
          state != AudioProcessingState.connecting &&
          state != AudioProcessingState.buffering,
      position: _audioPlayer.position,
      bufferedPosition: _audioPlayer.bufferedPosition,
      speed: _audioPlayer.speed,
    );
  }
}

class Seeker {
  Seeker(this._player);

  final AudioPlayer _player;

  void forward() {
    final duration = _player.duration;
    final position = _player.position;
    if (duration != null && position != null) {
      final newPosition = position + const Duration(seconds: 10);
      if (newPosition < duration) {
        _player.seek(newPosition);
      }
    }
  }

  void backward() {
    final position = _player.position;
    if (position != null) {
      final newPosition = position - const Duration(seconds: 10);
      if (newPosition > Duration.zero) {
        _player.seek(newPosition);
      } else {
        _player.seek(Duration.zero);
      }
    }
  }
}