播放逻辑修改

lib/shared/audio_player.dart

@@ -20,15 +20,15 @@ final _logger = Logger('AbsAudioPlayer');
 abstract class AbsAudioPlayer {
   final _mediaItemController = BehaviorSubject<MediaItem?>.seeded(null);
   final playerStateSubject =
-      BehaviorSubject.seeded(PlayerState(false, ProcessingState.idle));
+      BehaviorSubject.seeded(AbsPlayerState(false, AbsProcessingState.idle));
   final _bookStreamController = BehaviorSubject<BookExpanded?>.seeded(null);
   final _chapterStreamController = BehaviorSubject<BookChapter?>.seeded(null);
 
   BookExpanded? get book => _bookStreamController.nvalue;
   BookChapter? get currentChapter => _chapterStreamController.nvalue;
-  PlayerState get playerState => playerStateSubject.value;
+  AbsPlayerState get playerState => playerStateSubject.value;
   Stream<MediaItem?> get mediaItemStream => _mediaItemController.stream;
-  Stream<PlayerState> get playerStateStream => playerStateSubject.stream;
+  Stream<AbsPlayerState> get playerStateStream => playerStateSubject.stream;
 
   Future<void> load(
     BookExpanded book, {
@@ -71,7 +71,7 @@ abstract class AbsAudioPlayer {
               baseUrl: baseUrl, token: token),
         )
         .toList();
-    setPlayList(playlist, index: indexTrack, position: positionInTrack);
+    await setPlayList(playlist, index: indexTrack, position: positionInTrack);
   }
 
   Future<void> setPlayList(
@@ -138,6 +138,7 @@ abstract class AbsAudioPlayer {
     await seekInBook(chapter.start + offset);
   }
 
+  bool get playing => playerState.playing;
   Stream<bool> get playingStream;
   Stream<BookExpanded?> get bookStream => _bookStreamController.stream;
   Stream<BookChapter?> get chapterStream => _chapterStreamController.stream;
@@ -185,7 +186,7 @@ abstract class AbsAudioPlayer {
 }
 
 /// Enumerates the different processing states of a player.
-enum ProcessingState {
+enum AbsProcessingState {
   /// The player has not loaded an [AudioSource].
   idle,
 
@@ -206,15 +207,15 @@ enum ProcessingState {
 /// orthogonally, and so if [processingState] is [ProcessingState.buffering],
 /// you can check [playing] to determine whether the buffering occurred while
 /// the player was playing or while the player was paused.
-class PlayerState {
+class AbsPlayerState {
   /// Whether the player will play when [processingState] is
   /// [ProcessingState.ready].
   final bool playing;
 
   /// The current processing state of the player.
-  final ProcessingState processingState;
+  final AbsProcessingState processingState;
 
-  PlayerState(this.playing, this.processingState);
+  AbsPlayerState(this.playing, this.processingState);
 
   @override
   String toString() => 'playing=$playing,processingState=$processingState';
@@ -229,11 +230,11 @@ class PlayerState {
       other.playing == playing &&
       other.processingState == processingState;
 
-  PlayerState copyWith({
+  AbsPlayerState copyWith({
     bool? playing,
-    ProcessingState? processingState,
+    AbsProcessingState? processingState,
   }) {
-    return PlayerState(
+    return AbsPlayerState(
       playing ?? this.playing,
       processingState ?? this.processingState,
     );

lib/shared/audio_player_mpv.dart

@@ -12,20 +12,23 @@ class AbsMpvAudioPlayer extends AbsAudioPlayer {
         state.copyWith(
           playing: playing,
           processingState: playing
-              ? state.processingState == ProcessingState.idle
-                  ? ProcessingState.ready
+              ? state.processingState == AbsProcessingState.idle
+                  ? AbsProcessingState.ready
                   : state.processingState
               : player.state.buffering
-                  ? ProcessingState.buffering
+                  ? AbsProcessingState.buffering
                   : player.state.completed
-                      ? ProcessingState.completed
-                      : ProcessingState.ready,
+                      ? AbsProcessingState.completed
+                      : AbsProcessingState.ready,
         ),
       );
     });
   }
   @override
-  Stream<Duration> get bufferedPositionInBookStream => player.stream.buffer;
+  Duration get bufferedPosition => player.state.buffer;
+
+  @override
+  Stream<Duration> get bufferedPositionStream => player.stream.buffer;
 
   @override
   int get currentIndex => player.state.playlist.index;
@@ -45,6 +48,9 @@ class AbsMpvAudioPlayer extends AbsAudioPlayer {
     await player.playOrPause();
   }
 
+  @override
+  Stream<bool> get playingStream => player.stream.playing;
+
   @override
   Duration get position => player.state.position;
 
@@ -91,17 +97,5 @@ class AbsMpvAudioPlayer extends AbsAudioPlayer {
   }
 
   @override
-  Stream<bool> get playingStream => player.stream.playing;
-
-  @override
-  // TODO: implement speed
   double get speed => player.state.rate;
-
-  @override
-  // TODO: implement bufferedPosition
-  Duration get bufferedPosition => player.state.buffer;
-
-  @override
-  // TODO: implement bufferedPositionStream
-  Stream<Duration> get bufferedPositionStream => player.stream.buffer;
 }

lib/shared/audio_player_platform.dart

@@ -0,0 +1,96 @@
+import 'package:just_audio/just_audio.dart';
+import 'package:logging/logging.dart';
+import 'package:vaani/shared/audio_player.dart';
+
+final _logger = Logger('AbsPlatformAudioPlayer');
+
+class AbsPlatformAudioPlayer extends AbsAudioPlayer {
+  final AudioPlayer player = AudioPlayer();
+  AbsPlatformAudioPlayer() {
+    player.playerStateStream.listen((state) {
+      playerStateSubject.add(
+        playerState.copyWith(
+          playing: state.playing,
+          processingState: {
+            ProcessingState.idle: AbsProcessingState.idle,
+            ProcessingState.buffering: AbsProcessingState.buffering,
+            ProcessingState.completed: AbsProcessingState.completed,
+            ProcessingState.loading: AbsProcessingState.loading,
+            ProcessingState.ready: AbsProcessingState.ready,
+          }[state.processingState],
+        ),
+      );
+    });
+  }
+  @override
+  Duration get bufferedPosition => player.bufferedPosition;
+
+  @override
+  Stream<Duration> get bufferedPositionStream => player.bufferedPositionStream;
+
+  @override
+  int get currentIndex => player.currentIndex ?? 0;
+
+  @override
+  Future<void> pause() async {
+    await player.pause();
+  }
+
+  @override
+  Future<void> play() async {
+    await player.play();
+  }
+
+  @override
+  Future<void> playOrPause() async {
+    player.playing ? await player.pause() : await player.play();
+  }
+
+  @override
+  Stream<bool> get playingStream => player.playingStream;
+
+  @override
+  Duration get position => player.position;
+
+  @override
+  Stream<Duration> get positionStream => player.positionStream;
+
+  @override
+  Future<void> seek(Duration position, {int? index}) async {
+    await player.seek(position, index: index);
+  }
+
+  @override
+  Future<void> setPlayList(
+    List<Uri> playlist, {
+    int? index,
+    Duration? position,
+  }) async {
+    List<AudioSource> audioSources =
+        playlist.map((uri) => AudioSource.uri(uri)).toList();
+    await player
+        .setAudioSources(
+      audioSources,
+      preload: true,
+      initialIndex: index,
+      initialPosition: position,
+    )
+        .catchError((error) {
+      _logger.shout('Error in setting audio source: $error');
+      return null;
+    });
+  }
+
+  @override
+  Future<void> setSpeed(double speed) async {
+    await player.setSpeed(speed);
+  }
+
+  @override
+  Future<void> setVolume(double volume) async {
+    await player.setVolume(volume);
+  }
+
+  @override
+  double get speed => player.speed;
+}