Flutter 颤振上的音频播放器：我能'；不要一个接一个地播放mp3

我已经找了好几天的解决方案，但都找不到。我需要用音频播放器一个接一个地播放mp3文件，这对我来说是不可能的。我使用的是唯一的工具（据我所知），它为您提供了做这类事情的库，但我找不到如何做。谢谢你的帮助

playLocal(List list) async {

list.forEach((f) async {
  final file = new File('${(await getTemporaryDirectory()).path}/voice.mp3');
  await file.writeAsBytes((await loadAsset(f)).buffer.asUint8List());
  bool finish = false;

  if (player.state == null || player.state == AudioPlayerState.COMPLETED) {
    await player.play(file.path, isLocal:true);
  }

  if (player.state != null && player.state != AudioPlayerState.COMPLETED) {
    while(!finish){
      player.onPlayerCompletion.listen((event){
        finish = true;
      });
      if (finish) {await player.play(file.path, isLocal:true);}
    }
  }

});

}

您可以使用软件包
在

assetsAudioPlayer.finished.中收听
调用
\u next（）

代码片段

void _next() {
    if (_assetsAudioPlayer.playlist != null) {
      _assetsAudioPlayer.playlistNext();
    } else {
      _currentAssetPosition++;
      _open(_currentAssetPosition);
    }
  }   
@override
      void initState() {
        super.initState();
        _assetsAudioPlayer.finished.listen((finished) {
          print("paly next");
          _next();
        });
      }

在
song1.mp3
完成自动播放
song2.mp3


完整代码

import 'package:assets_audio_player/assets_audio_player.dart';
import 'package:assets_audio_player_example/asset_audio_player_icons.dart';
import 'package:flutter/material.dart';

void main() => runApp(MyApp());

class MyApp extends StatefulWidget {
  @override
  _MyAppState createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  final assets = <String>[
    "assets/audios/song1.mp3",
    "assets/audios/song2.mp3",
    "assets/audios/song3.mp3",
  ];
  final AssetsAudioPlayer _assetsAudioPlayer = AssetsAudioPlayer();

  var _currentAssetPosition = -1;

  void _open(int assetIndex) {
    _currentAssetPosition = assetIndex % assets.length;
    _assetsAudioPlayer.open(assets[_currentAssetPosition]);
  }

  void _playPause() {
    _assetsAudioPlayer.playOrPause();
  }

  void _next() {
    if (_assetsAudioPlayer.playlist != null) {
      _assetsAudioPlayer.playlistNext();
    } else {
      _currentAssetPosition++;
      _open(_currentAssetPosition);
    }
  }

  void _prev() {
    if (_assetsAudioPlayer.playlist != null) {
      _assetsAudioPlayer.playlistPrevious();
    } else {
      _currentAssetPosition--;
      _open(_currentAssetPosition);
    }
  }

  @override
  void initState() {
    super.initState();
    _assetsAudioPlayer.finished.listen((finished) {
      print("paly next");
      _next();
    });
  }

  @override
  void dispose() {
    _assetsAudioPlayer.stop();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: const Text('Plugin example app'),
        ),
        body: Padding(
          padding: const EdgeInsets.only(bottom: 48.0),
          child: Column(
            mainAxisSize: MainAxisSize.max,
            crossAxisAlignment: CrossAxisAlignment.stretch,
            children: <Widget>[
              RaisedButton(
                onPressed: () {
                  _assetsAudioPlayer
                      .openPlaylist(Playlist(assetAudioPaths: this.assets));
                },
                child: Text("Playlist test"),
              ),
              Expanded(
                child: StreamBuilder(
                  stream: _assetsAudioPlayer.current,
                  initialData: const PlayingAudio(),
                  builder: (BuildContext context,
                      AsyncSnapshot<PlayingAudio> snapshot) {
                    final PlayingAudio currentAudio = snapshot.data;
                    return ListView.builder(
                      itemBuilder: (context, position) {
                        return ListTile(
                            title: Text(assets[position].split("/").last,
                                style: TextStyle(
                                    color: assets[position] ==
                                            currentAudio.assetAudioPath
                                        ? Colors.blue
                                        : Colors.black)),
                            onTap: () {
                              _open(position);
                            });
                      },
                      itemCount: assets.length,
                    );
                  },
                ),
              ),
              Row(
                mainAxisAlignment: MainAxisAlignment.center,
                mainAxisSize: MainAxisSize.max,
                children: <Widget>[
                  StreamBuilder(
                    stream: _assetsAudioPlayer.isLooping,
                    initialData: false,
                    builder:
                        (BuildContext context, AsyncSnapshot<bool> snapshot) {
                      return RaisedButton(
                        child: Text(snapshot.data ? "Looping" : "Not looping"),
                        onPressed: () {
                          _assetsAudioPlayer.toggleLoop();
                        },
                      );
                    },
                  ),
                  SizedBox(width: 20),
                  RaisedButton(
                    child: Text("Seek to 2:00"),
                    onPressed: () {
                      _assetsAudioPlayer.seek(Duration(minutes: 2));
                    },
                  ),
                ],
              ),
              Row(
                mainAxisAlignment: MainAxisAlignment.center,
                children: <Widget>[
                  StreamBuilder(
                    stream: _assetsAudioPlayer.currentPosition,
                    initialData: const Duration(),
                    builder: (BuildContext context,
                        AsyncSnapshot<Duration> snapshot) {
                      Duration duration = snapshot.data;
                      return Text(durationToString(duration));
                    },
                  ),
                  Text(" - "),
                  StreamBuilder(
                    stream: _assetsAudioPlayer.current,
                    builder: (BuildContext context,
                        AsyncSnapshot<PlayingAudio> snapshot) {
                      Duration duration = Duration();
                      if (snapshot.hasData) {
                        duration = snapshot.data.duration;
                      }
                      return Text(durationToString(duration));
                    },
                  ),
                ],
              ),
              Row(
                mainAxisAlignment: MainAxisAlignment.center,
                mainAxisSize: MainAxisSize.max,
                children: [
                  IconButton(
                    onPressed: _prev,
                    icon: Icon(AssetAudioPlayerIcons.to_start),
                  ),
                  StreamBuilder(
                    stream: _assetsAudioPlayer.isPlaying,
                    initialData: false,
                    builder:
                        (BuildContext context, AsyncSnapshot<bool> snapshot) {
                      return IconButton(
                        onPressed: _playPause,
                        icon: Icon(snapshot.data
                            ? AssetAudioPlayerIcons.pause
                            : AssetAudioPlayerIcons.play),
                      );
                    },
                  ),
                  IconButton(
                    icon: Icon(AssetAudioPlayerIcons.to_end),
                    onPressed: _next,
                  ),
                ],
              ),
            ],
          ),
        ),
      ),
    );
  }
}

String durationToString(Duration duration) {
  String twoDigits(int n) {
    if (n >= 10) return "$n";
    return "0$n";
  }

  String twoDigitMinutes =
      twoDigits(duration.inMinutes.remainder(Duration.minutesPerHour));
  String twoDigitSeconds =
      twoDigits(duration.inSeconds.remainder(Duration.secondsPerMinute));
  return "$twoDigitMinutes:$twoDigitSeconds";
}

import'package:assets_audio_player/assets_audio_player.dart'；
导入“package:assets\u audio\u player\u示例/assets\u audio\u player\u icons.dart”；
进口“包装：颤振/材料.省道”；
void main（）=>runApp（MyApp（））；
类MyApp扩展了StatefulWidget{
@凌驾
_MyAppState createState（）=>\u MyAppState（）；
}
类MyAppState扩展了状态{
最终资产=[
“资产/音频/歌曲1.mp3”，
“资产/音频/歌曲2.mp3”，
“资产/音频/歌曲3.mp3”，
];
最终AssetsAudioPlayer _AssetsAudioPlayer=AssetsAudioPlayer（）；
var _currentAssetPosition=-1；
空开（内部资产索引）{
_currentAssetPosition=assetIndex%assets.length；
_打开（资产[_currentAssetPosition]）；
}
void_playPause（）{
_assetsAudioPlayer.playOrPause（）；
}
void_next（）{
如果（_assetsAudioPlayer.playlist！=null）{
_AssetAudioPlayer.playlingNext（）；
}否则{
_currentAssetPosition++；
_打开（_currentAssetPosition）；
}
}
void_prev（）{
如果（_assetsAudioPlayer.playlist！=null）{
_AssetAudioPlayer.playlipPrevious（）；
}否则{
_当前资产位置--；
_打开（_currentAssetPosition）；
}
}
@凌驾
void initState（）{
super.initState（）；
_AssetAudioPlayer.finished.listen（（完成）{
打印（“下一页”）；
_next（）；
});
}
@凌驾
无效处置（）{
_assetsAudioPlayer.stop（）；
super.dispose（）；
}
@凌驾
小部件构建（构建上下文）{
返回材料PP(
家：脚手架(
appBar:appBar(
标题：const Text（“插件示例应用程序”），
),
主体：填充物(
填充：仅限常量边集（底部：48.0），
子：列(
mainAxisSize:mainAxisSize.max，
crossAxisAlignment:crossAxisAlignment.stretch，
儿童：[
升起的按钮(
已按下：（）{
_资产音频层
.openPlaylist（Playlist（assetudiopath:this.assets））；
},
子项：文本（“播放列表测试”），
),
扩大(
孩子：StreamBuilder(
流：_assetsAudioPlayer.current，
initialData:const PlayingAudio（），
生成器：（BuildContext上下文，
异步快照（快照）{
最终播放音频currentAudio=snapshot.data；
返回ListView.builder(
itemBuilder：（上下文、位置）{
返回列表块(
标题：文本（资产[位置]）。拆分（“/”）。最后，
样式：TextStyle(
颜色：资产[头寸]==
currentAudio.assetAudioPath
颜色：蓝色
：颜色。黑色），
onTap:（）{
_打开（位置）；
});
},
itemCount:assets.length，
);
},
),
),
划船(
mainAxisAlignment:mainAxisAlignment.center，
mainAxisSize:mainAxisSize.max，
儿童：[
StreamBuilder(
流：_assetsAudioPlayer.isLooping，
initialData:false，
建设者：
（BuildContext上下文，异步快照）{
返回上升按钮(
子项：文本（snapshot.data？“循环”：“非循环”），
已按下：（）{
_AssetAudioPlayer.toggleLoop（）；
},
);
},
),
尺寸箱（宽度：20），
升起的按钮(
儿童：文本（“搜索到2:00”），
已按下：（）{
_assetsAudioPlayer.seek（持续时间（分钟：2））；
},
),
],
),
划船(
mainAxisAlignment:mainAxisAlignment.center，
儿童：[
StreamBuilder(
流：_assetsAudioPlayer.currentPosition，
initialData:const Duration（），
生成器：（BuildContext上下文，
异步快照（快照）{
持续时间=snapshot.data；
返回文本（durationToString（duration））；
},
),
正文（“-”，
StreamBuilder(
流：_assetsAudioPlayer.current，
生成器：（BuildContext上下文，
异步快照（快照）{
持续时间=持续时间（）；
if（snapshot.hasData）{
持续时间=snapshot.data.duration；
}
返回文本（durationToString（duration））；
},
),
],
),
划船(
MainAxisAlign:MainAxisAlign