mirror of
https://github.com/Dr-Blank/Vaani.git
synced 2026-02-16 06:19:35 +00:00
346 lines
11 KiB
Dart
346 lines
11 KiB
Dart
import 'package:audio_service/audio_service.dart';
|
|
import 'package:audio_session/audio_session.dart';
|
|
import 'package:collection/collection.dart';
|
|
import 'package:hooks_riverpod/hooks_riverpod.dart';
|
|
import 'package:just_audio/just_audio.dart';
|
|
import 'package:logging/logging.dart';
|
|
import 'package:riverpod_annotation/riverpod_annotation.dart';
|
|
import 'package:shelfsdk/audiobookshelf_api.dart' as api;
|
|
import 'package:vaani/api/api_provider.dart';
|
|
import 'package:vaani/api/library_item_provider.dart';
|
|
import 'package:vaani/db/available_boxes.dart';
|
|
import 'package:vaani/db/cache/cache_key.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/abs_audio_handler.dart';
|
|
import 'package:vaani/features/player/core/abs_audio_player.dart' as core;
|
|
import 'package:vaani/features/player/core/abs_audio_player_platform.dart';
|
|
import 'package:vaani/features/settings/app_settings_provider.dart';
|
|
import 'package:vaani/shared/extensions/box.dart';
|
|
import 'package:vaani/shared/extensions/model_conversions.dart';
|
|
|
|
part 'abs_provider.g.dart';
|
|
|
|
final _logger = Logger('AbsPlayerProvider');
|
|
|
|
/// 音频播放器 配置
|
|
@Riverpod(keepAlive: true)
|
|
Future<AudioHandler> configurePlayer(Ref ref) async {
|
|
final player = ref.read(absPlayerProvider);
|
|
// for playing audio on windows, linux
|
|
|
|
// for configuring how this app will interact with other audio apps
|
|
final session = await AudioSession.instance;
|
|
await session.configure(const AudioSessionConfiguration.speech());
|
|
|
|
final audioService = await AudioService.init(
|
|
builder: () => AbsAudioHandler(player),
|
|
config: const AudioServiceConfig(
|
|
androidNotificationChannelId: 'dr.blank.vaani.channel.audio',
|
|
androidNotificationChannelName: 'ABSPlayback',
|
|
androidNotificationChannelDescription:
|
|
'Needed to control audio from lock screen',
|
|
androidNotificationOngoing: false,
|
|
androidStopForegroundOnPause: false,
|
|
androidNotificationIcon: 'drawable/ic_stat_logo',
|
|
preloadArtwork: true,
|
|
// fastForwardInterval: Duration(seconds: 20),
|
|
// rewindInterval: Duration(seconds: 20),
|
|
),
|
|
);
|
|
|
|
_logger.finer('created simple player');
|
|
return audioService;
|
|
}
|
|
|
|
// just_audio 播放器
|
|
@Riverpod(keepAlive: true)
|
|
core.AbsAudioPlayer audioPlayer(Ref ref) {
|
|
final player = AbsPlatformAudioPlayer();
|
|
// final player = AbsMpvAudioPlayer();
|
|
ref.onDispose(player.dispose);
|
|
return player;
|
|
}
|
|
|
|
// 播放器激活状态
|
|
@riverpod
|
|
bool playerActive(Ref ref) {
|
|
return false;
|
|
}
|
|
|
|
@Riverpod(keepAlive: true)
|
|
AudioPlayer simpleAudioPlayer(Ref ref) {
|
|
final player = AudioPlayer();
|
|
ref.onDispose(player.dispose);
|
|
return player;
|
|
}
|
|
|
|
@Riverpod(keepAlive: true)
|
|
class AbsAudioPlayer extends _$AbsAudioPlayer {
|
|
@override
|
|
AudioPlayer build() {
|
|
final audioPlayer = ref.watch(simpleAudioPlayerProvider);
|
|
return audioPlayer;
|
|
}
|
|
|
|
Future<void> load(
|
|
api.BookExpanded book, {
|
|
Duration? initialPosition,
|
|
bool play = true,
|
|
}) async {
|
|
final currentTrack = book.findTrackAtTime(initialPosition ?? Duration.zero);
|
|
final indexTrack = book.tracks.indexOf(currentTrack);
|
|
final positionInTrack = initialPosition != null
|
|
? initialPosition - currentTrack.startOffset
|
|
: null;
|
|
final api = ref.read(authenticatedApiProvider);
|
|
|
|
final downloadManager = ref.read(simpleDownloadManagerProvider);
|
|
print(downloadManager.basePath);
|
|
|
|
final libItem =
|
|
await ref.read(libraryItemProvider(book.libraryItemId).future);
|
|
final downloadedUris = await downloadManager.getDownloadedFilesUri(libItem);
|
|
|
|
final bookSettings = ref.read(bookSettingsProvider(book.libraryItemId));
|
|
var bookPlayerSettings = bookSettings.playerSettings;
|
|
final start = bookSettings.playerSettings.skipChapterStart;
|
|
final end = bookSettings.playerSettings.skipChapterEnd;
|
|
final appPlayerSettings = ref.read(appSettingsProvider).playerSettings;
|
|
final configurePlayerForEveryBook =
|
|
appPlayerSettings.configurePlayerForEveryBook;
|
|
List<AudioSource> audioSources =
|
|
start > Duration.zero || end > Duration.zero
|
|
? book.tracks
|
|
.map(
|
|
(track) => ClippingAudioSource(
|
|
child: AudioSource.uri(
|
|
_getUri(
|
|
track,
|
|
downloadedUris,
|
|
baseUrl: api.baseUrl,
|
|
token: api.token!,
|
|
),
|
|
),
|
|
start: start,
|
|
end: end > Duration.zero ? null : track.duration - end,
|
|
),
|
|
)
|
|
.toList()
|
|
: book.tracks
|
|
.map(
|
|
(track) => AudioSource.uri(
|
|
_getUri(
|
|
track,
|
|
downloadedUris,
|
|
baseUrl: api.baseUrl,
|
|
token: api.token!,
|
|
),
|
|
),
|
|
)
|
|
.toList();
|
|
await state
|
|
.setAudioSources(
|
|
audioSources,
|
|
preload: true,
|
|
initialIndex: indexTrack,
|
|
initialPosition: positionInTrack,
|
|
)
|
|
.catchError((error) {
|
|
_logger.shout('Error in setting audio source: $error');
|
|
return null;
|
|
});
|
|
// set the volume
|
|
await state.setVolume(
|
|
configurePlayerForEveryBook
|
|
? bookPlayerSettings.preferredDefaultVolume ??
|
|
appPlayerSettings.preferredDefaultVolume
|
|
: appPlayerSettings.preferredDefaultVolume,
|
|
);
|
|
// set the speed
|
|
await state.setSpeed(
|
|
configurePlayerForEveryBook
|
|
? bookPlayerSettings.preferredDefaultSpeed ??
|
|
appPlayerSettings.preferredDefaultSpeed
|
|
: appPlayerSettings.preferredDefaultSpeed,
|
|
);
|
|
if (play) await state.play();
|
|
}
|
|
|
|
Uri _getUri(
|
|
api.AudioTrack track,
|
|
List<Uri>? downloadedUris, {
|
|
required Uri baseUrl,
|
|
required String token,
|
|
}) {
|
|
// check if the track is in the downloadedUris
|
|
final uri = downloadedUris?.firstWhereOrNull(
|
|
(element) {
|
|
return element.pathSegments.last == track.metadata?.filename;
|
|
},
|
|
);
|
|
|
|
return uri ??
|
|
Uri.parse('${baseUrl.toString()}${track.contentUrl}?token=$token');
|
|
}
|
|
}
|
|
|
|
/// 音频播放器 riverpod状态
|
|
@Riverpod(keepAlive: true)
|
|
class AbsPlayer extends _$AbsPlayer {
|
|
@override
|
|
core.AbsAudioPlayer build() {
|
|
final audioPlayer = ref.watch(audioPlayerProvider);
|
|
return audioPlayer;
|
|
}
|
|
|
|
Future<void> load(
|
|
api.BookExpanded book, {
|
|
Duration? initialPosition,
|
|
bool play = true,
|
|
}) async {
|
|
if (state.book == book || state.book?.libraryItemId == book.libraryItemId) {
|
|
state.playOrPause();
|
|
return;
|
|
}
|
|
final api = ref.read(authenticatedApiProvider);
|
|
|
|
final downloadManager = ref.read(simpleDownloadManagerProvider);
|
|
print(downloadManager.basePath);
|
|
|
|
final libItem =
|
|
await ref.read(libraryItemProvider(book.libraryItemId).future);
|
|
final downloadedUris = await downloadManager.getDownloadedFilesUri(libItem);
|
|
|
|
final bookSettings = ref.read(bookSettingsProvider(book.libraryItemId));
|
|
var bookPlayerSettings = bookSettings.playerSettings;
|
|
var appPlayerSettings = ref.read(appSettingsProvider).playerSettings;
|
|
|
|
var configurePlayerForEveryBook =
|
|
appPlayerSettings.configurePlayerForEveryBook;
|
|
|
|
await state.load(
|
|
book,
|
|
baseUrl: api.baseUrl,
|
|
token: api.token!,
|
|
initialPosition: initialPosition,
|
|
downloadedUris: downloadedUris,
|
|
start: bookSettings.playerSettings.skipChapterStart,
|
|
end: bookSettings.playerSettings.skipChapterEnd,
|
|
);
|
|
// set the volume
|
|
await state.setVolume(
|
|
configurePlayerForEveryBook
|
|
? bookPlayerSettings.preferredDefaultVolume ??
|
|
appPlayerSettings.preferredDefaultVolume
|
|
: appPlayerSettings.preferredDefaultVolume,
|
|
);
|
|
// set the speed
|
|
await state.setSpeed(
|
|
configurePlayerForEveryBook
|
|
? bookPlayerSettings.preferredDefaultSpeed ??
|
|
appPlayerSettings.preferredDefaultSpeed
|
|
: appPlayerSettings.preferredDefaultSpeed,
|
|
);
|
|
if (play) await state.play();
|
|
}
|
|
}
|
|
|
|
@riverpod
|
|
class PlayerState extends _$PlayerState {
|
|
@override
|
|
core.AbsPlayerState build() {
|
|
final player = ref.read(absPlayerProvider);
|
|
player.playerStateStream.listen((playerState) {
|
|
if (playerState != state) {
|
|
state = playerState;
|
|
}
|
|
});
|
|
return player.playerState;
|
|
}
|
|
|
|
bool isLoading(String itemId) {
|
|
final player = ref.read(absPlayerProvider);
|
|
return player.book?.libraryItemId == itemId &&
|
|
!state.playing &&
|
|
state.processingState == core.AbsProcessingState.loading;
|
|
}
|
|
|
|
bool isPlaying() {
|
|
return state.playing;
|
|
}
|
|
}
|
|
|
|
@riverpod
|
|
Future<Duration?> currentTime(Ref ref, String libraryItemId) async {
|
|
final me = await ref.watch(meProvider.future);
|
|
final userProgress = me.mediaProgress
|
|
?.firstWhereOrNull((element) => element.libraryItemId == libraryItemId);
|
|
return userProgress?.currentTime;
|
|
}
|
|
|
|
@riverpod
|
|
class CurrentBook extends _$CurrentBook {
|
|
@override
|
|
api.BookExpanded? build() {
|
|
listenSelf((previous, next) {
|
|
if (previous == null && next == null) {
|
|
final activeLibraryItemId = AvailableHiveBoxes.basicBox
|
|
.getAs<String>(CacheKey.activeLibraryItemId);
|
|
if (activeLibraryItemId != null) {
|
|
update(activeLibraryItemId, play: false);
|
|
}
|
|
}
|
|
});
|
|
return null;
|
|
}
|
|
// @override
|
|
// api.BookExpanded? build() {
|
|
// final player = ref.read(absPlayerProvider);
|
|
// player.bookStream.listen((book) {
|
|
// if (book != state) {
|
|
// state = book;
|
|
// }
|
|
// });
|
|
// return player.book;
|
|
// }
|
|
|
|
Future<void> update(String libraryItemId, {bool play = true}) async {
|
|
if (state?.libraryItemId == libraryItemId) {
|
|
ref.read(audioPlayerProvider).playOrPause();
|
|
return;
|
|
}
|
|
final book = await ref.read(libraryItemProvider(libraryItemId).future);
|
|
state = book.media.asBookExpanded;
|
|
final currentTime =
|
|
await ref.read(currentTimeProvider(libraryItemId).future);
|
|
await ref
|
|
.read(absPlayerProvider.notifier)
|
|
.load(state!, initialPosition: currentTime, play: play);
|
|
if (play) {
|
|
AvailableHiveBoxes.basicBox.put(
|
|
CacheKey.activeLibraryItemId,
|
|
libraryItemId,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
@riverpod
|
|
class CurrentChapter extends _$CurrentChapter {
|
|
@override
|
|
api.BookChapter? build() {
|
|
final player = ref.read(absPlayerProvider);
|
|
player.chapterStream.listen((chapter) {
|
|
if (chapter != state) {
|
|
state = chapter;
|
|
}
|
|
});
|
|
return player.currentChapter;
|
|
}
|
|
}
|
|
|
|
@riverpod
|
|
Stream<Duration> positionChapter(Ref ref) {
|
|
return ref.read(absPlayerProvider).positionInChapterStream;
|
|
}
|