960 lines
27 KiB
Dart
960 lines
27 KiB
Dart
import 'dart:async';
|
|
import 'dart:html';
|
|
import 'dart:math';
|
|
|
|
import 'package:flutter/services.dart';
|
|
import 'package:flutter/widgets.dart';
|
|
import 'package:flutter_web_plugins/flutter_web_plugins.dart';
|
|
import 'package:just_audio/just_audio.dart';
|
|
|
|
final Random _random = Random();
|
|
|
|
class JustAudioPlugin {
|
|
static void registerWith(Registrar registrar) {
|
|
final MethodChannel channel = MethodChannel(
|
|
'com.ryanheise.just_audio.methods',
|
|
const StandardMethodCodec(),
|
|
registrar.messenger);
|
|
final JustAudioPlugin instance = JustAudioPlugin(registrar);
|
|
channel.setMethodCallHandler(instance.handleMethodCall);
|
|
}
|
|
|
|
final Registrar registrar;
|
|
|
|
JustAudioPlugin(this.registrar);
|
|
|
|
Future<dynamic> handleMethodCall(MethodCall call) async {
|
|
switch (call.method) {
|
|
case 'init':
|
|
final String id = call.arguments[0];
|
|
new Html5AudioPlayer(id: id, registrar: registrar);
|
|
return null;
|
|
case 'setIosCategory':
|
|
return null;
|
|
default:
|
|
throw PlatformException(code: 'Unimplemented');
|
|
}
|
|
}
|
|
}
|
|
|
|
abstract class JustAudioPlayer {
|
|
final String id;
|
|
final Registrar registrar;
|
|
final MethodChannel methodChannel;
|
|
final PluginEventChannel eventChannel;
|
|
final StreamController eventController = StreamController();
|
|
ProcessingState _processingState = ProcessingState.none;
|
|
bool _playing = false;
|
|
int _index;
|
|
|
|
JustAudioPlayer({@required this.id, @required this.registrar})
|
|
: methodChannel = MethodChannel('com.ryanheise.just_audio.methods.$id',
|
|
const StandardMethodCodec(), registrar.messenger),
|
|
eventChannel = PluginEventChannel('com.ryanheise.just_audio.events.$id',
|
|
const StandardMethodCodec(), registrar.messenger) {
|
|
methodChannel.setMethodCallHandler(_methodHandler);
|
|
eventChannel.controller = eventController;
|
|
}
|
|
|
|
Future<dynamic> _methodHandler(MethodCall call) async {
|
|
try {
|
|
final args = call.arguments;
|
|
switch (call.method) {
|
|
case 'load':
|
|
return await load(args[0]);
|
|
case 'play':
|
|
return await play();
|
|
case 'pause':
|
|
return await pause();
|
|
case 'setVolume':
|
|
return await setVolume(args[0]);
|
|
case 'setSpeed':
|
|
return await setSpeed(args[0]);
|
|
case 'setLoopMode':
|
|
return await setLoopMode(args[0]);
|
|
case 'setShuffleModeEnabled':
|
|
return await setShuffleModeEnabled(args[0]);
|
|
case 'setAutomaticallyWaitsToMinimizeStalling':
|
|
return null;
|
|
case 'seek':
|
|
return await seek(args[0], args[1]);
|
|
case 'dispose':
|
|
return dispose();
|
|
case 'concatenating.add':
|
|
return await concatenatingAdd(args[0], args[1]);
|
|
case "concatenating.insert":
|
|
return await concatenatingInsert(args[0], args[1], args[2]);
|
|
case "concatenating.addAll":
|
|
return await concatenatingAddAll(args[0], args[1]);
|
|
case "concatenating.insertAll":
|
|
return await concatenatingInsertAll(args[0], args[1], args[2]);
|
|
case "concatenating.removeAt":
|
|
return await concatenatingRemoveAt(args[0], args[1]);
|
|
case "concatenating.removeRange":
|
|
return await concatenatingRemoveRange(args[0], args[1], args[2]);
|
|
case "concatenating.move":
|
|
return await concatenatingMove(args[0], args[1], args[2]);
|
|
case "concatenating.clear":
|
|
return await concatenatingClear(args[0]);
|
|
case "setAndroidAudioAttributes":
|
|
return null;
|
|
default:
|
|
throw PlatformException(code: 'Unimplemented');
|
|
}
|
|
} catch (e, stacktrace) {
|
|
print("$stacktrace");
|
|
rethrow;
|
|
}
|
|
}
|
|
|
|
Future<int> load(Map source);
|
|
|
|
Future<void> play();
|
|
|
|
Future<void> pause();
|
|
|
|
Future<void> setVolume(double volume);
|
|
|
|
Future<void> setSpeed(double speed);
|
|
|
|
Future<void> setLoopMode(int mode);
|
|
|
|
Future<void> setShuffleModeEnabled(bool enabled);
|
|
|
|
Future<void> seek(int position, int index);
|
|
|
|
@mustCallSuper
|
|
void dispose() {
|
|
eventController.close();
|
|
}
|
|
|
|
Duration getCurrentPosition();
|
|
|
|
Duration getBufferedPosition();
|
|
|
|
Duration getDuration();
|
|
|
|
concatenatingAdd(String playerId, Map source);
|
|
|
|
concatenatingInsert(String playerId, int index, Map source);
|
|
|
|
concatenatingAddAll(String playerId, List sources);
|
|
|
|
concatenatingInsertAll(String playerId, int index, List sources);
|
|
|
|
concatenatingRemoveAt(String playerId, int index);
|
|
|
|
concatenatingRemoveRange(String playerId, int start, int end);
|
|
|
|
concatenatingMove(String playerId, int currentIndex, int newIndex);
|
|
|
|
concatenatingClear(String playerId);
|
|
|
|
broadcastPlaybackEvent() {
|
|
var updateTime = DateTime.now().millisecondsSinceEpoch;
|
|
eventController.add({
|
|
'processingState': _processingState.index,
|
|
'updatePosition': getCurrentPosition()?.inMilliseconds,
|
|
'updateTime': updateTime,
|
|
'bufferedPosition': getBufferedPosition()?.inMilliseconds,
|
|
// TODO: Icy Metadata
|
|
'icyMetadata': null,
|
|
'duration': getDuration()?.inMilliseconds,
|
|
'currentIndex': _index,
|
|
});
|
|
}
|
|
|
|
transition(ProcessingState processingState) {
|
|
_processingState = processingState;
|
|
broadcastPlaybackEvent();
|
|
}
|
|
}
|
|
|
|
class Html5AudioPlayer extends JustAudioPlayer {
|
|
AudioElement _audioElement = AudioElement();
|
|
Completer _durationCompleter;
|
|
AudioSourcePlayer _audioSourcePlayer;
|
|
LoopMode _loopMode = LoopMode.off;
|
|
bool _shuffleModeEnabled = false;
|
|
final Map<String, AudioSourcePlayer> _audioSourcePlayers = {};
|
|
|
|
Html5AudioPlayer({@required String id, @required Registrar registrar})
|
|
: super(id: id, registrar: registrar) {
|
|
_audioElement.addEventListener('durationchange', (event) {
|
|
_durationCompleter?.complete();
|
|
broadcastPlaybackEvent();
|
|
});
|
|
_audioElement.addEventListener('error', (event) {
|
|
_durationCompleter?.completeError(_audioElement.error);
|
|
});
|
|
_audioElement.addEventListener('ended', (event) async {
|
|
_currentAudioSourcePlayer.complete();
|
|
});
|
|
_audioElement.addEventListener('timeupdate', (event) {
|
|
_currentAudioSourcePlayer.timeUpdated(_audioElement.currentTime);
|
|
});
|
|
_audioElement.addEventListener('loadstart', (event) {
|
|
transition(ProcessingState.buffering);
|
|
});
|
|
_audioElement.addEventListener('waiting', (event) {
|
|
transition(ProcessingState.buffering);
|
|
});
|
|
_audioElement.addEventListener('stalled', (event) {
|
|
transition(ProcessingState.buffering);
|
|
});
|
|
_audioElement.addEventListener('canplaythrough', (event) {
|
|
transition(ProcessingState.ready);
|
|
});
|
|
_audioElement.addEventListener('progress', (event) {
|
|
broadcastPlaybackEvent();
|
|
});
|
|
}
|
|
|
|
List<int> get order {
|
|
final sequence = _audioSourcePlayer.sequence;
|
|
List<int> order = List<int>(sequence.length);
|
|
if (_shuffleModeEnabled) {
|
|
order = _audioSourcePlayer.shuffleOrder;
|
|
} else {
|
|
for (var i = 0; i < order.length; i++) {
|
|
order[i] = i;
|
|
}
|
|
}
|
|
return order;
|
|
}
|
|
|
|
List<int> getInv(List<int> order) {
|
|
List<int> orderInv = List<int>(order.length);
|
|
for (var i = 0; i < order.length; i++) {
|
|
orderInv[order[i]] = i;
|
|
}
|
|
return orderInv;
|
|
}
|
|
|
|
onEnded() async {
|
|
if (_loopMode == LoopMode.one) {
|
|
await seek(0, null);
|
|
play();
|
|
} else {
|
|
final order = this.order;
|
|
final orderInv = getInv(order);
|
|
if (orderInv[_index] + 1 < order.length) {
|
|
// move to next item
|
|
_index = order[orderInv[_index] + 1];
|
|
await _currentAudioSourcePlayer.load();
|
|
// Should always be true...
|
|
if (_playing) {
|
|
play();
|
|
}
|
|
} else {
|
|
// reached end of playlist
|
|
if (_loopMode == LoopMode.all) {
|
|
// Loop back to the beginning
|
|
if (order.length == 1) {
|
|
await seek(0, null);
|
|
play();
|
|
} else {
|
|
_index = order[0];
|
|
await _currentAudioSourcePlayer.load();
|
|
// Should always be true...
|
|
if (_playing) {
|
|
play();
|
|
}
|
|
}
|
|
} else {
|
|
transition(ProcessingState.completed);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: Improve efficiency.
|
|
IndexedAudioSourcePlayer get _currentAudioSourcePlayer =>
|
|
_audioSourcePlayer != null && _index < _audioSourcePlayer.sequence.length
|
|
? _audioSourcePlayer.sequence[_index]
|
|
: null;
|
|
|
|
@override
|
|
Future<int> load(Map source) async {
|
|
_currentAudioSourcePlayer?.pause();
|
|
_audioSourcePlayer = getAudioSource(source);
|
|
_index = 0;
|
|
if (_shuffleModeEnabled) {
|
|
_audioSourcePlayer?.shuffle(0, _index);
|
|
}
|
|
return (await _currentAudioSourcePlayer.load())?.inMilliseconds;
|
|
}
|
|
|
|
Future<Duration> loadUri(final Uri uri) async {
|
|
transition(ProcessingState.loading);
|
|
final src = uri.toString();
|
|
if (src != _audioElement.src) {
|
|
_durationCompleter = Completer<num>();
|
|
_audioElement.src = src;
|
|
_audioElement.preload = 'auto';
|
|
_audioElement.load();
|
|
try {
|
|
await _durationCompleter.future;
|
|
} on MediaError catch (e) {
|
|
throw PlatformException(
|
|
code: "${e.code}", message: "Failed to load URL");
|
|
} finally {
|
|
_durationCompleter = null;
|
|
}
|
|
}
|
|
transition(ProcessingState.ready);
|
|
final seconds = _audioElement.duration;
|
|
return seconds.isFinite
|
|
? Duration(milliseconds: (seconds * 1000).toInt())
|
|
: null;
|
|
}
|
|
|
|
@override
|
|
Future<void> play() async {
|
|
_playing = true;
|
|
await _currentAudioSourcePlayer.play();
|
|
}
|
|
|
|
@override
|
|
Future<void> pause() async {
|
|
_playing = false;
|
|
_currentAudioSourcePlayer.pause();
|
|
}
|
|
|
|
@override
|
|
Future<void> setVolume(double volume) async {
|
|
_audioElement.volume = volume;
|
|
}
|
|
|
|
@override
|
|
Future<void> setSpeed(double speed) async {
|
|
_audioElement.playbackRate = speed;
|
|
}
|
|
|
|
@override
|
|
Future<void> setLoopMode(int mode) async {
|
|
_loopMode = LoopMode.values[mode];
|
|
}
|
|
|
|
@override
|
|
Future<void> setShuffleModeEnabled(bool enabled) async {
|
|
_shuffleModeEnabled = enabled;
|
|
if (enabled) {
|
|
_audioSourcePlayer?.shuffle(0, _index);
|
|
}
|
|
}
|
|
|
|
@override
|
|
Future<void> seek(int position, int newIndex) async {
|
|
int index = newIndex ?? _index;
|
|
if (index != _index) {
|
|
_currentAudioSourcePlayer.pause();
|
|
_index = index;
|
|
await _currentAudioSourcePlayer.load();
|
|
await _currentAudioSourcePlayer.seek(position);
|
|
if (_playing) {
|
|
_currentAudioSourcePlayer.play();
|
|
}
|
|
} else {
|
|
await _currentAudioSourcePlayer.seek(position);
|
|
}
|
|
}
|
|
|
|
ConcatenatingAudioSourcePlayer _concatenating(String playerId) =>
|
|
_audioSourcePlayers[playerId] as ConcatenatingAudioSourcePlayer;
|
|
|
|
concatenatingAdd(String playerId, Map source) {
|
|
final playlist = _concatenating(playerId);
|
|
playlist.add(getAudioSource(source));
|
|
}
|
|
|
|
concatenatingInsert(String playerId, int index, Map source) {
|
|
_concatenating(playerId).insert(index, getAudioSource(source));
|
|
if (index <= _index) {
|
|
_index++;
|
|
}
|
|
}
|
|
|
|
concatenatingAddAll(String playerId, List sources) {
|
|
_concatenating(playerId).addAll(getAudioSources(sources));
|
|
}
|
|
|
|
concatenatingInsertAll(String playerId, int index, List sources) {
|
|
_concatenating(playerId).insertAll(index, getAudioSources(sources));
|
|
if (index <= _index) {
|
|
_index += sources.length;
|
|
}
|
|
}
|
|
|
|
concatenatingRemoveAt(String playerId, int index) async {
|
|
// Pause if removing current item
|
|
if (_index == index && _playing) {
|
|
_currentAudioSourcePlayer.pause();
|
|
}
|
|
_concatenating(playerId).removeAt(index);
|
|
if (_index == index) {
|
|
// Skip backward if there's nothing after this
|
|
if (index == _audioSourcePlayer.sequence.length) {
|
|
_index--;
|
|
}
|
|
// Resume playback at the new item (if it exists)
|
|
if (_playing && _currentAudioSourcePlayer != null) {
|
|
await _currentAudioSourcePlayer.load();
|
|
_currentAudioSourcePlayer.play();
|
|
}
|
|
} else if (index < _index) {
|
|
// Reflect that the current item has shifted its position
|
|
_index--;
|
|
}
|
|
}
|
|
|
|
concatenatingRemoveRange(String playerId, int start, int end) async {
|
|
if (_index >= start && _index < end && _playing) {
|
|
// Pause if removing current item
|
|
_currentAudioSourcePlayer.pause();
|
|
}
|
|
_concatenating(playerId).removeRange(start, end);
|
|
if (_index >= start && _index < end) {
|
|
// Skip backward if there's nothing after this
|
|
if (start >= _audioSourcePlayer.sequence.length) {
|
|
_index = start - 1;
|
|
} else {
|
|
_index = start;
|
|
}
|
|
// Resume playback at the new item (if it exists)
|
|
if (_playing && _currentAudioSourcePlayer != null) {
|
|
await _currentAudioSourcePlayer.load();
|
|
_currentAudioSourcePlayer.play();
|
|
}
|
|
} else if (end <= _index) {
|
|
// Reflect that the current item has shifted its position
|
|
_index -= (end - start);
|
|
}
|
|
}
|
|
|
|
concatenatingMove(String playerId, int currentIndex, int newIndex) {
|
|
_concatenating(playerId).move(currentIndex, newIndex);
|
|
if (currentIndex == _index) {
|
|
_index = newIndex;
|
|
} else if (currentIndex < _index && newIndex >= _index) {
|
|
_index--;
|
|
} else if (currentIndex > _index && newIndex <= _index) {
|
|
_index++;
|
|
}
|
|
}
|
|
|
|
concatenatingClear(String playerId) {
|
|
_currentAudioSourcePlayer.pause();
|
|
_concatenating(playerId).clear();
|
|
}
|
|
|
|
@override
|
|
Duration getCurrentPosition() => _currentAudioSourcePlayer?.position;
|
|
|
|
@override
|
|
Duration getBufferedPosition() => _currentAudioSourcePlayer?.bufferedPosition;
|
|
|
|
@override
|
|
Duration getDuration() => _currentAudioSourcePlayer?.duration;
|
|
|
|
@override
|
|
void dispose() {
|
|
_currentAudioSourcePlayer?.pause();
|
|
_audioElement.removeAttribute('src');
|
|
_audioElement.load();
|
|
transition(ProcessingState.none);
|
|
super.dispose();
|
|
}
|
|
|
|
List<AudioSourcePlayer> getAudioSources(List json) =>
|
|
json.map((s) => getAudioSource(s)).toList();
|
|
|
|
AudioSourcePlayer getAudioSource(Map json) {
|
|
final String id = json['id'];
|
|
var audioSourcePlayer = _audioSourcePlayers[id];
|
|
if (audioSourcePlayer == null) {
|
|
audioSourcePlayer = decodeAudioSource(json);
|
|
_audioSourcePlayers[id] = audioSourcePlayer;
|
|
}
|
|
return audioSourcePlayer;
|
|
}
|
|
|
|
AudioSourcePlayer decodeAudioSource(Map json) {
|
|
try {
|
|
switch (json['type']) {
|
|
case 'progressive':
|
|
return ProgressiveAudioSourcePlayer(
|
|
this, json['id'], Uri.parse(json['uri']), json['headers']);
|
|
case "dash":
|
|
return DashAudioSourcePlayer(
|
|
this, json['id'], Uri.parse(json['uri']), json['headers']);
|
|
case "hls":
|
|
return HlsAudioSourcePlayer(
|
|
this, json['id'], Uri.parse(json['uri']), json['headers']);
|
|
case "concatenating":
|
|
return ConcatenatingAudioSourcePlayer(
|
|
this,
|
|
json['id'],
|
|
getAudioSources(json['audioSources']),
|
|
json['useLazyPreparation']);
|
|
case "clipping":
|
|
return ClippingAudioSourcePlayer(
|
|
this,
|
|
json['id'],
|
|
getAudioSource(json['audioSource']),
|
|
Duration(milliseconds: json['start']),
|
|
Duration(milliseconds: json['end']));
|
|
case "looping":
|
|
return LoopingAudioSourcePlayer(this, json['id'],
|
|
getAudioSource(json['audioSource']), json['count']);
|
|
default:
|
|
throw Exception("Unknown AudioSource type: " + json['type']);
|
|
}
|
|
} catch (e, stacktrace) {
|
|
print("$stacktrace");
|
|
rethrow;
|
|
}
|
|
}
|
|
}
|
|
|
|
abstract class AudioSourcePlayer {
|
|
Html5AudioPlayer html5AudioPlayer;
|
|
final String id;
|
|
|
|
AudioSourcePlayer(this.html5AudioPlayer, this.id);
|
|
|
|
List<IndexedAudioSourcePlayer> get sequence;
|
|
|
|
List<int> get shuffleOrder;
|
|
|
|
int shuffle(int treeIndex, int currentIndex);
|
|
}
|
|
|
|
abstract class IndexedAudioSourcePlayer extends AudioSourcePlayer {
|
|
IndexedAudioSourcePlayer(Html5AudioPlayer html5AudioPlayer, String id)
|
|
: super(html5AudioPlayer, id);
|
|
|
|
Future<Duration> load();
|
|
|
|
Future<void> play();
|
|
|
|
Future<void> pause();
|
|
|
|
Future<void> seek(int position);
|
|
|
|
Future<void> complete();
|
|
|
|
Future<void> timeUpdated(double seconds) async {}
|
|
|
|
Duration get duration;
|
|
|
|
Duration get position;
|
|
|
|
Duration get bufferedPosition;
|
|
|
|
AudioElement get _audioElement => html5AudioPlayer._audioElement;
|
|
|
|
@override
|
|
int shuffle(int treeIndex, int currentIndex) => treeIndex + 1;
|
|
|
|
@override
|
|
String toString() => "${this.runtimeType}";
|
|
}
|
|
|
|
abstract class UriAudioSourcePlayer extends IndexedAudioSourcePlayer {
|
|
final Uri uri;
|
|
final Map headers;
|
|
double _resumePos;
|
|
Duration _duration;
|
|
Completer _completer;
|
|
|
|
UriAudioSourcePlayer(
|
|
Html5AudioPlayer html5AudioPlayer, String id, this.uri, this.headers)
|
|
: super(html5AudioPlayer, id);
|
|
|
|
@override
|
|
List<IndexedAudioSourcePlayer> get sequence => [this];
|
|
|
|
@override
|
|
List<int> get shuffleOrder => [0];
|
|
|
|
@override
|
|
Future<Duration> load() async {
|
|
_resumePos = 0.0;
|
|
return _duration = await html5AudioPlayer.loadUri(uri);
|
|
}
|
|
|
|
@override
|
|
Future<void> play() async {
|
|
_audioElement.currentTime = _resumePos;
|
|
_audioElement.play();
|
|
_completer = Completer();
|
|
await _completer.future;
|
|
_completer = null;
|
|
}
|
|
|
|
@override
|
|
Future<void> pause() async {
|
|
_resumePos = _audioElement.currentTime;
|
|
_audioElement.pause();
|
|
_interruptPlay();
|
|
}
|
|
|
|
@override
|
|
Future<void> seek(int position) async {
|
|
_audioElement.currentTime = _resumePos = position / 1000.0;
|
|
}
|
|
|
|
@override
|
|
Future<void> complete() async {
|
|
_interruptPlay();
|
|
html5AudioPlayer.onEnded();
|
|
}
|
|
|
|
_interruptPlay() {
|
|
if (_completer?.isCompleted == false) {
|
|
_completer.complete();
|
|
}
|
|
}
|
|
|
|
@override
|
|
Duration get duration {
|
|
return _duration;
|
|
//final seconds = _audioElement.duration;
|
|
//return seconds.isFinite
|
|
// ? Duration(milliseconds: (seconds * 1000).toInt())
|
|
// : null;
|
|
}
|
|
|
|
@override
|
|
Duration get position {
|
|
double seconds = _audioElement.currentTime;
|
|
return Duration(milliseconds: (seconds * 1000).toInt());
|
|
}
|
|
|
|
@override
|
|
Duration get bufferedPosition {
|
|
if (_audioElement.buffered.length > 0) {
|
|
return Duration(
|
|
milliseconds:
|
|
(_audioElement.buffered.end(_audioElement.buffered.length - 1) *
|
|
1000)
|
|
.toInt());
|
|
} else {
|
|
return Duration.zero;
|
|
}
|
|
}
|
|
}
|
|
|
|
class ProgressiveAudioSourcePlayer extends UriAudioSourcePlayer {
|
|
ProgressiveAudioSourcePlayer(
|
|
Html5AudioPlayer html5AudioPlayer, String id, Uri uri, Map headers)
|
|
: super(html5AudioPlayer, id, uri, headers);
|
|
}
|
|
|
|
class DashAudioSourcePlayer extends UriAudioSourcePlayer {
|
|
DashAudioSourcePlayer(
|
|
Html5AudioPlayer html5AudioPlayer, String id, Uri uri, Map headers)
|
|
: super(html5AudioPlayer, id, uri, headers);
|
|
}
|
|
|
|
class HlsAudioSourcePlayer extends UriAudioSourcePlayer {
|
|
HlsAudioSourcePlayer(
|
|
Html5AudioPlayer html5AudioPlayer, String id, Uri uri, Map headers)
|
|
: super(html5AudioPlayer, id, uri, headers);
|
|
}
|
|
|
|
class ConcatenatingAudioSourcePlayer extends AudioSourcePlayer {
|
|
static List<int> generateShuffleOrder(int length, [int firstIndex]) {
|
|
final shuffleOrder = List<int>(length);
|
|
for (var i = 0; i < length; i++) {
|
|
final j = _random.nextInt(i + 1);
|
|
shuffleOrder[i] = shuffleOrder[j];
|
|
shuffleOrder[j] = i;
|
|
}
|
|
if (firstIndex != null) {
|
|
for (var i = 1; i < length; i++) {
|
|
if (shuffleOrder[i] == firstIndex) {
|
|
final v = shuffleOrder[0];
|
|
shuffleOrder[0] = shuffleOrder[i];
|
|
shuffleOrder[i] = v;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return shuffleOrder;
|
|
}
|
|
|
|
final List<AudioSourcePlayer> audioSourcePlayers;
|
|
final bool useLazyPreparation;
|
|
List<int> _shuffleOrder;
|
|
|
|
ConcatenatingAudioSourcePlayer(Html5AudioPlayer html5AudioPlayer, String id,
|
|
this.audioSourcePlayers, this.useLazyPreparation)
|
|
: _shuffleOrder = generateShuffleOrder(audioSourcePlayers.length),
|
|
super(html5AudioPlayer, id);
|
|
|
|
@override
|
|
List<IndexedAudioSourcePlayer> get sequence =>
|
|
audioSourcePlayers.expand((p) => p.sequence).toList();
|
|
|
|
@override
|
|
List<int> get shuffleOrder {
|
|
final order = <int>[];
|
|
var offset = order.length;
|
|
final childOrders = <List<int>>[];
|
|
for (var audioSourcePlayer in audioSourcePlayers) {
|
|
final childShuffleOrder = audioSourcePlayer.shuffleOrder;
|
|
childOrders.add(childShuffleOrder.map((i) => i + offset).toList());
|
|
offset += childShuffleOrder.length;
|
|
}
|
|
for (var i = 0; i < childOrders.length; i++) {
|
|
order.addAll(childOrders[_shuffleOrder[i]]);
|
|
}
|
|
return order;
|
|
}
|
|
|
|
@override
|
|
int shuffle(int treeIndex, int currentIndex) {
|
|
int currentChildIndex;
|
|
for (var i = 0; i < audioSourcePlayers.length; i++) {
|
|
final indexBefore = treeIndex;
|
|
final child = audioSourcePlayers[i];
|
|
treeIndex = child.shuffle(treeIndex, currentIndex);
|
|
if (currentIndex >= indexBefore && currentIndex < treeIndex) {
|
|
currentChildIndex = i;
|
|
} else {}
|
|
}
|
|
// Shuffle so that the current child is first in the shuffle order
|
|
_shuffleOrder =
|
|
generateShuffleOrder(audioSourcePlayers.length, currentChildIndex);
|
|
return treeIndex;
|
|
}
|
|
|
|
add(AudioSourcePlayer player) {
|
|
audioSourcePlayers.add(player);
|
|
_shuffleOrder.add(audioSourcePlayers.length - 1);
|
|
}
|
|
|
|
insert(int index, AudioSourcePlayer player) {
|
|
audioSourcePlayers.insert(index, player);
|
|
for (var i = 0; i < audioSourcePlayers.length; i++) {
|
|
if (_shuffleOrder[i] >= index) {
|
|
_shuffleOrder[i]++;
|
|
}
|
|
}
|
|
_shuffleOrder.add(index);
|
|
}
|
|
|
|
addAll(List<AudioSourcePlayer> players) {
|
|
audioSourcePlayers.addAll(players);
|
|
_shuffleOrder.addAll(
|
|
List.generate(players.length, (i) => audioSourcePlayers.length + i)
|
|
.toList()
|
|
..shuffle());
|
|
}
|
|
|
|
insertAll(int index, List<AudioSourcePlayer> players) {
|
|
audioSourcePlayers.insertAll(index, players);
|
|
for (var i = 0; i < audioSourcePlayers.length; i++) {
|
|
if (_shuffleOrder[i] >= index) {
|
|
_shuffleOrder[i] += players.length;
|
|
}
|
|
}
|
|
_shuffleOrder.addAll(
|
|
List.generate(players.length, (i) => index + i).toList()..shuffle());
|
|
}
|
|
|
|
removeAt(int index) {
|
|
audioSourcePlayers.removeAt(index);
|
|
// 0 1 2 3
|
|
// 3 2 0 1
|
|
for (var i = 0; i < audioSourcePlayers.length; i++) {
|
|
if (_shuffleOrder[i] > index) {
|
|
_shuffleOrder[i]--;
|
|
}
|
|
}
|
|
_shuffleOrder.removeWhere((i) => i == index);
|
|
}
|
|
|
|
removeRange(int start, int end) {
|
|
audioSourcePlayers.removeRange(start, end);
|
|
for (var i = 0; i < audioSourcePlayers.length; i++) {
|
|
if (_shuffleOrder[i] >= end) {
|
|
_shuffleOrder[i] -= (end - start);
|
|
}
|
|
}
|
|
_shuffleOrder.removeWhere((i) => i >= start && i < end);
|
|
}
|
|
|
|
move(int currentIndex, int newIndex) {
|
|
audioSourcePlayers.insert(
|
|
newIndex, audioSourcePlayers.removeAt(currentIndex));
|
|
}
|
|
|
|
clear() {
|
|
audioSourcePlayers.clear();
|
|
_shuffleOrder.clear();
|
|
}
|
|
}
|
|
|
|
class ClippingAudioSourcePlayer extends IndexedAudioSourcePlayer {
|
|
final UriAudioSourcePlayer audioSourcePlayer;
|
|
final Duration start;
|
|
final Duration end;
|
|
Completer<ClipInterruptReason> _completer;
|
|
double _resumePos;
|
|
Duration _duration;
|
|
|
|
ClippingAudioSourcePlayer(Html5AudioPlayer html5AudioPlayer, String id,
|
|
this.audioSourcePlayer, this.start, this.end)
|
|
: super(html5AudioPlayer, id);
|
|
|
|
@override
|
|
List<IndexedAudioSourcePlayer> get sequence => [this];
|
|
|
|
@override
|
|
List<int> get shuffleOrder => [0];
|
|
|
|
@override
|
|
Future<Duration> load() async {
|
|
_resumePos = (start ?? Duration.zero).inMilliseconds / 1000.0;
|
|
Duration fullDuration =
|
|
await html5AudioPlayer.loadUri(audioSourcePlayer.uri);
|
|
_audioElement.currentTime = _resumePos;
|
|
_duration = Duration(
|
|
milliseconds: min((end ?? fullDuration).inMilliseconds,
|
|
fullDuration.inMilliseconds) -
|
|
(start ?? Duration.zero).inMilliseconds);
|
|
return _duration;
|
|
}
|
|
|
|
double get remaining => end.inMilliseconds / 1000 - _audioElement.currentTime;
|
|
|
|
@override
|
|
Future<void> play() async {
|
|
_interruptPlay(ClipInterruptReason.simultaneous);
|
|
_audioElement.currentTime = _resumePos;
|
|
_audioElement.play();
|
|
_completer = Completer<ClipInterruptReason>();
|
|
ClipInterruptReason reason;
|
|
while ((reason = await _completer.future) == ClipInterruptReason.seek) {
|
|
_completer = Completer<ClipInterruptReason>();
|
|
}
|
|
if (reason == ClipInterruptReason.end) {
|
|
html5AudioPlayer.onEnded();
|
|
}
|
|
_completer = null;
|
|
}
|
|
|
|
@override
|
|
Future<void> pause() async {
|
|
_interruptPlay(ClipInterruptReason.pause);
|
|
_resumePos = _audioElement.currentTime;
|
|
_audioElement.pause();
|
|
}
|
|
|
|
@override
|
|
Future<void> seek(int position) async {
|
|
_interruptPlay(ClipInterruptReason.seek);
|
|
_audioElement.currentTime =
|
|
_resumePos = start.inMilliseconds / 1000.0 + position / 1000.0;
|
|
}
|
|
|
|
@override
|
|
Future<void> complete() async {
|
|
_interruptPlay(ClipInterruptReason.end);
|
|
}
|
|
|
|
@override
|
|
Future<void> timeUpdated(double seconds) async {
|
|
if (end != null) {
|
|
if (seconds >= end.inMilliseconds / 1000) {
|
|
_interruptPlay(ClipInterruptReason.end);
|
|
}
|
|
}
|
|
}
|
|
|
|
@override
|
|
Duration get duration {
|
|
return _duration;
|
|
}
|
|
|
|
@override
|
|
Duration get position {
|
|
double seconds = _audioElement.currentTime;
|
|
var position = Duration(milliseconds: (seconds * 1000).toInt());
|
|
if (start != null) {
|
|
position -= start;
|
|
}
|
|
if (position < Duration.zero) {
|
|
position = Duration.zero;
|
|
}
|
|
return position;
|
|
}
|
|
|
|
@override
|
|
Duration get bufferedPosition {
|
|
if (_audioElement.buffered.length > 0) {
|
|
var seconds =
|
|
_audioElement.buffered.end(_audioElement.buffered.length - 1);
|
|
var position = Duration(milliseconds: (seconds * 1000).toInt());
|
|
if (start != null) {
|
|
position -= start;
|
|
}
|
|
if (position < Duration.zero) {
|
|
position = Duration.zero;
|
|
}
|
|
if (duration != null && position > duration) {
|
|
position = duration;
|
|
}
|
|
return position;
|
|
} else {
|
|
return Duration.zero;
|
|
}
|
|
}
|
|
|
|
_interruptPlay(ClipInterruptReason reason) {
|
|
if (_completer?.isCompleted == false) {
|
|
_completer.complete(reason);
|
|
}
|
|
}
|
|
}
|
|
|
|
enum ClipInterruptReason { end, pause, seek, simultaneous }
|
|
|
|
class LoopingAudioSourcePlayer extends AudioSourcePlayer {
|
|
final AudioSourcePlayer audioSourcePlayer;
|
|
final int count;
|
|
|
|
LoopingAudioSourcePlayer(Html5AudioPlayer html5AudioPlayer, String id,
|
|
this.audioSourcePlayer, this.count)
|
|
: super(html5AudioPlayer, id);
|
|
|
|
@override
|
|
List<IndexedAudioSourcePlayer> get sequence =>
|
|
List.generate(count, (i) => audioSourcePlayer)
|
|
.expand((p) => p.sequence)
|
|
.toList();
|
|
|
|
@override
|
|
List<int> get shuffleOrder {
|
|
final order = <int>[];
|
|
var offset = order.length;
|
|
for (var i = 0; i < count; i++) {
|
|
final childShuffleOrder = audioSourcePlayer.shuffleOrder;
|
|
order.addAll(childShuffleOrder.map((i) => i + offset).toList());
|
|
offset += childShuffleOrder.length;
|
|
}
|
|
return order;
|
|
}
|
|
|
|
@override
|
|
int shuffle(int treeIndex, int currentIndex) {
|
|
for (var i = 0; i < count; i++) {
|
|
treeIndex = audioSourcePlayer.shuffle(treeIndex, currentIndex);
|
|
}
|
|
return treeIndex;
|
|
}
|
|
}
|