更改播放音频方式

lib/features/player/providers/session_provider.dart

@@ -0,0 +1,216 @@
+import 'package:audio_service/audio_service.dart';
+import 'package:http/http.dart' as http;
+import 'package:just_audio/just_audio.dart';
+import 'package:just_audio_media_kit/just_audio_media_kit.dart';
+import 'package:riverpod/riverpod.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+import 'package:shelfsdk/audiobookshelf_api.dart' as core;
+import 'package:vaani/api/api_provider.dart';
+import 'package:vaani/api/library_item_provider.dart';
+import 'package:vaani/features/downloads/providers/download_manager.dart';
+import 'package:vaani/features/per_book_settings/providers/book_settings_provider.dart';
+import 'package:vaani/features/player/core/audiobook_player_session.dart';
+import 'package:vaani/globals.dart';
+import 'package:vaani/settings/app_settings_provider.dart';
+import 'package:vaani/shared/extensions/obfuscation.dart';
+
+part 'session_provider.g.dart';
+
+class SessionPlayer {
+  late final AbsAudioHandler _audioService;
+  core.PlaybackSessionExpanded? _session;
+  Ref ref;
+  SessionPlayer(this.ref);
+  void setAudioService(AbsAudioHandler audioPlayer) {
+    _audioService = audioPlayer;
+  }
+
+  Future<void> load(String id, String? episodeId) async {
+    ref.read(sessionLoadingProvider(id).notifier).setLoading();
+    final api = ref.read(authenticatedApiProvider);
+    final playBack = await api.items.play(
+      libraryItemId: id,
+      parameters: core.PlayItemReqParams(
+        deviceInfo: core.DeviceInfoReqParams(
+          clientVersion: appVersion,
+          manufacturer: deviceManufacturer,
+          model: deviceModel,
+          sdkVersion: deviceSdkVersion,
+          clientName: appName,
+          deviceName: deviceName,
+        ),
+        forceDirectPlay: false,
+        forceTranscode: false,
+        supportedMimeTypes: [
+          "audio/flac",
+          "audio/mpeg",
+          "audio/mp4",
+          "audio/ogg",
+          "audio/aac",
+          "audio/webm",
+        ],
+      ),
+      responseErrorHandler: _responseErrorHandler,
+    ) as core.PlaybackSessionExpanded;
+
+    final downloadManager = ref.read(simpleDownloadManagerProvider);
+    final libItem =
+        await ref.read(libraryItemProvider(playBack.libraryItemId).future);
+    final downloadedUris = await downloadManager.getDownloadedFilesUri(libItem);
+
+    var bookPlayerSettings =
+        ref.read(bookSettingsProvider(playBack.libraryItemId)).playerSettings;
+    var appPlayerSettings = ref.read(appSettingsProvider).playerSettings;
+
+    var configurePlayerForEveryBook =
+        appPlayerSettings.configurePlayerForEveryBook;
+
+    await Future.wait([
+      _audioService.setSourceAudiobook(
+        playBack,
+        baseUrl: api.baseUrl,
+        token: api.token!,
+        downloadedUris: downloadedUris,
+      ),
+      // set the volume
+      _audioService.setVolume(
+        configurePlayerForEveryBook
+            ? bookPlayerSettings.preferredDefaultVolume ??
+                appPlayerSettings.preferredDefaultVolume
+            : appPlayerSettings.preferredDefaultVolume,
+      ),
+      // set the speed
+      _audioService.setSpeed(
+        configurePlayerForEveryBook
+            ? bookPlayerSettings.preferredDefaultSpeed ??
+                appPlayerSettings.preferredDefaultSpeed
+            : appPlayerSettings.preferredDefaultSpeed,
+      ),
+    ]);
+    _session = playBack;
+    ref.read(sessionLoadingProvider(id).notifier).setLoaded();
+    ref.notifyListeners();
+  }
+
+  AbsAudioHandler get audioService => _audioService;
+  core.PlaybackSession? get session => _session;
+
+  void _responseErrorHandler(http.Response response, [error]) {
+    if (response.statusCode != 200) {
+      appLogger.severe('Error with api: ${response.obfuscate()}, $error');
+      throw PlaybackSyncError(
+        'Error syncing position: ${response.body}, $error',
+      );
+    }
+  }
+}
+
+@Riverpod(keepAlive: true)
+class Player extends _$Player {
+  @override
+  AbsAudioHandler build() {
+    final audioService = ref.watch(sessionProvider).audioService;
+    // audioService.positionStream.listen((position){
+
+    // });
+    return audioService;
+  }
+
+  Future<void> togglePlayPause() => state.togglePlayPause();
+  Future<void> play() => state.play();
+  Future<void> pause() => state.pause();
+  Future<void> seekInBook(Duration globalPosition) =>
+      state.seekInBook(globalPosition);
+}
+
+@Riverpod(keepAlive: true)
+SessionPlayer session(Ref ref) {
+  return SessionPlayer(ref);
+}
+
+@Riverpod(keepAlive: true)
+class SessionLoading extends _$SessionLoading {
+  @override
+  bool build(String itemId) {
+    return false;
+  }
+
+  setLoading() {
+    state = true;
+  }
+
+  setLoaded() {
+    state = false;
+  }
+}
+
+@Riverpod(keepAlive: true)
+class PlayState extends _$PlayState {
+  @override
+  PlayerState build() {
+    return PlayerState(false, ProcessingState.idle);
+  }
+
+  void setState(PlayerState playerState) {
+    state = playerState;
+  }
+}
+
+@riverpod
+core.BookChapter? currentChapter(Ref ref) {
+  return ref.watch(playerProvider.select((v) => v.currentChapter));
+}
+
+@Riverpod(keepAlive: true)
+Future<AbsAudioHandler> audioHandlerInit(Ref ref) async {
+  // JustAudioMediaKit.ensureInitialized(windows: false);
+  JustAudioMediaKit.ensureInitialized();
+  final audioService = await AudioService.init(
+    builder: () => AbsAudioHandler(ref),
+    config: const AudioServiceConfig(
+      androidNotificationChannelId: 'com.vaani.rang.channel.audio',
+      androidNotificationChannelName: 'ABSPlayback',
+      androidNotificationChannelDescription:
+          'Needed to control audio from lock screen',
+      androidNotificationOngoing: false,
+      androidStopForegroundOnPause: false,
+      androidNotificationIcon: 'drawable/ic_stat_logo',
+      preloadArtwork: true,
+    ),
+  );
+  ref.read(sessionProvider).setAudioService(audioService);
+  return audioService;
+}
+
+// @Riverpod(keepAlive: true)
+// class PlaybackReporter extends _$PlaybackReporter {
+//   @override
+//   Future<core.PlaybackReporter> build() async {
+//     final playerSettings = ref.watch(appSettingsProvider).playerSettings;
+//     final player = ref.watch(playerProvider);
+//     final session = ref.watch(sessionProvider.select((v) => v.session));
+//     final api = ref.watch(authenticatedApiProvider);
+
+//     final reporter = core.PlaybackReporter(
+//       player.player,
+//       api,
+//       reportingInterval: playerSettings.playbackReportInterval,
+//       markCompleteWhenTimeLeft: playerSettings.markCompleteWhenTimeLeft,
+//       minimumPositionForReporting: playerSettings.minimumPositionForReporting,
+//       session: session,
+//     );
+//     ref.onDispose(reporter.dispose);
+//     return reporter;
+//   }
+// }
+
+class PlaybackSyncError implements Exception {
+  String message;
+
+  PlaybackSyncError([this.message = 'Error syncing playback']);
+
+  @override
+  String toString() {
+    return 'PlaybackSyncError: $message';
+  }
+}