groove/Vaani
1
0
Fork 0
mirror of https://github.com/Dr-Blank/Vaani.git synced 2026-02-17 23:09:36 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

更改播放逻辑

Browse source
This commit is contained in:
rang 2025-12-08 17:54:08 +08:00
parent 290b68336f
commit 420438c0df
29 changed files with 810 additions and 514 deletions
Download patch file Download diff file Expand all files Collapse all files

243
lib/features/player/providers/abs_provider.dart
View file

@ -1,192 +1,111 @@
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:logging/logging.dart';
import 'package:media_kit/media_kit.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/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' as core;
import 'package:vaani/features/player/core/abs_audio_player.dart' as core;
import 'package:vaani/features/player/core/audiobook_player.dart';
import 'package:vaani/features/settings/app_settings_provider.dart';
import 'package:vaani/globals.dart';
import 'package:vaani/shared/extensions/chapter.dart';
import 'package:vaani/shared/audio_player.dart' as core;
import 'package:vaani/shared/audio_player_mpv.dart';
part 'abs_provider.g.dart';
final _logger = Logger('AbsPlayerProvider');
@Riverpod(keepAlive: true)
Future<core.AbsAudioHandler> absAudioHandlerInit(Ref ref) async {
// for playing audio on windows, linux
MediaKit.ensureInitialized();
// 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: () => core.AbsAudioHandler(ref),
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;
}
@Riverpod(keepAlive: true)
class AbsPlayer extends _$AbsPlayer {
class AbsAudioPlayer extends _$AbsAudioPlayer {
@override
core.AbsAudioHandler build() {
return ref.read(absAudioHandlerInitProvider).valueOrNull!;
}
}
@Riverpod(keepAlive: true)
class AbsState extends _$AbsState {
@override
core.AbsPlayerState build() {
return core.AbsPlayerState();
core.AbsAudioPlayer build() {
final player = AbsMpvAudioPlayer();
return player;
}
// 加载书籍
Future<void> load(api.BookExpanded book, Duration? currentTime) async {
final player = ref.read(absPlayerProvider);
if (state.book == book || state.book?.libraryItemId == book.libraryItemId) {
appLogger.info('Book was already set');
player.playOrPause();
Future<void> load(
api.BookExpanded book, {
Duration? initialPosition,
}) async {
if (state.book == book) {
state.playOrPause();
return;
}
final appSettings = ref.read(appSettingsProvider);
final api = ref.read(authenticatedApiProvider);
final downloadManager = ref.read(simpleDownloadManagerProvider);
final libItem =
await ref.read(libraryItemProvider(book.libraryItemId).future);
final downloadedUris = await downloadManager.getDownloadedFilesUri(libItem);
var bookPlayerSettings =
ref.read(bookSettingsProvider(book.libraryItemId)).playerSettings;
var appPlayerSettings = ref.read(appSettingsProvider).playerSettings;
var configurePlayerForEveryBook =
appPlayerSettings.configurePlayerForEveryBook;
final trackToPlay = book.findTrackAtTime(currentTime ?? Duration.zero);
final chapterToPlay = book.findChapterAtTime(currentTime ?? Duration.zero);
final initialIndex = book.tracks.indexOf(trackToPlay);
final initialPositionInTrack =
currentTime != null ? currentTime - trackToPlay.startOffset : null;
final album = appSettings.notificationSettings.primaryTitle
.formatNotificationTitle(book);
final artlist = appSettings.notificationSettings.secondaryTitle
.formatNotificationTitle(book);
final id = _getUri(trackToPlay, downloadedUris,
baseUrl: api.baseUrl, token: api.token!)
.toString();
final item = MediaItem(
id: id,
title: chapterToPlay.title,
album: album,
artist: artlist,
duration: chapterToPlay.duration,
artUri: Uri.parse(
'${api.baseUrl}/api/items/${book.libraryItemId}/cover?token=${api.token!}',
),
await state.load(
book,
baseUrl: api.baseUrl,
token: api.token!,
initialPosition: initialPosition,
);
state = state.copyWith(
book: book,
currentChapter: chapterToPlay,
currentIndex: initialIndex,
);
player.playMediaItem(item);
await Future.wait([
player.setMediaItem(item),
// player.setVolume(
// configurePlayerForEveryBook
// ? bookPlayerSettings.preferredDefaultVolume ??
// appPlayerSettings.preferredDefaultVolume
// : appPlayerSettings.preferredDefaultVolume,
// ),
player.setSpeed(
configurePlayerForEveryBook
? bookPlayerSettings.preferredDefaultSpeed ??
appPlayerSettings.preferredDefaultSpeed
: appPlayerSettings.preferredDefaultSpeed,
),
player.play(),
]);
// player.setSourceAudiobook(
// book,
// baseUrl: api.baseUrl,
// token: api.token!,
// initialPosition: currentTime,
// downloadedUris: downloadedUris,
// volume: configurePlayerForEveryBook
// ? bookPlayerSettings.preferredDefaultVolume ??
// appPlayerSettings.preferredDefaultVolume
// : appPlayerSettings.preferredDefaultVolume,
// speed: configurePlayerForEveryBook
// ? bookPlayerSettings.preferredDefaultSpeed ??
// appPlayerSettings.preferredDefaultSpeed
// : appPlayerSettings.preferredDefaultSpeed,
// );
await state.play();
}
}
Future<void> next() async {}
Future<void> previous() async {}
void updataPlaying(bool playing) {
state = state.copyWith(playing: playing);
}
Stream<Duration> get positionStreamInChapter {
final player = ref.read(absPlayerProvider);
return player.stream.position.distinct().map((position) {
return position +
(state.book?.tracks[state.currentIndex].startOffset ??
Duration.zero) -
(state.currentChapter?.start ?? Duration.zero);
@riverpod
class PlayerState extends _$PlayerState {
@override
core.PlayerState build() {
final player = ref.read(absAudioPlayerProvider);
player.playerStateStream.listen((playerState) {
if (playerState != state) {
state = playerState;
}
});
return player.playerState;
}
}
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;
},
);
@riverpod
class CurrentBook extends _$CurrentBook {
@override
api.BookExpanded? build() {
final player = ref.read(absAudioPlayerProvider);
player.bookStream.listen((book) {
if (book != state) {
state = book;
}
});
return player.book;
}
}
return uri ??
Uri.parse('${baseUrl.toString()}${track.contentUrl}?token=$token');
@riverpod
bool isPlayerActive(Ref ref) {
final player = ref.read(absAudioPlayerProvider);
player.bookStream.listen((book) {
ref.invalidateSelf();
});
return player.book != null;
}
@riverpod
class CurrentChapter extends _$CurrentChapter {
@override
api.BookChapter? build() {
final player = ref.read(absAudioPlayerProvider);
player.chapterStream.listen((chapter) {
if (chapter != state) {
state = chapter;
}
});
return player.currentChapter;
}
}
@riverpod
Stream<Duration> positionChapter(Ref ref) {
return ref.watch(absStateProvider.notifier).positionStreamInChapter;
return ref.read(absAudioPlayerProvider).positionInChapterStream;
}
@riverpod
List<api.BookChapter> currentChapters(Ref ref) {
final book = ref.watch(currentBookProvider);
if (book == null) {
return [];
}
final currentChapter = ref.watch(currentChapterProvider);
if (currentChapter == null) {
return [];
}
final index = book.chapters.indexOf(currentChapter);
final total = book.chapters.length;
final start = index - 3 >= 0 ? index - 3 : 0;
final end = start + 20 <= total ? start + 20 : total;
return book.chapters.sublist(start, end);
}