304 lines
8.3 KiB
Dart
304 lines
8.3 KiB
Dart
import 'dart:async';
|
||
import 'package:flutter/foundation.dart';
|
||
import '../../core/core.dart';
|
||
import 'package:permission_handler/permission_handler.dart';
|
||
|
||
enum VoiceState {
|
||
listening, // Waiting for user input
|
||
processing, // Sending to AI
|
||
speaking, // AI is talking
|
||
error,
|
||
}
|
||
|
||
class VoiceSessionController extends ChangeNotifier {
|
||
final CharacterModel character;
|
||
final Function(String) onUserMessage;
|
||
final Function(ChatMessage) onAiMessage;
|
||
|
||
// Speaking Queue
|
||
final List<String> _speakQueue = [];
|
||
bool _isSpeaking = false;
|
||
Timer? _silenceTimer;
|
||
|
||
VoiceState _state = VoiceState.listening;
|
||
String _recognizedText = '';
|
||
String _aiTypingText = '';
|
||
bool _isMicMuted = false;
|
||
|
||
// Services
|
||
final STTService _stt = STTService();
|
||
final TTSService _tts = TTSService();
|
||
|
||
// State getters
|
||
VoiceState get state => _state;
|
||
String get recognizedText => _recognizedText;
|
||
String get aiTypingText => _aiTypingText;
|
||
bool get isMicMuted => _isMicMuted;
|
||
|
||
// Buffer for sentence completion
|
||
String _sentenceBuffer = '';
|
||
final List<String> _punctuation = ['。', '？', '！', '.', '?', '!', '\n'];
|
||
|
||
VoiceSessionController({
|
||
required this.character,
|
||
required this.onUserMessage,
|
||
required this.onAiMessage,
|
||
}) {
|
||
_init();
|
||
}
|
||
|
||
Future<void> _init() async {
|
||
// Request permissions
|
||
await [Permission.microphone, Permission.speech].request();
|
||
|
||
// Init services
|
||
await _stt.init();
|
||
await _tts.init();
|
||
|
||
// Setup TTS callbacks
|
||
_tts.setStartHandler(() {
|
||
debugPrint('🔊 TTS Started');
|
||
// Already paused STT in _processSpeakQueue
|
||
});
|
||
|
||
_tts.setCompletionHandler(() {
|
||
debugPrint('✅ TTS Completed');
|
||
_isSpeaking = false;
|
||
_processSpeakQueue(); // Play next
|
||
});
|
||
|
||
_tts.setErrorHandler((msg) {
|
||
debugPrint('❌ TTS Error: $msg');
|
||
_isSpeaking = false;
|
||
_processSpeakQueue();
|
||
});
|
||
|
||
// Start listening immediately
|
||
if (!_isMicMuted) {
|
||
startListening();
|
||
}
|
||
}
|
||
|
||
void toggleMic() {
|
||
_isMicMuted = !_isMicMuted;
|
||
if (_isMicMuted) {
|
||
stopListening();
|
||
} else {
|
||
if (_state == VoiceState.listening) {
|
||
startListening();
|
||
}
|
||
}
|
||
notifyListeners();
|
||
}
|
||
|
||
Future<void> startListening() async {
|
||
if (_isMicMuted) return;
|
||
|
||
_state = VoiceState.listening;
|
||
_recognizedText = '';
|
||
_lastProcessedLength = 0;
|
||
notifyListeners();
|
||
|
||
// Stop TTS if it's playing (Interruption)
|
||
if (_isSpeaking || _speakQueue.isNotEmpty) {
|
||
_speakQueue.clear();
|
||
await _tts.stop();
|
||
_isSpeaking = false;
|
||
}
|
||
|
||
await _stt.listen(
|
||
onResult: (text) {
|
||
_recognizedText = text;
|
||
notifyListeners();
|
||
},
|
||
onFinalResult: (text) {
|
||
_recognizedText = text;
|
||
notifyListeners();
|
||
_processUserMessage(text);
|
||
},
|
||
localeId: 'zh-CN', // Make dynamic later if needed
|
||
);
|
||
}
|
||
|
||
Future<void> stopListening() async {
|
||
await _stt.stop();
|
||
}
|
||
|
||
Future<void> _processUserMessage(String text) async {
|
||
if (text.trim().isEmpty) {
|
||
// If empty, just listen again
|
||
startListening();
|
||
return;
|
||
}
|
||
|
||
_state = VoiceState.processing;
|
||
onUserMessage(text); // Notify UI to show user message
|
||
notifyListeners();
|
||
|
||
// Construct history for context (simplified for now, ideally pass full history)
|
||
// We will rely on ChatService to handle the full history if we pass the latest message
|
||
// But ChatService needs the list. For the voice mode, let's assume interacting adds to DB
|
||
// and we might need to fetch fresh context or pass it in.
|
||
// Ideally, the InteractionScreen manages the source of truth for messages.
|
||
// Here we'll just send the text to prompt the AI.
|
||
|
||
// Construct history
|
||
final session = await ChatStorageService.getSession(character.id);
|
||
var messages = session.messages;
|
||
|
||
// ChatService.sendMessage appends the userMessage automatically.
|
||
// We need to ensure 'messages' doesn't already contain it (if DB write was fast).
|
||
if (messages.isNotEmpty) {
|
||
final lastMsg = messages.last;
|
||
if (lastMsg.isUser && lastMsg.content == text) {
|
||
messages = List.from(messages)..removeLast();
|
||
}
|
||
}
|
||
|
||
_aiTypingText = '';
|
||
_sentenceBuffer = '';
|
||
_lastProcessedLength = 0;
|
||
|
||
try {
|
||
final fullResponse = await ChatService.sendMessage(
|
||
character: character,
|
||
messages: messages,
|
||
userMessage: text, // ChatService handles appending this if we use the right method
|
||
onStream: (content) {
|
||
_aiTypingText = content;
|
||
_processStreamChunk(content);
|
||
notifyListeners();
|
||
},
|
||
);
|
||
|
||
// Process any remaining text in buffer
|
||
if (_sentenceBuffer.isNotEmpty) {
|
||
if (_state != VoiceState.speaking) {
|
||
_state = VoiceState.speaking;
|
||
notifyListeners();
|
||
}
|
||
await _speak(_sentenceBuffer);
|
||
}
|
||
|
||
// Interaction finished, save AI message
|
||
final aiMsg = ChatMessage.assistant(fullResponse);
|
||
onAiMessage(aiMsg);
|
||
|
||
// Note: We do NOT immediately startListening here.
|
||
// We rely on the TTS Completion Handler to trigger startListening
|
||
// when the entire queue is drained.
|
||
|
||
} catch (e) {
|
||
debugPrint('❌ Voice Process Error: $e');
|
||
_state = VoiceState.error;
|
||
notifyListeners();
|
||
// Retry listening after error
|
||
Future.delayed(const Duration(seconds: 2), startListening);
|
||
}
|
||
}
|
||
|
||
// Better implementation needs to handle state to avoid infinite loops
|
||
int _lastProcessedLength = 0;
|
||
|
||
void _processStreamChunk(String content) {
|
||
if (_state != VoiceState.speaking) {
|
||
_state = VoiceState.speaking;
|
||
notifyListeners();
|
||
}
|
||
|
||
// Calculate delta (new content only)
|
||
if (content.length <= _lastProcessedLength) return;
|
||
|
||
String delta = content.substring(_lastProcessedLength);
|
||
_lastProcessedLength = content.length;
|
||
_sentenceBuffer += delta;
|
||
|
||
// Check for punctuation to split sentences
|
||
bool foundPunctuation = false;
|
||
for (var p in _punctuation) {
|
||
if (_sentenceBuffer.contains(p)) {
|
||
foundPunctuation = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (foundPunctuation) {
|
||
_processBufferForSentences();
|
||
}
|
||
}
|
||
|
||
void _processBufferForSentences() {
|
||
String tempBuffer = _sentenceBuffer;
|
||
String keepBuffer = '';
|
||
|
||
// Simple tokenizer: split by punctuation but keep the punctuation attached to the sentence
|
||
// This is a naive implementation.
|
||
// "Hello! How are you?" -> ["Hello!", "How are you?"]
|
||
|
||
// We iterate through chars to find split points
|
||
int lastSplitIndex = 0;
|
||
|
||
for (int i = 0; i < tempBuffer.length; i++) {
|
||
String char = tempBuffer[i];
|
||
if (_punctuation.contains(char)) {
|
||
// Found end of a sentence
|
||
String sentence = tempBuffer.substring(lastSplitIndex, i + 1);
|
||
if (sentence.trim().isNotEmpty) {
|
||
_speak(sentence);
|
||
}
|
||
lastSplitIndex = i + 1;
|
||
}
|
||
}
|
||
|
||
// Keep the remaining part that didn't end with punctuation
|
||
if (lastSplitIndex < tempBuffer.length) {
|
||
keepBuffer = tempBuffer.substring(lastSplitIndex);
|
||
}
|
||
|
||
_sentenceBuffer = keepBuffer;
|
||
}
|
||
|
||
Future<void> _speak(String text) async {
|
||
// If we are listening (interrupted), ignore (or should check state)
|
||
if (_state == VoiceState.listening) return;
|
||
|
||
_speakQueue.add(text);
|
||
_processSpeakQueue();
|
||
}
|
||
|
||
void _processSpeakQueue() async {
|
||
if (_isSpeaking) return;
|
||
|
||
if (_speakQueue.isEmpty) {
|
||
// All done speaking (or no TTS was produced)
|
||
if (_state == VoiceState.speaking || _state == VoiceState.processing) {
|
||
debugPrint('🎤 Queue empty, resuming listening...');
|
||
_state = VoiceState.listening;
|
||
notifyListeners();
|
||
// Debounce STT restart to avoid rapid stop/start deadlocks
|
||
_silenceTimer?.cancel();
|
||
_silenceTimer = Timer(const Duration(milliseconds: 250), () {
|
||
startListening();
|
||
});
|
||
}
|
||
return;
|
||
}
|
||
|
||
// Pop first
|
||
String text = _speakQueue.removeAt(0);
|
||
_isSpeaking = true;
|
||
|
||
// Ensure STT is paused while speaking
|
||
await stopListening();
|
||
|
||
await _tts.speak(text);
|
||
}
|
||
|
||
@override
|
||
void dispose() {
|
||
_stt.stop();
|
||
_tts.stop();
|
||
super.dispose();
|
||
}
|
||
}
|