Initial commit
This commit is contained in:
admin1
@@ -0,0 +1,279 @@
|
||||
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
||||
|
||||
import '../../../../core/contracts/cancellation.dart';
|
||||
import '../../../../core/contracts/danmaku.dart';
|
||||
import '../../../../core/domain/ports/danmaku_gateway.dart';
|
||||
import '../../../../core/media/danmaku_comment_pipeline.dart';
|
||||
import '../../../../providers/danmaku_settings_provider.dart';
|
||||
import '../../../../providers/di_providers.dart';
|
||||
import '../../../../shared/utils/app_logger.dart';
|
||||
import 'danmaku_matcher.dart';
|
||||
|
||||
const _tag = 'DanmakuSession';
|
||||
|
||||
class DanmakuSessionNotifier extends AsyncNotifier<DanmakuSessionState> {
|
||||
late final DanmakuGateway _gateway;
|
||||
late final DanmakuMatcher _matcher;
|
||||
|
||||
CancellationToken? _token;
|
||||
String? _currentItemId;
|
||||
List<DanmakuSource> _sources = const [];
|
||||
int _chConvert = 0;
|
||||
|
||||
@override
|
||||
Future<DanmakuSessionState> build() async {
|
||||
_gateway = ref.read(danmakuGatewayProvider);
|
||||
_matcher = DanmakuMatcher(gateway: _gateway);
|
||||
ref.onDispose(() => _token?.cancel('notifier disposed'));
|
||||
return const DanmakuSessionIdle();
|
||||
}
|
||||
|
||||
Future<void> loadFor(DanmakuMatchContext context) async {
|
||||
final token = _swapToken('loadFor:${context.itemId}');
|
||||
_currentItemId = context.itemId;
|
||||
|
||||
final settings = _readSettings();
|
||||
final sources = settings.enabledSources;
|
||||
if (!settings.enabled || sources.isEmpty) {
|
||||
AppLogger.debug(
|
||||
_tag,
|
||||
'loadFor(${context.itemId}) -> Idle: '
|
||||
'enabled=${settings.enabled} sources=${sources.length}',
|
||||
);
|
||||
_sources = const [];
|
||||
state = const AsyncData(DanmakuSessionIdle());
|
||||
return;
|
||||
}
|
||||
|
||||
_sources = sources;
|
||||
_chConvert = _chConvertFromMode(settings.chineseConvert);
|
||||
state = const AsyncData(DanmakuSessionMatching());
|
||||
|
||||
try {
|
||||
final result = await _matcher.resolve(
|
||||
sources: _sources,
|
||||
context: context,
|
||||
cancelToken: token,
|
||||
);
|
||||
if (_isStale(token, context.itemId)) return;
|
||||
|
||||
if (result.matches.isEmpty || result.pickedIndex < 0) {
|
||||
AppLogger.info(
|
||||
_tag,
|
||||
'loadFor(${context.itemId}) -> Empty: no matches found',
|
||||
);
|
||||
state = const AsyncData(DanmakuSessionEmpty());
|
||||
return;
|
||||
}
|
||||
|
||||
state = AsyncData(
|
||||
DanmakuSessionMatched(
|
||||
matches: result.matches,
|
||||
selectedIndex: result.pickedIndex,
|
||||
commentStatus: DanmakuCommentStatus.loading,
|
||||
),
|
||||
);
|
||||
|
||||
AppLogger.debug(
|
||||
_tag,
|
||||
'auto-select index=${result.pickedIndex} '
|
||||
'(target ep=${context.episode})',
|
||||
);
|
||||
await _loadCommentsForCurrent(token: token);
|
||||
} on CancelledException {
|
||||
return;
|
||||
} catch (e, st) {
|
||||
if (_isStale(token, context.itemId)) return;
|
||||
AppLogger.error(_tag, 'loadFor failed', e, st);
|
||||
state = AsyncData(DanmakuSessionFailed(e.toString()));
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> selectMatch(int index) async {
|
||||
final current = state.value;
|
||||
if (current is! DanmakuSessionMatched) return;
|
||||
if (index < 0 || index >= current.matches.length) return;
|
||||
if (index == current.selectedIndex &&
|
||||
current.commentStatus == DanmakuCommentStatus.ready) {
|
||||
return;
|
||||
}
|
||||
|
||||
final token = _swapToken('selectMatch:$index');
|
||||
state = AsyncData(
|
||||
current.copyWith(
|
||||
selectedIndex: index,
|
||||
commentStatus: DanmakuCommentStatus.loading,
|
||||
),
|
||||
);
|
||||
await _loadCommentsForCurrent(token: token);
|
||||
}
|
||||
|
||||
Future<void> applyManualSelection({
|
||||
required DanmakuSource source,
|
||||
required int episodeId,
|
||||
required int animeId,
|
||||
required String animeTitle,
|
||||
required String episodeTitle,
|
||||
}) async {
|
||||
if (source.url.isEmpty || episodeId <= 0) return;
|
||||
final current = state.value;
|
||||
final picked = DanmakuMatchCandidate(
|
||||
source: source,
|
||||
match: DanmakuMatch(
|
||||
episodeId: episodeId,
|
||||
animeId: animeId,
|
||||
animeTitle: animeTitle,
|
||||
episodeTitle: episodeTitle,
|
||||
),
|
||||
);
|
||||
|
||||
final previous = current is DanmakuSessionMatched ? current : null;
|
||||
final newMatches = previous == null
|
||||
? [picked]
|
||||
: [
|
||||
picked,
|
||||
...previous.matches.where(
|
||||
(m) => m.episodeId != episodeId || m.source.url != source.url,
|
||||
),
|
||||
];
|
||||
|
||||
final token = _swapToken('applyManual:$episodeId');
|
||||
state = AsyncData(
|
||||
DanmakuSessionMatched(
|
||||
matches: newMatches,
|
||||
selectedIndex: 0,
|
||||
commentStatus: DanmakuCommentStatus.loading,
|
||||
),
|
||||
);
|
||||
|
||||
try {
|
||||
await _loadCommentsForCurrent(token: token);
|
||||
} catch (_) {
|
||||
if (_isStale(token, _currentItemId)) return;
|
||||
if (previous != null) {
|
||||
state = AsyncData(previous);
|
||||
} else {
|
||||
state = const AsyncData(DanmakuSessionEmpty());
|
||||
}
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
Future<List<DanmakuMatchCandidate>?> manualSearch(String query) async {
|
||||
final trimmed = query.trim();
|
||||
if (_sources.isEmpty || trimmed.isEmpty) return const [];
|
||||
final token = _token;
|
||||
final results = <DanmakuMatchCandidate>[];
|
||||
|
||||
for (final source in _sources) {
|
||||
List<DanmakuMatch> matches;
|
||||
try {
|
||||
matches = await _gateway.match(source.url, trimmed, 0);
|
||||
} on CancelledException {
|
||||
return null;
|
||||
} catch (e) {
|
||||
if (token != null && token.isCancelled) return null;
|
||||
AppLogger.warn(_tag, 'manualSearch source "${source.url}" failed', e);
|
||||
continue;
|
||||
}
|
||||
if (token != null && token.isCancelled) return null;
|
||||
results.addAll(
|
||||
matches.map(
|
||||
(match) => DanmakuMatchCandidate(source: source, match: match),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
Future<List<DanmakuBangumiEpisode>?> listEpisodesForAnime(
|
||||
DanmakuSource source,
|
||||
int animeId,
|
||||
) async {
|
||||
if (source.url.isEmpty || animeId <= 0) return const [];
|
||||
final token = _token;
|
||||
final res = await _gateway.getBangumiEpisodes(source.url, animeId);
|
||||
if (token != null && token.isCancelled) return null;
|
||||
return res;
|
||||
}
|
||||
|
||||
Future<void> _loadCommentsForCurrent({
|
||||
required CancellationToken token,
|
||||
}) async {
|
||||
final current = state.value;
|
||||
if (current is! DanmakuSessionMatched) return;
|
||||
final selected = current.matches[current.selectedIndex];
|
||||
final episodeId = selected.episodeId;
|
||||
final settings = _readSettings();
|
||||
|
||||
try {
|
||||
final raw = await _gateway.fetchComments(
|
||||
selected.source.url,
|
||||
episodeId,
|
||||
chConvert: _chConvert,
|
||||
);
|
||||
token.throwIfCancelled();
|
||||
final comments = processDanmakuComments(
|
||||
raw,
|
||||
blockedKeywords: settings.blockedKeywords,
|
||||
mergeDuplicates: settings.mergeDuplicates,
|
||||
);
|
||||
if (_isStale(token, _currentItemId)) return;
|
||||
AppLogger.debug(
|
||||
_tag,
|
||||
'comments ready from "${selected.source.displayName}" '
|
||||
'for ep=$episodeId: ${comments.length} items',
|
||||
);
|
||||
final cur = state.value;
|
||||
if (cur is DanmakuSessionMatched) {
|
||||
state = AsyncData(
|
||||
cur.copyWith(
|
||||
commentStatus: DanmakuCommentStatus.ready,
|
||||
comments: comments,
|
||||
),
|
||||
);
|
||||
}
|
||||
} on CancelledException {
|
||||
return;
|
||||
} catch (e) {
|
||||
if (_isStale(token, _currentItemId)) return;
|
||||
AppLogger.warn(_tag, 'load comments failed for ep=$episodeId', e);
|
||||
final cur = state.value;
|
||||
if (cur is DanmakuSessionMatched) {
|
||||
state = AsyncData(
|
||||
cur.copyWith(commentStatus: DanmakuCommentStatus.failed),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CancellationToken _swapToken(String reason) {
|
||||
_token?.cancel(reason);
|
||||
final t = CancellationToken();
|
||||
_token = t;
|
||||
return t;
|
||||
}
|
||||
|
||||
bool _isStale(CancellationToken token, String? itemIdAtStart) {
|
||||
if (token.isCancelled) return true;
|
||||
if (token != _token) return true;
|
||||
if (itemIdAtStart != null && itemIdAtStart != _currentItemId) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
DanmakuSettingsState _readSettings() =>
|
||||
ref.read(danmakuSettingsProvider).value ?? const DanmakuSettingsState();
|
||||
|
||||
static int _chConvertFromMode(ChineseConvertMode mode) => switch (mode) {
|
||||
ChineseConvertMode.toSimplified => 1,
|
||||
ChineseConvertMode.toTraditional => 2,
|
||||
ChineseConvertMode.none => 0,
|
||||
};
|
||||
}
|
||||
|
||||
final danmakuSessionProvider =
|
||||
AsyncNotifierProvider.autoDispose<
|
||||
DanmakuSessionNotifier,
|
||||
DanmakuSessionState
|
||||
>(DanmakuSessionNotifier.new);
|
||||
Reference in New Issue
Block a user