150 lines
3.8 KiB
Dart
150 lines
3.8 KiB
Dart
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
|
import 'package:flutter_tts/flutter_tts.dart';
|
|
import 'package:wakelock_plus/wakelock_plus.dart';
|
|
|
|
enum TtsStatus { idle, playing, paused }
|
|
|
|
class TtsState {
|
|
final TtsStatus status;
|
|
final int paragraphIndex;
|
|
final int totalParagraphs;
|
|
final double speed;
|
|
|
|
const TtsState({
|
|
this.status = TtsStatus.idle,
|
|
this.paragraphIndex = 0,
|
|
this.totalParagraphs = 0,
|
|
this.speed = 1.0,
|
|
});
|
|
|
|
TtsState copyWith({
|
|
TtsStatus? status,
|
|
int? paragraphIndex,
|
|
int? totalParagraphs,
|
|
double? speed,
|
|
}) =>
|
|
TtsState(
|
|
status: status ?? this.status,
|
|
paragraphIndex: paragraphIndex ?? this.paragraphIndex,
|
|
totalParagraphs: totalParagraphs ?? this.totalParagraphs,
|
|
speed: speed ?? this.speed,
|
|
);
|
|
|
|
bool get isPlaying => status == TtsStatus.playing;
|
|
}
|
|
|
|
class TtsNotifier extends StateNotifier<TtsState> {
|
|
final FlutterTts _tts = FlutterTts();
|
|
List<String> _paragraphs = [];
|
|
|
|
TtsNotifier() : super(const TtsState()) {
|
|
_init();
|
|
}
|
|
|
|
Future<void> _init() async {
|
|
await _tts.setLanguage('vi-VN');
|
|
await _tts.setSpeechRate(1.0);
|
|
await _tts.setVolume(1.0);
|
|
await _tts.setPitch(1.0);
|
|
|
|
_tts.setCompletionHandler(() {
|
|
if (state.status == TtsStatus.playing) {
|
|
_next();
|
|
}
|
|
});
|
|
|
|
_tts.setErrorHandler((msg) {
|
|
state = state.copyWith(status: TtsStatus.idle);
|
|
WakelockPlus.disable();
|
|
});
|
|
}
|
|
|
|
/// Start reading from [content] starting at optional [paragraphIndex].
|
|
Future<void> startReading(String content, {int paragraphIndex = 0}) async {
|
|
_paragraphs = content
|
|
.split(RegExp(r'\n+'))
|
|
.map((p) => p.trim())
|
|
.where((p) => p.isNotEmpty)
|
|
.toList();
|
|
|
|
if (_paragraphs.isEmpty) return;
|
|
|
|
final validIndex = paragraphIndex.clamp(0, _paragraphs.length - 1);
|
|
state = state.copyWith(
|
|
status: TtsStatus.playing,
|
|
paragraphIndex: validIndex,
|
|
totalParagraphs: _paragraphs.length,
|
|
);
|
|
await WakelockPlus.enable();
|
|
await _speak(validIndex);
|
|
}
|
|
|
|
Future<void> _speak(int index) async {
|
|
if (index >= _paragraphs.length) {
|
|
state = state.copyWith(status: TtsStatus.idle);
|
|
await WakelockPlus.disable();
|
|
return;
|
|
}
|
|
await _tts.setSpeechRate(state.speed);
|
|
await _tts.speak(_paragraphs[index]);
|
|
}
|
|
|
|
Future<void> _next() async {
|
|
final next = state.paragraphIndex + 1;
|
|
if (next >= state.totalParagraphs) {
|
|
state = state.copyWith(status: TtsStatus.idle, paragraphIndex: 0);
|
|
await WakelockPlus.disable();
|
|
return;
|
|
}
|
|
state = state.copyWith(paragraphIndex: next);
|
|
await _speak(next);
|
|
}
|
|
|
|
Future<void> pause() async {
|
|
await _tts.pause();
|
|
state = state.copyWith(status: TtsStatus.paused);
|
|
await WakelockPlus.disable();
|
|
}
|
|
|
|
Future<void> resume() async {
|
|
if (state.status != TtsStatus.paused) return;
|
|
state = state.copyWith(status: TtsStatus.playing);
|
|
await WakelockPlus.enable();
|
|
await _speak(state.paragraphIndex);
|
|
}
|
|
|
|
Future<void> stop() async {
|
|
await _tts.stop();
|
|
state = state.copyWith(status: TtsStatus.idle, paragraphIndex: 0);
|
|
await WakelockPlus.disable();
|
|
}
|
|
|
|
Future<void> skipForward() async {
|
|
await _tts.stop();
|
|
await _next();
|
|
}
|
|
|
|
Future<void> skipBack() async {
|
|
await _tts.stop();
|
|
final prev = (state.paragraphIndex - 1).clamp(0, state.totalParagraphs - 1);
|
|
state = state.copyWith(paragraphIndex: prev);
|
|
if (state.status == TtsStatus.playing) await _speak(prev);
|
|
}
|
|
|
|
Future<void> setSpeed(double speed) async {
|
|
state = state.copyWith(speed: speed);
|
|
await _tts.setSpeechRate(speed);
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_tts.stop();
|
|
WakelockPlus.disable();
|
|
super.dispose();
|
|
}
|
|
}
|
|
|
|
final ttsProvider = StateNotifierProvider<TtsNotifier, TtsState>((ref) {
|
|
return TtsNotifier();
|
|
});
|