firebase_ai liveGenerativeModel() live transcription for user voice is not accurate

[Magesh-kanna]

[READ] Step 1: Are you in the right place?

Issues filed here should be about bugs in the code in this repository. If you have a general
question, need help debugging, or fall into some other category use one of these other channels:

• For general technical questions, post a question on StackOverflow
  with the firebase tag.
• For general Firebase discussion, use the
  firebase-talk google group.
• For help troubleshooting your application that does not fall under one of the above categories,
  reach out to the personalized Firebase support channel.

[REQUIRED] Step 2: Describe your environment

• Android Studio version: Anti-gravity latest version
• Firebase Component: (firebase_ai, firebase logic)
• Component version: firebase_ai: 3.7.0

[REQUIRED] Step 3: Describe the problem

I've implemented the firebase_ai liveGenerativeModel plugin in my flutter app and the live transcription is not accurate when the user is speaking to AI - but AI picks up the correct sentence and live transcription gives the wrong text and the UI is reflected accordingly.

Steps to reproduce:

Start the session and start talking to AI - you'll see the live transcription mismatch with the actual user voice - but AI picks the correct input.

Relevant Code:

import 'dart:async';
import 'dart:convert';
import 'dart:developer';
import 'dart:io';
import 'dart:typed_data';

import 'package:firebase_ai/firebase_ai.dart';
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:flutter_soloud/flutter_soloud.dart';
import 'package:flutter_svg/svg.dart';
import 'package:go_router/go_router.dart';
import 'package:lottie/lottie.dart';
import 'package:phosphor_flutter/phosphor_flutter.dart';
import 'package:record/record.dart';
import 'package:uuid/uuid.dart';
import 'package:whomie/core/constants/app_colors.dart';
import 'package:whomie/core/constants/image_path.dart';
import 'package:whomie/core/constants/internet_status.dart';
import 'package:whomie/core/database/app_database.dart';
import 'package:whomie/core/helper/entry_feedback_helper.dart';
import 'package:whomie/core/helper/logger_helper.dart';
import 'package:whomie/core/helper/text_helper.dart';
import 'package:whomie/core/helper/voice_prompt_generator.dart';
import 'package:whomie/core/helper/whomie_toast.dart';
import 'package:whomie/core/presentation/widgets/whomie_app_bar.dart';
import 'package:whomie/core/presentation/widgets/whomie_scaffold.dart';
import 'package:whomie/core/providers/internet_status_provider.dart';
import 'package:whomie/core/services/fcm_service.dart';
import 'package:whomie/core/services/feature_flagging.dart';
import 'package:whomie/core/services/profile_service.dart';
import 'package:whomie/features/auth/data/auth_repository.dart';
import 'package:whomie/features/journal/data/journal_repository.dart';
import 'package:whomie/features/journal/data/journal_service.dart';
import 'package:whomie/features/journal/presentation/providers/voice_journal_persistence_provider.dart';
import 'package:whomie/features/mood/data/mood_repository.dart';
import 'package:whomie/features/mood/presentation/providers/mood_checkin_provider.dart';

class VoiceJournalScreen extends ConsumerStatefulWidget {
  final String? sessionId;
  final double? initialMood;

  const VoiceJournalScreen({super.key, this.sessionId, this.initialMood});

  @override
  ConsumerState<VoiceJournalScreen> createState() => _VoiceJournalScreenState();
}

class _VoiceJournalScreenState extends ConsumerState<VoiceJournalScreen>
    with SingleTickerProviderStateMixin {
  // Gemini Live Model & Session
  late LiveGenerativeModel _liveModel;
  LiveSession? _session;

  // Audio recording & playback
  final _recorder = AudioRecorder();
  AudioSource? _audioSrc;
  SoundHandle? _handle;
  bool _disposed = false;

  // State Management
  bool _audioReady = false;
  bool _settingUpSession = false;
  bool _conversationActive = false;
  bool _isAiSpeaking = false;
  StreamController<bool>? _stopController;
  StreamController<InlineDataPart>? _geminiStreamController;

  late String _sessionId;
  final List<Map<String, dynamic>> _messages = [];
  final ScrollController _scrollController = ScrollController();
  late AnimationController _pulseController;
  String? _lastAdvice;

  StreamSubscription<Uint8List>? _micSubscription;

  // Solution tracking
  List<Map<String, String>> _currentSolutions = [];

  @override
  void initState() {
    super.initState();
    _sessionId = widget.sessionId ?? const Uuid().v4();

    _pulseController = AnimationController(
      vsync: this,
      duration: const Duration(seconds: 1),
    )..repeat(reverse: true);

    WidgetsBinding.instance.addPostFrameCallback((_) async {
      if (mounted) {
        await _initializeLiveModel();
        await _initializeAudio();
        if (mounted) {
          _startConversation();
        }
      }
      if (widget.sessionId != null) {
        _loadHistory();
      }
    });

    // Trigger premium entry feel
    EntryFeedbackHelper.triggerPremiumEntry();
  }

  Future<void> _initializeLiveModel() async {
    setState(() => _settingUpSession = true);
    try {
      final moodLabel = widget.initialMood != null
          ? _getMoodLabel(widget.initialMood!)
          : 'neutral';
      final prompt = await VoicePromptGenerator.generatePrompt(
        userMessage: "",
        ref: ref,
        moodLabel: moodLabel,
      );

      // Getting the AI Model name from the remote config.
      final voiceAIModelNamefromRemoteConfig = FeatureFlags.aiVoiceModel;
      LoggerHelper.whomieLog(
        '🚀 Remote Config AI Model Name Voice: $voiceAIModelNamefromRemoteConfig',
      );

      final model = voiceAIModelNamefromRemoteConfig != ''
          ? voiceAIModelNamefromRemoteConfig
          : 'gemini-2.0-flash-live-preview-04-09';

      LoggerHelper.whomieLog('USED AI Model Name Voice: $model');

      _liveModel = FirebaseAI.vertexAI().liveGenerativeModel(
        model: model,
        systemInstruction: Content.text(prompt),
        liveGenerationConfig: LiveGenerationConfig(
          speechConfig: SpeechConfig(
            voiceName: FeatureFlags.aiVoiceName != ''
                ? FeatureFlags.aiVoiceName
                : 'zephyr',
          ),
          responseModalities: [ResponseModalities.audio],
          inputAudioTranscription: AudioTranscriptionConfig(),
          outputAudioTranscription: AudioTranscriptionConfig(),
        ),
        tools: [
          Tool.functionDeclarations([
            FunctionDeclaration(
              'provideSolutions',
              'Provides exactly 3 actionable solutions, an empathic summary, and optionally a notification reminder to the user.',
              parameters: {
                'advice': Schema.string(
                  description: 'Empathic summary and feedback for the user.',
                ),
                'solutions': Schema.array(
                  description:
                      'Exactly 3 actionable options. Each MUST have a text and a category (physical, mental, or emotional).',
                  items: Schema.object(
                    properties: {
                      'text': Schema.string(description: 'The solution text.'),
                      'category': Schema.string(
                        description:
                            'Category: "physical", "mental", or "emotional".',
                      ),
                    },
                  ),
                ),
                'notification': Schema.object(
                  description:
                      'Optional notification settings. Null if no follow-up is needed.',
                  properties: {
                    'date': Schema.string(
                      description: 'Date in YYYY-MM-DD format.',
                    ),
                    'frequency': Schema.string(
                      description: 'Frequency: "once", "daily", or "weekly".',
                    ),
                    'time': Schema.string(
                      description:
                          'Time in HH:MM AM/PM format (e.g., "09:00 AM").',
                    ),
                  },
                  nullable: true,
                  optionalProperties: ['date', 'frequency', 'time'],
                ),
              },
            ),
          ]),
        ],
      );
      LoggerHelper.whomieLog('✅ Live Model initialized');
    } catch (e) {
      LoggerHelper.whomieLog('❌ Error setting up live model: $e');
    } finally {
      if (mounted) setState(() => _settingUpSession = false);
    }
  }

  Future<void> _initializeAudio() async {
    try {
      final hasPermission = await _recorder.hasPermission();
      if (!hasPermission) {
        if (mounted) {
          WhomieToast.error(
            context: context,
            text: 'Microphone permission is required.',
          );
        }
        return;
      }

      if (!SoLoud.instance.isInitialized) {
        await SoLoud.instance.init(sampleRate: 24000, channels: Channels.mono);
      }
      if (mounted) setState(() => _audioReady = true);
    } catch (e) {
      log("Error initializing audio: $e");
    }
  }

  Future<void> _loadHistory() async {
    final repository = ref.read(journalRepositoryProvider);
    final entries = await repository.watchSessionEntries(_sessionId).first;

    if (mounted) {
      setState(() {
        for (var entry in entries) {
          if (entry.content.isNotEmpty) {
            _messages.add({
              'role': entry.isUser ? 'user' : 'ai',
              'content': entry.content,
            });
          }
        }
      });
      _scrollToBottom(delayed: true);
    }
  }

  void _scrollToBottom({bool delayed = false}) {
    // If delayed, wait for animations (like the AnimatedSwitcher 400ms duration)
    final delay = delayed ? const Duration(milliseconds: 300) : Duration.zero;

    Future.delayed(delay, () {
      if (!mounted) return;
      WidgetsBinding.instance.addPostFrameCallback((_) {
        if (_scrollController.hasClients) {
          _scrollController.animateTo(
            _scrollController.position.maxScrollExtent,
            duration: const Duration(milliseconds: 200),
            curve: Curves.easeOut,
          );
        }
      });
    });
  }

  Future<void> _toggleConversation() async {
    if (_conversationActive) {
      await _stopConversation();
    } else {
      await _startConversation();
    }
  }

  // FIXED: Start mic streaming - simplified and clean
  Future<void> _startMicStreaming() async {
    if (_micSubscription != null || _session == null) {
      log("⚠️ Mic already active or session null");
      return;
    }

    log("🎤 Initializing mic stream...");

    final recordConfig = RecordConfig(
      encoder: AudioEncoder.pcm16bits,
      sampleRate: 24000,
      numChannels: 1,
      echoCancel: true,
      noiseSuppress: true,
      androidConfig: const AndroidRecordConfig(
        audioSource: AndroidAudioSource.voiceCommunication,
      ),
      iosConfig: const IosRecordConfig(
        categoryOptions: [IosAudioCategoryOption.defaultToSpeaker],
      ),
    );

    try {
      final inputStream = await _recorder.startStream(recordConfig);
      _micSubscription = inputStream.listen((data) {
        // GATING LOGIC: Only send to Gemini if AI is NOT speaking and session is active
        if (_geminiStreamController != null &&
            !_geminiStreamController!.isClosed &&
            !_isAiSpeaking) {
          _geminiStreamController!.add(InlineDataPart('audio/pcm', data));
        }
      });

      log('✅ Mic initialized and listener started');
    } catch (e) {
      log('❌ Error initializing mic stream: $e');
      _micSubscription = null;
    }
  }

  // FIXED: Stop mic streaming - actually stops the recording
  Future<void> _stopMicStreaming() async {
    log('🛑 Stopping mic completely...');
    try {
      if (_micSubscription != null) {
        await _micSubscription!.cancel();
        _micSubscription = null;
      }
      // Check if recorder is disposed before accessing it
      if (!_disposed) {
        try {
          if (await _recorder.isRecording()) {
            await _recorder.stop();
          }
        } catch (e) {
          // Recorder may already be disposed, ignore this specific error
          log('⚠️ Recorder access skipped (might already be disposed)');
        }
      }
      log('✅ Mic stopped successfully');
    } catch (e) {
      log('⚠️ Error stopping mic streaming: $e');
    }
  }

  // FIXED: Wait for playback completion
  Future<void> _waitForPlaybackCompletion() async {
    log("🔊 Waiting for AI playback to complete...");

    if (_handle == null || _audioSrc == null) {
      log("⚠️ No active audio handle");
      _isAiSpeaking = false;
      return;
    }

    // Small delay to ensure audio has started
    await Future.delayed(const Duration(milliseconds: 150));

    // Wait for playback to finish naturally
    int checkCount = 0;
    const maxChecks = 300; // 30 second timeout

    while (mounted && _handle != null && checkCount < maxChecks) {
      final isValid = SoLoud.instance.getIsValidVoiceHandle(_handle!);

      if (!isValid) {
        log(
          "✅ Audio playback finished after $checkCount checks (~${checkCount * 100}ms)",
        );
        break;
      }

      checkCount++;
      await Future.delayed(const Duration(milliseconds: 100));
    }

    if (checkCount >= maxChecks) {
      log("⚠️ Playback timeout reached");
    }

    if (!mounted) return;

    // Clean up handle
    _handle = null;
    _isAiSpeaking = false;

    log("🎤 Playback complete, Whomie is listening again.");
  }

  Future<void> _startConversation() async {
    if (!_audioReady) return;

    setState(() {
      _settingUpSession = true;
      _currentSolutions = [];
    });

    try {
      // 1. Connect to Gemini Live
      log("🚀 Connecting to Whomie AI Voice Live...");
      _session = await _liveModel.connect();
      log("✅ Connected");

      // Initialize persistent stream for Gemini
      _geminiStreamController = StreamController<InlineDataPart>();
      _session!.sendMediaStream(_geminiStreamController!.stream);

      _stopController = StreamController<bool>();
      unawaited(_processMessagesContinuously());

      await _startMicStreaming();

      setState(() {
        _conversationActive = true;
        _settingUpSession = false;
      });
    } catch (e) {
      if (mounted) {
        setState(() => _settingUpSession = false);
        String errorMsg = 'Error starting conversation: $e';
        bool isRateLimit =
            e.toString().contains('429') ||
            e.toString().contains('Resource exhausted');

        if (isRateLimit) {
          errorMsg =
              "I am busy with lot of people trying, I'm working on it. Please wait.";
          WhomieToast.warning(
            context: context,
            text: errorMsg,
            subtitle: 'Please try saying again',
          );
          setState(() {
            _messages.add({
              'role': 'ai',
              'content': errorMsg,
              'timestamp': DateTime.now(),
            });
            _conversationActive = false;
          });
        } else {
          WhomieToast.error(
            context: context,
            text: errorMsg,
            subtitle: 'Please try saying again',
          );
        }
      }
    }
  }

  Future<void> _stopConversation({bool updateUi = true}) async {
    if (updateUi && mounted) {
      setState(() {
        _settingUpSession = true;
      });
    }

    try {
      await _stopMicStreaming();
      // await _recorder.stop();
      if (_audioSrc != null) {
        SoLoud.instance.setDataIsEnded(_audioSrc!);
      }
      if (_handle != null) {
        await SoLoud.instance.stop(_handle!);
      }

      await _session?.close();
      if (_geminiStreamController != null &&
          !_geminiStreamController!.isClosed) {
        await _geminiStreamController?.close();
        _geminiStreamController = null;
      }
      if (_stopController != null && !_stopController!.isClosed) {
        _stopController?.add(true);
        await _stopController?.close();
      }

      if (updateUi && mounted) {
        setState(() {
          _conversationActive = false;
          _isAiSpeaking = false;
          _settingUpSession = false;
        });
      }
    } catch (e) {
      log("Error stopping conversation: $e");
      if (updateUi && mounted) {
        setState(() => _settingUpSession = false);
      }
    }
  }

  Future<void> _processMessagesContinuously() async {
    if (_session == null) return;

    bool shouldContinue = true;
    _stopController!.stream.listen((stop) {
      if (stop) shouldContinue = false;
    });

    while (shouldContinue) {
      try {
        await for (final response in _session!.receive()) {
          log("Gemini Server Response type: ${response.runtimeType}");
          // response is usually LiveServerResponse which has a 'message' field
          try {
            final dynamic resp = response;
            if (resp.message is LiveServerMessage) {
              await _handleLiveServerMessage(resp.message as LiveServerMessage);
            } else if (resp is LiveServerMessage) {
              await _handleLiveServerMessage(resp);
            }
          } catch (e) {
            log("Error parsing response: $e");
          }
        }
      } catch (e) {
        if (e.toString().contains('closed') || e.toString().contains('1006')) {
          log("⚠️ Connection lost in _processMessagesContinuously: $e");
          if (mounted && _conversationActive) {
            WhomieToast.error(
              context: context,
              text: 'Connection lost',
              subtitle: 'Please restart the session',
            );
            _stopConversation();
          }
          break;
        }
        LoggerHelper.whomieLog("Error in message processing: $e");
        await Future.delayed(const Duration(seconds: 1));
      }
    }
  }

  Future<void> _handleLiveServerMessage(LiveServerMessage message) async {
    try {
      log("Handling Server Message type: ${message.runtimeType}");
      if (message is LiveServerContent) {
        if (message.modelTurn != null) {
          log("📦 Got LiveServerContent with modelTurn");
        }
        if (message.turnComplete == true) {
          log("🔚 Turn Complete");
        }
        if (message.interrupted == true) {
          log("⚠️ Interrupted");
        }
        final parts = message.modelTurn?.parts;
        if (parts != null) {
          if (!mounted) return;

          if (!_isAiSpeaking) {
            setState(() => _isAiSpeaking = true);
            // Create a fresh audio source for this turn
            _audioSrc = SoLoud.instance.setBufferStream(
              bufferingType: BufferingType.released,
              bufferingTimeNeeds: 0,
            );
            _handle = await SoLoud.instance.play(_audioSrc!);
          }

          for (final part in parts) {
            if (part is TextPart) {
              _updateTranscription(part.text, isUser: false);
            } else if (part is InlineDataPart) {
              if (part.mimeType.startsWith('audio') && _audioSrc != null) {
                SoLoud.instance.addAudioDataStream(_audioSrc!, part.bytes);
              }
            }
          }
        }

        // Handle transcriptions in firebase_ai 3.x
        if (message.outputTranscription != null) {
          final text = message.outputTranscription!.text;
          if (text != null && text.isNotEmpty) {
            log("📝 AI Transcript: $text");
            _updateTranscription(text, isUser: false);
          }
        }
        if (message.inputTranscription != null) {
          final text = message.inputTranscription!.text;
          if (text != null && text.isNotEmpty) {
            log("📝 User Transcript: $text");
            _updateTranscription(text, isUser: true);
          }
        }

        if (message.turnComplete == true) {
          log("🔚 AI finished speaking");

          if (mounted) {
            setState(() {
              // Removed _lastMessageId reset
            });
          }

          if (_audioSrc != null) {
            SoLoud.instance.setDataIsEnded(_audioSrc!);
          }
          _waitForPlaybackCompletion(); // 🎤 USER CAN TALK AGAIN
        }
      } else if (message is LiveServerToolCall) {
        final toolCalls = message.functionCalls;
        if (toolCalls != null) {
          for (final fc in toolCalls) {
            if (fc.name == 'provideSolutions') {
              final advice = fc.args['advice'] as String?;
              final rawSolutions = (fc.args['solutions'] as List<dynamic>?);
              final List<Map<String, String>> solutions = [];
              if (rawSolutions != null) {
                for (var s in rawSolutions) {
                  if (s is Map) {
                    solutions.add({
                      'text': s['text']?.toString() ?? '',
                      'category': s['category']?.toString() ?? 'mental',
                    });
                  } else {
                    solutions.add({'text': s.toString(), 'category': 'mental'});
                  }
                }
              }

              if (mounted && advice != null) {
                setState(() {
                  _currentSolutions = solutions;
                  _messages.add({
                    'role': 'ai',
                    'content': advice,
                    'timestamp': DateTime.now(),
                  });
                });
                _scrollToBottom(delayed: true);
                _lastAdvice = advice;
                // Update provider state
                ref
                    .read(voiceJournalPersistenceProvider.notifier)
                    .updateState(advice: advice, currentSolutions: solutions);

                Future.delayed(const Duration(seconds: 2), () {
                  _toggleConversation();
                });

                _session?.send(
                  input: Content.functionResponse(fc.name, {
                    'status': 'displayed',
                  }),
                );
              }
            }
          }
        }
      } else {
        log("🔍 Other Server Message: $message");
      }
    } catch (e) {
      LoggerHelper.whomieLog("Error handling server message: $e");
    }
  }

  void _updateTranscription(String text, {required bool isUser}) {
    if (!mounted) return;

    // Clean text if it's from AI
    final cleanedText = isUser ? text : _cleanAiResponse(text);
    if (cleanedText.isEmpty) return;

    // Strict English Filter: Reject text with non-Latin characters if it's from the user or misdetected AI
    if (!_isEnglishText(cleanedText)) {
      LoggerHelper.whomieLog(
        "🚫 Filtered out non-English content: $cleanedText",
      );
      return;
    }

    setState(() {
      final String targetRole = isUser ? 'user' : 'ai';

      bool isNewSpeaker =
          _messages.isEmpty || _messages.last['role'] != targetRole;

      if (isNewSpeaker) {
        _messages.add({
          'role': targetRole,
          'content': cleanedText,
          'timestamp': DateTime.now(),
        });
      } else {
        _messages.last['content'] =
            (_messages.last['content'] ?? '') + cleanedText;
      }
    });

    _scrollToBottom(delayed: true);
  }

  String _cleanAiResponse(String text) {
    if (text.isEmpty) return text;

    // Use a local copy to avoid modifying the original if we decide not to clean
    String result = text;

    // 1. Remove markdown code blocks if present
    if (result.contains('```')) {
      final regExp = RegExp(r'```(?:json)?\s*([\s\S]*?)\s*```');
      final match = regExp.firstMatch(result);
      if (match != null) {
        result = match.group(1)?.trim() ?? result;
      }
    }

    // 2. Try to parse as JSON if it looks like it
    if (result.trim().startsWith('{') && result.trim().endsWith('}')) {
      try {
        final json = jsonDecode(result.trim());
        if (json is Map<String, dynamic>) {
          if (json.containsKey('question')) {
            return json['question'].toString();
          } else if (json.containsKey('advice')) {
            return json['advice'].toString();
          }
        }
      } catch (_) {
        // Not valid JSON, continue
      }
    }

    // 3. Last resort: simple regex cleanup for "question": "..."
    final questionMatch = RegExp(
      r'"question"\s*:\s*"([^"]*)"',
    ).firstMatch(result);
    if (questionMatch != null) {
      return questionMatch.group(1) ?? result;
    }

    return result; // Return raw text (preserving spaces) if no cleaning matched
  }

  bool _isEnglishText(String text) {
    if (text.isEmpty) return true;
    // This regex allows Latin characters, numbers, common punctuation, and emojis.
    // It rejects scripts like Telugu, Hindi, Japanese, etc.
    final latinRegex = RegExp(
      r'^[a-zA-Z0-9\s\p{P}\p{S}\p{Emoji}]*$',
      unicode: true,
    );
    return latinRegex.hasMatch(text);
  }

  Future<void> _onSolutionSelected(String solution) async {
    final repository = ref.read(journalRepositoryProvider);

    // Find the category associated with the selected solution
    String? selectedCategory;
    for (final sol in _currentSolutions) {
      if (sol['text'] == solution) {
        selectedCategory = sol['category'];
        break;
      }
    }

    await repository.saveActionSelection(
      sessionId: _sessionId,
      optionA: _currentSolutions.isNotEmpty
          ? _currentSolutions[0]['text'] ?? ''
          : '',
      optionB: _currentSolutions.length > 1
          ? _currentSolutions[1]['text'] ?? ''
          : '',
      optionC: _currentSolutions.length > 2
          ? _currentSolutions[2]['text'] ?? ''
          : '',
      selectedOption: solution,
      category: selectedCategory,
    );

    log("✅ Voice AI Options Selected: $solution");
    log("Current Session ID: $_sessionId");
    log("Current Solutions: $_currentSolutions");
    log("Current Selected Solution: $solution");

    // Generate and save conversation title for voice chat session
    ref
        .read(journalServiceProvider)
        .generateAndSaveSessionTitle(_sessionId, _messages);

    // completing the voice chat session
    await repository.markJournalAsCompleted(_sessionId);

    // Saving the mood in mood table
    if (widget.initialMood != null) {
      final moodRepo = ref.read(moodRepositoryProvider);
      await moodRepo.saveMood(
        widget.initialMood!.round(),
        moodName: _getMoodLabel(widget.initialMood!),
        note: 'Saved after live voice session',
      );
      ref.read(moodCheckinStateProvider.notifier).setSubmitted();
    }

    // Showing the notification for the selected task
    await ref
        .read(fcmServiceProvider)
        .showPermanentNotification(
          title: 'Whomie',
          body: solution,
          payload: _sessionId,
        );

    // Showing the toast for the selected task
    if (mounted && context.mounted) {
      WhomieToast.success(context: context, text: 'Saved to your tasks!');
      await _stopConversation();

      // Update persistence provider and trigger save
      ref
          .read(voiceJournalPersistenceProvider.notifier)
          .updateState(
            messages: _messages,
            sessionId: _sessionId,
            mood: widget.initialMood,
            currentSolutions: _currentSolutions,
            advice: _lastAdvice,
            selectedSolution: solution,
          );
      await ref.read(voiceJournalPersistenceProvider.notifier).saveToDb();

      if (mounted && context.mounted) {
        Navigator.pop(context);
      }
    }
  }

  @override
  void dispose() {
    // Mark as disposed first to prevent any further recorder access
    _disposed = true;

    // Use a sync approach to avoid race conditions
    // Cancel any active mic subscription immediately
    _micSubscription?.cancel();
    _micSubscription = null;

    // Close stream controllers
    if (_geminiStreamController != null && !_geminiStreamController!.isClosed) {
      _geminiStreamController?.close();
      _geminiStreamController = null;
    }
    if (_stopController != null && !_stopController!.isClosed) {
      _stopController?.add(true);
      _stopController?.close();
    }

    // Dispose session and audio resources synchronously
    _session?.close();
    if (_audioSrc != null) {
      try {
        SoLoud.instance.setDataIsEnded(_audioSrc!);
      } catch (_) {}
    }
    if (_handle != null) {
      try {
        SoLoud.instance.stop(_handle!);
      } catch (_) {}
    }

    // Dispose recorder - it's safe now as we've cancelled subscriptions
    try {
      _recorder.dispose();
    } catch (e) {
      log('⚠️ Recorder dispose warning: $e');
    }

    _pulseController.dispose();
    _scrollController.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    ref.listen(slowInternetProvider, (previous, next) {
      log('🌐 Internet Status Changed: $next');
      if (!_conversationActive) return;

      if (next == InternetStatus.noInternet) {
        WhomieToast.error(
          context: context,
          text: 'No internet connection',
          subtitle: 'Please check your connection',
        );
      } else if (next == InternetStatus.slow) {
        WhomieToast.warning(
          context: context,
          text: 'Slow internet detected',
          subtitle: 'You might experience some delays',
        );
      }
    });

    final optionsStream = ref
        .watch(journalRepositoryProvider)
        .watchOptionsBySessionId(_sessionId);

    return PopScope(
      canPop: false,
      onPopInvokedWithResult: (didPop, result) async {
        if (!didPop) return;
        if (_messages.isNotEmpty) {
          // Update persistence provider and trigger save
          ref
              .read(voiceJournalPersistenceProvider.notifier)
              .updateState(
                messages: _messages,
                sessionId: _sessionId,
                mood: widget.initialMood,
                currentSolutions: _currentSolutions,
                advice: _lastAdvice,
              );
          await ref.read(voiceJournalPersistenceProvider.notifier).saveToDb();
        }
        await _stopConversation(updateUi: false);
        if (context.mounted) {
          Navigator.of(context).pop();
        }
      },
      child: Container(
        decoration: BoxDecoration(
          gradient: LinearGradient(
            begin: Alignment.topCenter,
            end: Alignment.bottomCenter,
            colors: [
              Colors.white,
              const Color(0xFFF8FBFF),
              AppColors.primary.withValues(alpha: 0.05),
            ],
          ),
        ),
        child: WhomieScaffold(
          backgroundColor: Colors.transparent,
          appBar: WhomieAppBar(
            title: 'Whomie Voice',
            actions: [
              if (FeatureFlags.isPausePlayVoiceAI && _currentSolutions.isEmpty)
                IconButton(
                  onPressed: _settingUpSession ? null : _toggleConversation,
                  icon: Icon(
                    _conversationActive
                        ? Icons.pause_circle_filled
                        : Icons.play_circle_filled,
                    color: AppColors.primary,
                    size: 32,
                  ),
                ),
              if (_conversationActive)
                Padding(
                  padding: const EdgeInsets.only(right: 16),
                  child: PhosphorIcon(
                    PhosphorIcons.broadcast(PhosphorIconsStyle.fill),
                    color: Colors.redAccent,
                  ),
                ),
            ],
          ),
          body: Column(
            children: [
              Expanded(
                flex: 3,
                child: _messages.isEmpty
                    ? Center(
                        child: Column(
                          mainAxisAlignment: MainAxisAlignment.center,
                          children: [
                            Icon(
                              PhosphorIcons.microphone(PhosphorIconsStyle.fill),
                              size: 80,
                              color: AppColors.primaryDark.withValues(
                                alpha: 0.8,
                              ),
                            ),
                            const SizedBox(height: 24),
                            Text(
                              _conversationActive
                                  ? 'Whomie is listening...'
                                  : 'Please wait, Whomie is starting',
                              style: TextStyle(
                                color: AppColors.textPrimary.withValues(
                                  alpha: 0.4,
                                ),
                                fontSize: 18,
                                fontWeight: FontWeight.w500,
                                letterSpacing: 0.5,
                              ),
                            ),
                          ],
                        ),
                      )
                    : ListView.builder(
                        controller: _scrollController,
                        padding: const EdgeInsets.all(16),
                        itemCount: _messages.length,
                        itemBuilder: (context, index) {
                          final msg = _messages[index];
                          final isUser = msg['role'] == 'user';
                          final userId = ref
                              .read(authRepositoryProvider)
                              .currentUser
                              ?.uid;

                          return Column(
                            crossAxisAlignment: isUser
                                ? CrossAxisAlignment.end
                                : CrossAxisAlignment.start,
                            children: [
                              Row(
                                mainAxisAlignment: isUser
                                    ? MainAxisAlignment.end
                                    : MainAxisAlignment.start,
                                crossAxisAlignment: CrossAxisAlignment.end,
                                children: [
                                  if (!isUser) ...[
                                    CircleAvatar(
                                      radius: 16,
                                      backgroundColor: Colors.white,
                                      child: SvgPicture.asset(
                                        ImagePath.svgLogo,
                                        fit: BoxFit.cover,
                                      ),
                                    ),
                                    const SizedBox(width: 8),
                                  ],
                                  Flexible(
                                    child: Container(
                                      margin: const EdgeInsets.symmetric(
                                        vertical: 4,
                                      ),
                                      padding: const EdgeInsets.all(12),
                                      decoration: BoxDecoration(
                                        color: isUser
                                            ? AppColors.primaryDark.withValues(
                                                alpha: 0.9,
                                              )
                                            : Colors.white.withValues(
                                                alpha: 0.7,
                                              ),
                                        borderRadius: BorderRadius.circular(20),
                                        border: Border.all(
                                          color: isUser
                                              ? Colors.white.withValues(
                                                  alpha: 0.1,
                                                )
                                              : Colors.white.withValues(
                                                  alpha: 0.4,
                                                ),
                                          width: 1,
                                        ),
                                        boxShadow: [
                                          BoxShadow(
                                            color: Colors.black.withValues(
                                              alpha: 0.05,
                                            ),
                                            blurRadius: 10,
                                            offset: const Offset(0, 4),
                                          ),
                                        ],
                                      ),
                                      child: RichText(
                                        text: TextHelper.parseMarkdown(
                                          msg['content'] ?? '',
                                          TextStyle(
                                            color: isUser
                                                ? Colors.white
                                                : AppColors.textPrimary,
                                            fontSize: 16,
                                            height: 1.4,
                                          ),
                                        ),
                                      ),
                                    ),
                                  ),
                                  if (isUser) ...[
                                    const SizedBox(width: 8),
                                    Consumer(
                                      builder: (context, ref, _) {
                                        final profilePictureAsync =
                                            userId != null
                                            ? ref.watch(
                                                profilePicturePathProvider(
                                                  userId,
                                                ),
                                              )
                                            : const AsyncValue.data(null);

                                        return profilePictureAsync.when(
                                          data: (path) {
                                            if (path != null &&
                                                File(path).existsSync()) {
                                              return CircleAvatar(
                                                radius: 16,
                                                backgroundImage: FileImage(
                                                  File(path),
                                                ),
                                              );
                                            }
                                            return CircleAvatar(
                                              radius: 16,
                                              backgroundColor:
                                                  AppColors.primaryDark,
                                              child: PhosphorIcon(
                                                PhosphorIcons.user(
                                                  PhosphorIconsStyle.regular,
                                                ),
                                                size: 16,
                                                color: Colors.white,
                                              ),
                                            );
                                          },
                                          loading: () =>
                                              const SizedBox(width: 32),
                                          error: (_, __) =>
                                              const SizedBox(width: 32),
                                        );
                                      },
                                    ),
                                  ],
                                ],
                              ),
                              const SizedBox(height: 8),
                            ],
                          );
                        },
                      ),
              ),
              StreamBuilder<ActionOption?>(
                stream: optionsStream,
                builder: (context, snapshot) {
                  final options = snapshot.data;
                  final List<String> displaySolutions =
                      _currentSolutions.isNotEmpty
                      ? _currentSolutions.map((s) => s['text'] ?? '').toList()
                      : (options != null
                            ? [
                                options.optionA ?? '',
                                options.optionB ?? '',
                                options.optionC ?? '',
                              ].where((s) => s.isNotEmpty).toList()
                            : []);

                  if (displaySolutions.isEmpty) {
                    return Expanded(
                      flex: 1,
                      child: Center(
                        child: _settingUpSession
                            ? const CircularProgressIndicator(
                                color: AppColors.primary,
                              )
                            : _conversationActive
                            ? Lottie.asset(
                                'assets/lottie/voice_visualization.json',
                                width: double.infinity,
                                height: 120,
                                fit: BoxFit.contain,
                                delegates: LottieDelegates(
                                  values: [
                                    ValueDelegate.color(
                                      const ['**', 'Fill 1'],
                                      value: _isAiSpeaking
                                          ? Colors.greenAccent
                                          : Colors.orangeAccent,
                                    ),
                                    ValueDelegate.color(
                                      const ['**', 'Fill'],
                                      value: _isAiSpeaking
                                          ? Colors.greenAccent
                                          : Colors.orangeAccent,
                                    ),
                                    ValueDelegate.color(
                                      const ['**', 'Stroke 1'],
                                      value: _isAiSpeaking
                                          ? Colors.greenAccent
                                          : Colors.orangeAccent,
                                    ),
                                  ],
                                ),
                              )
                            : const SizedBox.shrink(),
                      ),
                    );
                  }

                  return Padding(
                    padding: const EdgeInsets.only(
                      left: 12,
                      right: 12,
                      bottom: 48,
                    ),
                    child: Column(
                      crossAxisAlignment: CrossAxisAlignment.start,
                      children: [
                        Container(
                          padding: const EdgeInsets.symmetric(
                            vertical: 12,
                            horizontal: 12,
                          ),
                          margin: const EdgeInsets.only(bottom: 8, top: 8),
                          decoration: BoxDecoration(
                            color: AppColors.secondary,
                            borderRadius: BorderRadius.circular(12),
                          ),
                          child: Text(
                            (widget.sessionId == null)
                                ? "Select an option provided by Whomie"
                                : "Actions provided by Whomie",
                            style: TextStyle(
                              color: AppColors.white,
                              fontSize: 17,
                              fontWeight: FontWeight.bold,
                            ),
                          ),
                        ),
                        const SizedBox(height: 12),
                        ...displaySolutions.map((sol) {
                          final isSelected =
                              options != null &&
                              options.selectedOption?.trim() ==
                                  sol.toString().trim();
                          return Padding(
                            padding: const EdgeInsets.only(bottom: 12),
                            child: Material(
                              color: Colors.transparent,
                              child: InkWell(
                                onTap: widget.sessionId != null
                                    ? null
                                    : () => _onSolutionSelected(
                                        sol.toString().trim(),
                                      ),
                                borderRadius: BorderRadius.circular(16),
                                child: Container(
                                  padding: const EdgeInsets.symmetric(
                                    horizontal: 14,
                                    vertical: 12,
                                  ),
                                  decoration: BoxDecoration(
                                    color: const Color(0xFFFFF0ED),
                                    borderRadius: BorderRadius.circular(12),
                                    border: Border.all(
                                      color: isSelected
                                          ? AppColors.secondary
                                          : AppColors.secondary.withValues(
                                              alpha: 0.4,
                                            ),
                                      width: isSelected ? 2.5 : 1.5,
                                    ),
                                    boxShadow: const [
                                      BoxShadow(
                                        color: Colors.black12,
                                        blurRadius: 4,
                                        offset: Offset(0, 2),
                                      ),
                                    ],
                                  ),
                                  child: Row(
                                    children: [
                                      Expanded(
                                        child: Text(
                                          sol.toString(),
                                          style: const TextStyle(
                                            color: AppColors.textPrimary,
                                            fontWeight: FontWeight.bold,
                                            fontSize: 15,
                                          ),
                                        ),
                                      ),
                                      if (widget.sessionId == null) ...[
                                        const SizedBox(width: 8),
                                        Container(
                                          padding: const EdgeInsets.all(4),
                                          decoration: const BoxDecoration(
                                            color: AppColors.secondary,
                                            shape: BoxShape.circle,
                                          ),
                                          child: const Icon(
                                            Icons.arrow_forward_rounded,
                                            size: 14,
                                            color: Colors.white,
                                          ),
                                        ),
                                      ],
                                    ],
                                  ),
                                ),
                              ),
                            ),
                          );
                        }),
                        if (widget.sessionId == null)
                          Padding(
                            padding: const EdgeInsets.only(top: 8, bottom: 4),
                            child: Center(
                              child: TextButton(
                                onPressed: () async {
                                  if (_messages.isNotEmpty) {
                                    // Update persistence provider and trigger save
                                    ref
                                        .read(
                                          voiceJournalPersistenceProvider
                                              .notifier,
                                        )
                                        .updateState(
                                          messages: _messages,
                                          sessionId: _sessionId,
                                          mood: widget.initialMood,
                                          currentSolutions: _currentSolutions,
                                          advice: _lastAdvice,
                                        );
                                    await ref
                                        .read(
                                          voiceJournalPersistenceProvider
                                              .notifier,
                                        )
                                        .saveToDb();
                                  }
                                  if (mounted && context.mounted) context.pop();
                                },
                                style: TextButton.styleFrom(
                                  padding: const EdgeInsets.symmetric(
                                    horizontal: 24,
                                    vertical: 12,
                                  ),
                                ),
                                child: Text(
                                  'No Action',
                                  style: TextStyle(
                                    fontWeight: FontWeight.w500,
                                    fontSize: 14,
                                    color: AppColors.black,
                                    decoration: TextDecoration.underline,
                                    decorationColor: AppColors.black,
                                  ),
                                ),
                              ),
                            ),
                          ),
                      ],
                    ),
                  );
                },
              ),
            ],
          ),
        ),
      ),
    );
  }

  String _getMoodLabel(double value) {
    final index = (value.round() - 1).clamp(0, 6);
    const labels = [
      'Depressed',
      'Very Bad',
      'Bad',
      'Okay',
      'Good',
      'Great',
      'Awesome',
    ];
    return labels[index];
  }
}

[lehcar09]

Hi @Magesh-kanna, thank you for reaching out. I'm currently investigating this issue. I tried using the startAudioConversation API, and so far the transcription is accurate. I'm not that familiar with Dart language and just want to confirm some details.

• Are you using managing the audio pipeline using AudioRecord (for input) and AudioTrack (for output)?
• You said that AI picks up the correct sentence and live transcription gives the wrong text and the UI is reflected accordingly, could you provide more details on this?

Also, By any chance can share a recording and/or runnable MCVE to help us investigate the issue? Thanks!

[Magesh-kanna]

I'm using Flutter and Dart
https://drive.google.com/file/d/1lexAbkd7MCgQc0qTdF5LJYqLxyz4QyhF/view?usp=sharing

Please check the video from above URL. Unfortunately, i couldn't share the MVP code.
You can use the above mentioned code to reproduce the issue on any flutter app which is connected to firebase with Blaze plan.

Please let me know, if you need anything from me to fix this. @lehcar09

Edit: Sorry for late response (I was working on this issue only for soo longggg) 🙃

[Magesh-kanna]

And my Claude 4.5 fixed with something, Please check if it is helpful... But even though i'm getting the issue mentioned in video sometimes. I need a proper fix from the package team. Please do the needful.

`import 'dart:async';
import 'dart:convert';
import 'dart:developer';
import 'dart:io';
import 'dart:typed_data';

import 'package:firebase_ai/firebase_ai.dart';
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:flutter_soloud/flutter_soloud.dart';
import 'package:flutter_svg/svg.dart';
import 'package:go_router/go_router.dart';
import 'package:lottie/lottie.dart';
import 'package:phosphor_flutter/phosphor_flutter.dart';
import 'package:record/record.dart';
import 'package:uuid/uuid.dart';
import 'package:whomie/core/constants/app_colors.dart';
import 'package:whomie/core/constants/image_path.dart';
import 'package:whomie/core/constants/internet_status.dart';
import 'package:whomie/core/router/app_routes.dart';
import 'package:whomie/core/database/app_database.dart';
import 'package:whomie/core/helper/entry_feedback_helper.dart';
import 'package:whomie/core/helper/logger_helper.dart';
import 'package:whomie/core/helper/text_helper.dart';
import 'package:whomie/core/helper/voice_prompt_generator.dart';
import 'package:whomie/core/helper/whomie_toast.dart';
import 'package:whomie/core/presentation/widgets/whomie_app_bar.dart';
import 'package:whomie/core/presentation/widgets/whomie_scaffold.dart';
import 'package:whomie/core/providers/internet_status_provider.dart';
import 'package:whomie/core/services/fcm_service.dart';
import 'package:whomie/core/services/feature_flagging.dart';
import 'package:whomie/core/services/profile_service.dart';
import 'package:whomie/features/auth/data/auth_repository.dart';
import 'package:whomie/features/journal/data/journal_repository.dart';
import 'package:whomie/features/journal/data/journal_service.dart';
import 'package:whomie/features/journal/presentation/providers/voice_journal_persistence_provider.dart';

class VoiceJournalScreen extends ConsumerStatefulWidget {
final String? sessionId;
final double? initialMood;

const VoiceJournalScreen({super.key, this.sessionId, this.initialMood});

@OverRide
ConsumerState createState() => _VoiceJournalScreenState();
}

class _VoiceJournalScreenState extends ConsumerState
with SingleTickerProviderStateMixin {
// Gemini Live Model & Session
late LiveGenerativeModel _liveModel;
LiveSession? _session;

// Audio recording & playback
final _recorder = AudioRecorder();
AudioSource? _audioSrc;
SoundHandle? _handle;
bool _disposed = false;

// State Management
bool _audioReady = false;
bool _settingUpSession = false;
bool _conversationActive = false;
bool _isAiSpeaking = false;
StreamController? _stopController;
StreamController? _geminiStreamController;

String? _sessionId;
final List<Map<String, dynamic>> _messages = [];
final ScrollController _scrollController = ScrollController();
late AnimationController _pulseController;
String? _lastAdvice;

StreamSubscription? _micSubscription;

// Solution tracking
List<Map<String, String>> _currentSolutions = [];

@OverRide
void initState() {
super.initState();
_initializeSession();

_pulseController = AnimationController(
  vsync: this,
  duration: const Duration(seconds: 1),
)..repeat(reverse: true);

// Trigger premium entry feel
EntryFeedbackHelper.triggerPremiumEntry();

}

/// Initialize session - check for incomplete session or create new one
Future _initializeSession() async {
if (widget.sessionId != null) {
// Viewing existing session (from history)
_sessionId = widget.sessionId;
if (mounted) setState(() {});
await _loadHistory();
return;
} else {
_sessionId = const Uuid().v4();
}

// Check for incomplete voice session to resume
final incompleteSessionId = await ref
    .read(journalRepositoryProvider)
    .getIncompleteVoiceSession();

if (incompleteSessionId != null) {
  // Resume incomplete session
  _sessionId = incompleteSessionId;
  if (mounted) setState(() {});
  // IMPORTANT: Await history load so messages are available for AI context
  await _loadHistory();
  // Scroll to end after messages load
  WidgetsBinding.instance.addPostFrameCallback((_) {
    _jumpToEnd();
  });
} else {
  // Start new session
  _sessionId = const Uuid().v4();
  if (mounted) setState(() {});
}

// Initialize voice AI (now _messages is populated if resuming)
if (mounted) {
  await _initializeLiveModel();
  await _initializeAudio();
  if (mounted) {
    _startConversation();
  }
}

}

Future _initializeLiveModel() async {
setState(() => _settingUpSession = true);
try {
final moodLabel = widget.initialMood != null
? _getMoodLabel(widget.initialMood!)
: 'neutral';
final prompt = await VoicePromptGenerator.generatePrompt(
userMessage: "",
ref: ref,
moodLabel: moodLabel,
previousConversation: _messages.isNotEmpty ? _messages : null,
);

  // Getting the AI Model name from the remote config.
  final voiceAIModelNamefromRemoteConfig = FeatureFlags.aiVoiceModel;
  LoggerHelper.whomieLog(
    '🚀 Remote Config AI Model Name Voice: $voiceAIModelNamefromRemoteConfig',
  );

  final model = voiceAIModelNamefromRemoteConfig != ''
      ? voiceAIModelNamefromRemoteConfig
      : 'gemini-2.0-flash-live-preview-04-09';

  LoggerHelper.whomieLog('USED AI Model Name Voice: $model');

  _liveModel = FirebaseAI.vertexAI().liveGenerativeModel(
    model: model,
    systemInstruction: Content.text(prompt),
    liveGenerationConfig: LiveGenerationConfig(
      speechConfig: SpeechConfig(
        voiceName: FeatureFlags.aiVoiceName != ''
            ? FeatureFlags.aiVoiceName
            : 'zephyr',
      ),
      responseModalities: [ResponseModalities.audio],
      inputAudioTranscription: AudioTranscriptionConfig(),
      outputAudioTranscription: AudioTranscriptionConfig(),
    ),
    tools: [
      Tool.functionDeclarations([
        FunctionDeclaration(
          'provideSolutions',
          'Provides exactly 3 actionable solutions, an empathic summary, and optionally a notification reminder to the user.',
          parameters: {
            'advice': Schema.string(
              description: 'Empathic summary and feedback for the user.',
            ),
            'solutions': Schema.array(
              description:
                  'Exactly 3 actionable options. Each MUST have a text and a category (physical, mental, or emotional).',
              items: Schema.object(
                properties: {
                  'text': Schema.string(description: 'The solution text.'),
                  'category': Schema.string(
                    description:
                        'Category: "physical", "mental", or "emotional".',
                  ),
                  'durationMinutes': Schema.integer(
                    description:
                        'Estimated duration in minutes to complete this activity (e.g., 3 for breathing, 10 for meditation, 30 for a walk).',
                  ),
                },
              ),
            ),
            'notification': Schema.object(
              description:
                  'Optional notification settings. Null if no follow-up is needed.',
              properties: {
                'date': Schema.string(
                  description: 'Date in YYYY-MM-DD format.',
                ),
                'frequency': Schema.string(
                  description: 'Frequency: "once", "daily", or "weekly".',
                ),
                'time': Schema.string(
                  description:
                      'Time in HH:MM AM/PM format (e.g., "09:00 AM").',
                ),
              },
              nullable: true,
              optionalProperties: ['date', 'frequency', 'time'],
            ),
          },
        ),
        FunctionDeclaration(
          'closeSession',
          'ONLY call this when the user EXPLICITLY says goodbye, bye, see you, take care, I\'m done, or similar farewell words. NEVER call this due to silence, pauses, topic completion, or because you think the conversation is over. The user MUST verbally signal they want to leave.',
          parameters: {
            'reason': Schema.string(
              description:
                  'The exact farewell phrase the user said (e.g., "User said bye", "User said goodbye").',
            ),
          },
        ),
        FunctionDeclaration(
          'recordFeedback',
          'Record user feedback on a previously suggested solution/activity. Call this ONLY when the user reports the outcome of a previously selected action during a resumed session. Status must be: completed (user did it), not_preferred (user didn\'t like it), or deferred (user couldn\'t do it now but wants to later).',
          parameters: {
            'status': Schema.string(
              description:
                  'Feedback status: "completed", "not_preferred", or "deferred".',
            ),
            'reason': Schema.string(
              description:
                  'Optional reason (e.g., "didn\'t enjoy it", "no time", "feeling better now").',
            ),
          },
        ),
      ]),
    ],
  );
  LoggerHelper.whomieLog('✅ Live Model initialized');
} catch (e) {
  LoggerHelper.whomieLog('❌ Error setting up live model: $e');
} finally {
  if (mounted) setState(() => _settingUpSession = false);
}

}

Future _initializeAudio() async {
try {
final hasPermission = await _recorder.hasPermission();
if (!hasPermission) {
if (mounted) {
WhomieToast.error(
context: context,
text: 'Microphone permission is required.',
);
}
return;
}

  if (!SoLoud.instance.isInitialized) {
    await SoLoud.instance.init(sampleRate: 24000, channels: Channels.mono);
  }
  if (mounted) setState(() => _audioReady = true);
} catch (e) {
  log("Error initializing audio: $e");
}

}

Future _loadHistory() async {
final repository = ref.read(journalRepositoryProvider);
final entries = await repository.watchSessionEntries(_sessionId!).first;

if (mounted) {
  setState(() {
    for (var entry in entries) {
      if (entry.content.isNotEmpty) {
        _messages.add({
          'role': entry.isUser ? 'user' : 'ai',
          'content': entry.content,
        });
      }
    }
  });

  // Mark these messages as already saved to prevent duplicates
  ref
      .read(voiceJournalPersistenceProvider.notifier)
      .setSavedMessageCount(_messages.length);

  _scrollToBottom(delayed: true);
}

}

void _scrollToBottom({bool delayed = false}) {
// If delayed, wait for animations (like the AnimatedSwitcher 400ms duration)
final delay = delayed ? const Duration(milliseconds: 300) : Duration.zero;

Future.delayed(delay, () {
  if (!mounted) return;
  WidgetsBinding.instance.addPostFrameCallback((_) {
    if (_scrollController.hasClients) {
      _scrollController.animateTo(
        _scrollController.position.maxScrollExtent,
        duration: const Duration(milliseconds: 200),
        curve: Curves.easeOut,
      );
    }
  });
});

}

/// Instantly jump to end without animation - for resuming sessions
void _jumpToEnd() {
Future.delayed(const Duration(milliseconds: 100), () {
if (!mounted) return;
if (_scrollController.hasClients) {
_scrollController.jumpTo(_scrollController.position.maxScrollExtent);
}
});
}

Future _toggleConversation() async {
if (_conversationActive) {
await _stopConversation();
} else {
await _startConversation();
}
}

// FIXED: Start mic streaming - simplified and clean
Future _startMicStreaming() async {
if (_micSubscription != null || _session == null) {
log("⚠️ Mic already active or session null");
return;
}

log("🎤 Initializing mic stream with silence detection...");

// Optimized audio settings for better speech recognition
final recordConfig = RecordConfig(
  encoder: AudioEncoder.pcm16bits,
  sampleRate: 16000, // 16kHz is optimal for speech recognition
  numChannels: 1,
  echoCancel: true,
  noiseSuppress: true,
  autoGain: true, // Enable automatic gain control for consistent volume
  androidConfig: const AndroidRecordConfig(
    audioSource:
        AndroidAudioSource.voiceRecognition, // Optimized for speech
  ),
  iosConfig: const IosRecordConfig(
    categoryOptions: [
      IosAudioCategoryOption.defaultToSpeaker,
      IosAudioCategoryOption.allowBluetooth,
    ],
  ),
);

try {
  final inputStream = await _recorder.startStream(recordConfig);
  _micSubscription = inputStream.listen((data) {
    // GATING LOGIC: Only process if AI is NOT speaking and session is active
    if (_geminiStreamController != null &&
        !_geminiStreamController!.isClosed &&
        !_isAiSpeaking) {
      _geminiStreamController!.add(InlineDataPart('audio/pcm', data));
    }
  });

  log('✅ Mic initialized and listener started');
} catch (e) {
  log('❌ Error initializing mic stream: $e');
  _micSubscription = null;
}

}

// FIXED: Stop mic streaming - actually stops the recording
Future _stopMicStreaming() async {
log('🛑 Stopping mic completely...');
try {
if (_micSubscription != null) {
await _micSubscription!.cancel();
_micSubscription = null;
}
// Check if recorder is disposed before accessing it
if (!_disposed) {
try {
if (await _recorder.isRecording()) {
await _recorder.stop();
}
} catch (e) {
// Recorder may already be disposed, ignore this specific error
log('⚠️ Recorder access skipped (might already be disposed)');
}
}
log('✅ Mic stopped successfully');
} catch (e) {
log('⚠️ Error stopping mic streaming: $e');
}
}

// FIXED: Wait for playback completion
Future _waitForPlaybackCompletion() async {
log("🔊 Waiting for AI playback to complete...");

if (_handle == null || _audioSrc == null) {
  log("⚠️ No active audio handle");
  _isAiSpeaking = false;
  return;
}

// Small delay to ensure audio has started
await Future.delayed(const Duration(milliseconds: 150));

// Wait for playback to finish naturally
int checkCount = 0;
const maxChecks = 300; // 30 second timeout

while (mounted && _handle != null && checkCount < maxChecks) {
  final isValid = SoLoud.instance.getIsValidVoiceHandle(_handle!);

  if (!isValid) {
    log(
      "✅ Audio playback finished after $checkCount checks (~${checkCount * 100}ms)",
    );
    break;
  }

  checkCount++;
  await Future.delayed(const Duration(milliseconds: 100));
}

if (checkCount >= maxChecks) {
  log("⚠️ Playback timeout reached");
}

if (!mounted) return;

// Clean up handle
_handle = null;
_isAiSpeaking = false;

log("🎤 Playback complete, Whomie is listening again.");

}

Future _startConversation() async {
if (!_audioReady) return;

setState(() {
  _settingUpSession = true;
  _currentSolutions = [];
});

try {
  // 1. Connect to Gemini Live
  log("🚀 Connecting to Whomie AI Voice Live...");
  _session = await _liveModel.connect();
  log("✅ Connected");

  // Initialize persistent stream for Gemini
  _geminiStreamController = StreamController<InlineDataPart>();
  _session!.sendMediaStream(_geminiStreamController!.stream);

  _stopController = StreamController<bool>();
  unawaited(_processMessagesContinuously());

  await _startMicStreaming();

  setState(() {
    _conversationActive = true;
    _settingUpSession = false;
  });
} catch (e) {
  if (mounted) {
    setState(() => _settingUpSession = false);
    String errorMsg = 'Error starting conversation: $e';
    bool isRateLimit =
        e.toString().contains('429') ||
        e.toString().contains('Resource exhausted');

    if (isRateLimit) {
      errorMsg =
          "I am busy with lot of people trying, I'm working on it. Please wait.";
      WhomieToast.warning(
        context: context,
        text: errorMsg,
        subtitle: 'Please try saying again',
      );
      setState(() {
        _messages.add({
          'role': 'ai',
          'content': errorMsg,
          'timestamp': DateTime.now(),
        });
        _conversationActive = false;
      });
    } else {
      WhomieToast.error(
        context: context,
        text: errorMsg,
        subtitle: 'Please try saying again',
      );
    }
  }
}

}

Future _stopConversation({bool updateUi = true}) async {
if (updateUi && mounted) {
setState(() {
_settingUpSession = true;
});
}

try {
  await _stopMicStreaming();
  // await _recorder.stop();
  if (_audioSrc != null) {
    SoLoud.instance.setDataIsEnded(_audioSrc!);
  }
  if (_handle != null) {
    await SoLoud.instance.stop(_handle!);
  }

  await _session?.close();
  if (_geminiStreamController != null &&
      !_geminiStreamController!.isClosed) {
    await _geminiStreamController?.close();
    _geminiStreamController = null;
  }
  if (_stopController != null && !_stopController!.isClosed) {
    _stopController?.add(true);
    await _stopController?.close();
  }

  if (updateUi && mounted) {
    setState(() {
      _conversationActive = false;
      _isAiSpeaking = false;
      _settingUpSession = false;
    });
  }
} catch (e) {
  log("Error stopping conversation: $e");
  if (updateUi && mounted) {
    setState(() => _settingUpSession = false);
  }
}

}

Future _processMessagesContinuously() async {
if (_session == null) return;

bool shouldContinue = true;
_stopController!.stream.listen((stop) {
  if (stop) shouldContinue = false;
});

while (shouldContinue) {
  try {
    await for (final response in _session!.receive()) {
      log("Gemini Server Response type: ${response.runtimeType}");
      // response is usually LiveServerResponse which has a 'message' field
      try {
        final dynamic resp = response;
        if (resp.message is LiveServerMessage) {
          await _handleLiveServerMessage(resp.message as LiveServerMessage);
        } else if (resp is LiveServerMessage) {
          await _handleLiveServerMessage(resp);
        }
      } catch (e) {
        log("Error parsing response: $e");
      }
    }
  } catch (e) {
    if (e.toString().contains('closed') || e.toString().contains('1006')) {
      log("⚠️ Connection lost in _processMessagesContinuously: $e");
      if (mounted && _conversationActive) {
        WhomieToast.error(
          context: context,
          text: 'Connection lost',
          subtitle: 'Please restart the session',
        );
        _stopConversation();
      }
      break;
    }
    LoggerHelper.whomieLog("Error in message processing: $e");
    await Future.delayed(const Duration(seconds: 1));
  }
}

}

Future _handleLiveServerMessage(LiveServerMessage message) async {
try {
log("Handling Server Message type: ${message.runtimeType}");
if (message is LiveServerContent) {
if (message.modelTurn != null) {
log("📦 Got LiveServerContent with modelTurn");
}
if (message.turnComplete == true) {
log("🔚 Turn Complete");
}
if (message.interrupted == true) {
log("⚠️ Interrupted");
}
final parts = message.modelTurn?.parts;
if (parts != null) {
if (!mounted) return;

      if (!_isAiSpeaking) {
        setState(() => _isAiSpeaking = true);
        // Create a fresh audio source for this turn
        _audioSrc = SoLoud.instance.setBufferStream(
          bufferingType: BufferingType.released,
          bufferingTimeNeeds: 0,
        );
        _handle = await SoLoud.instance.play(_audioSrc!);
      }

      for (final part in parts) {
        if (part is TextPart) {
          _updateTranscription(part.text, isUser: false);
        } else if (part is InlineDataPart) {
          if (part.mimeType.startsWith('audio') && _audioSrc != null) {
            SoLoud.instance.addAudioDataStream(_audioSrc!, part.bytes);
          }
        }
      }
    }

    // Handle transcriptions in firebase_ai 3.x
    if (message.outputTranscription != null) {
      final text = message.outputTranscription!.text;
      if (text != null && text.isNotEmpty) {
        log("📝 AI Transcript: $text");
        _updateTranscription(text, isUser: false);
      }
    }
    if (message.inputTranscription != null) {
      final text = message.inputTranscription!.text;
      if (text != null && text.isNotEmpty) {
        log("📝 User Transcript: $text");
        _updateTranscription(text, isUser: true);
      }
    }

    if (message.turnComplete == true) {
      log("🔚 AI finished speaking");

      if (mounted) {
        setState(() {
          // Removed _lastMessageId reset
        });
      }

      if (_audioSrc != null) {
        SoLoud.instance.setDataIsEnded(_audioSrc!);
      }
      _waitForPlaybackCompletion(); // 🎤 USER CAN TALK AGAIN
    }
  } else if (message is LiveServerToolCall) {
    final toolCalls = message.functionCalls;
    if (toolCalls != null) {
      for (final fc in toolCalls) {
        if (fc.name == 'provideSolutions') {
          final advice = fc.args['advice'] as String?;
          final rawSolutions = (fc.args['solutions'] as List<dynamic>?);
          final List<Map<String, String>> solutions = [];
          if (rawSolutions != null) {
            for (var s in rawSolutions) {
              if (s is Map) {
                solutions.add({
                  'text': s['text']?.toString() ?? '',
                  'category': s['category']?.toString() ?? 'mental',
                  'durationMinutes':
                      s['durationMinutes']?.toString() ?? '15',
                });
              } else {
                solutions.add({'text': s.toString(), 'category': 'mental'});
              }
            }
          }

          if (mounted && advice != null) {
            setState(() {
              _currentSolutions = solutions;
              _messages.add({
                'role': 'ai',
                'content': advice,
                'timestamp': DateTime.now(),
              });
            });
            _scrollToBottom(delayed: true);
            _lastAdvice = advice;
            // Update provider state
            ref
                .read(voiceJournalPersistenceProvider.notifier)
                .updateState(advice: advice, currentSolutions: solutions);

            Future.delayed(const Duration(seconds: 2), () {
              _toggleConversation();
            });

            _session?.send(
              input: Content.functionResponse(fc.name, {
                'status': 'displayed',
              }),
            );
          }
        } else if (fc.name == 'recordFeedback') {
          // AI is recording feedback for a previously suggested solution
          final status = fc.args['status'] as String? ?? 'completed';
          final reason = fc.args['reason'] as String?;
          log('📝 AI recording feedback: status=$status, reason=$reason');

          if (_sessionId != null && mounted) {
            final repository = ref.read(journalRepositoryProvider);
            await repository.updateSolutionFeedback(
              sessionId: _sessionId!,
              status: status,
              reason: reason,
            );
          }

          // Send function response back to AI
          _session?.send(
            input: Content.functionResponse(fc.name, {
              'status': 'recorded',
            }),
          );
        } else if (fc.name == 'closeSession') {
          // AI is signaling that the session should be closed
          final reason = fc.args['reason'] as String?;
          log('🔚 AI requested session close: $reason');

          // Save messages and complete session
          ref
              .read(voiceJournalPersistenceProvider.notifier)
              .updateState(
                messages: _messages,
                sessionId: _sessionId,
                mood: widget.initialMood,
                currentSolutions: _currentSolutions,
                advice: _lastAdvice,
              );
          await ref
              .read(voiceJournalPersistenceProvider.notifier)
              .saveToDb();
          await ref
              .read(voiceJournalPersistenceProvider.notifier)
              .completeSession(_sessionId!, mood: widget.initialMood);

          // Generate title for history
          ref
              .read(journalServiceProvider)
              .generateAndSaveSessionTitle(_sessionId!, _messages);

          // Send response to AI
          _session?.send(
            input: Content.functionResponse(fc.name, {
              'status': 'completed',
            }),
          );

          // Show toast and navigate home
          if (mounted && context.mounted) {
            WhomieToast.success(
              context: context,
              text: 'Session completed!',
            );
            await _stopConversation();
            if (context.mounted && mounted) {
              context.go(AppRoutes.home);
            }
          }
        }
      }
    }
  } else {
    log("🔍 Other Server Message: $message");
  }
} catch (e) {
  LoggerHelper.whomieLog("Error handling server message: $e");
}

}

void _updateTranscription(String text, {required bool isUser}) {
if (!mounted) return;

// Clean and normalize text based on source
String cleanedText;
if (isUser) {
  // Apply transcription correction for user speech
  cleanedText = _normalizeUserTranscription(text);
} else {
  cleanedText = _cleanAiResponse(text);
}

if (cleanedText.trim().isEmpty) return;

// Strict English Filter: Handle text with non-Latin characters
if (!_isEnglishText(cleanedText)) {
  LoggerHelper.whomieLog("🚫 Non-English content detected: $cleanedText");
  if (isUser) {
    // Show "Other message" for non-English user speech
    cleanedText = 'Other message';
  } else {
    // Silently filter non-English AI output
    return;
  }
}

setState(() {
  final String targetRole = isUser ? 'user' : 'ai';

  bool isNewSpeaker =
      _messages.isEmpty || _messages.last['role'] != targetRole;

  if (isNewSpeaker) {
    _messages.add({
      'role': targetRole,
      'content': cleanedText,
      'timestamp': DateTime.now(),
    });
  } else {
    // Append with space for natural sentence flow
    final existing = _messages.last['content'] ?? '';
    final separator = existing.endsWith(' ') || cleanedText.startsWith(' ')
        ? ''
        : ' ';
    _messages.last['content'] = existing + separator + cleanedText;
  }
});

_scrollToBottom(delayed: true);

}

/// Normalize and correct common transcription errors for Indian English
String _normalizeUserTranscription(String text) {
if (text.isEmpty) return text;

LoggerHelper.whomieLog("📝 Raw user transcription: '$text'");

String result = text.trim();

// 0. Filter out noise artifacts from transcription
final noisePatterns = [
  RegExp(r'\[.*?\]', caseSensitive: false), // [inaudible], [noise], etc.
  RegExp(r'<.*?>', caseSensitive: false), // <noise>, <silence>, etc.
  RegExp(r'\(inaudible\)', caseSensitive: false),
  RegExp(r'\(noise\)', caseSensitive: false),
  RegExp(r'\(silence\)', caseSensitive: false),
  RegExp(r'\(unclear\)', caseSensitive: false),
];
for (final pattern in noisePatterns) {
  result = result.replaceAll(pattern, '');
}
result = result.trim();
if (result.isEmpty) return result;

// 1. Remove repeated characters from transcription errors (e.g., "hellooo" -> "hello")
result = result.replaceAllMapped(
  RegExp(r'(.)\1{2,}'),
  (match) => match.group(1)! * 2, // Keep max 2 repeated chars
);

// 2. Common Indian English transcription corrections
final corrections = <String, String>{
  // W/V sound substitutions
  r'\bwery\b': 'very',
  r'\bvhat\b': 'what',
  r'\bvorry\b': 'worry',
  r'\bvorried\b': 'worried',
  r'\bvork\b': 'work',
  r'\bvorking\b': 'working',
  r'\bvife\b': 'wife',
  r'\bvant\b': 'want',
  r'\bvanted\b': 'wanted',
  r'\bvill\b': 'will',
  r'\bvould\b': 'would',
  r'\bvith\b': 'with',
  r'\bvithout\b': 'without',
  r'\bwideo\b': 'video',
  r'\bwisit\b': 'visit',
  r'\bwisiting\b': 'visiting',
  r'\bwoice\b': 'voice',
  r'\bwolunteer\b': 'volunteer',
  r'\bwehicle\b': 'vehicle',
  r'\bwalue\b': 'value',
  r'\bwersion\b': 'version',
  // Th/D and Th/T sound substitutions
  r'\bdit\b': 'did',
  r'\bdat\b': 'that',
  r'\bdem\b': 'them',
  r'\bder\b': 'there',
  r'\bdey\b': 'they',
  r'\btink\b': 'think',
  r'\btinking\b': 'thinking',
  r'\btought\b': 'thought',
  r'\bting\b': 'thing',
  r'\btings\b': 'things',
  r'\bnotink\b': 'nothing',
  r'\bsometing\b': 'something',
  r'\beverything\b': 'everything',
  r'\banyting\b': 'anything',
  r'\bdis\b': 'this',
  r'\bden\b': 'then',
  r'\bdose\b': 'those',
  r'\bbrudder\b': 'brother',
  r'\bmudder\b': 'mother',
  r'\bfadder\b': 'father',
  r'\bwedder\b': 'weather',
  r'\btrew\b': 'through',
  // Number/word mishearings
  r'\bvan\b(?!\s+(?:driver|pool|ride))': 'one',
  r'\btree\b(?!\s|s\b)': 'three',
  r'\bfor\b(?=\s+(?:people|times|days|hours|minutes|years|months|weeks))':
      'four',
  // App name corrections
  r'\bhomie\b': 'Whomie',
  r'\bhommie\b': 'Whomie',
  r'\bhomy\b': 'Whomie',
  r'\bwho\.?mie\b': 'Whomie',
  // Common Indian English accent patterns
  r'\bekchually\b': 'actually',
  r'\baxually\b': 'actually',
  r'\bekzam\b': 'exam',
  r'\bjuss\b': 'just',
  r'\bpheling\b': 'feeling',
  r'\bfealing\b': 'feeling',
  r'\bstrass\b': 'stress',
  r'\btension\b(?=\s|$|\.)': 'stress',
  r'\btenshun\b': 'tension',
  r'\bsleap\b': 'sleep',
  r'\bsleeep\b': 'sleep',
  // Repeated words cleanup
  r'\b(\w+)\s+\1\b': r'$1',
};

corrections.forEach((pattern, replacement) {
  result = result.replaceAll(
    RegExp(pattern, caseSensitive: false),
    replacement,
  );
});

// 3. Remove common fillers ONLY if they're not the entire message
final fillerPatterns = [
  r'\buhh?\b',
  r'\bumm?\b',
  r'\bhmm+\b',
  r'\bahh?\b',
  r'\berr\b',
];

String resultWithoutFillers = result;
for (final pattern in fillerPatterns) {
  resultWithoutFillers = resultWithoutFillers.replaceAll(
    RegExp(pattern, caseSensitive: false),
    '',
  );
}

// Only use filler-removed version if it's not empty
if (resultWithoutFillers.trim().isNotEmpty) {
  result = resultWithoutFillers;
}

// 4. Clean up extra whitespace
result = result.replaceAll(RegExp(r'\s+'), ' ').trim();

// 5. Capitalize first letter if it's a new sentence
if (result.isNotEmpty) {
  result = result[0].toUpperCase() + result.substring(1);
}

LoggerHelper.whomieLog("📝 Normalized transcription: '$result'");

return result;

}

String _cleanAiResponse(String text) {
if (text.isEmpty) return text;

// Use a local copy to avoid modifying the original if we decide not to clean
String result = text;

// 1. Remove markdown code blocks if present
if (result.contains('```')) {
  final regExp = RegExp(r'```(?:json)?\s*([\s\S]*?)\s*```');
  final match = regExp.firstMatch(result);
  if (match != null) {
    result = match.group(1)?.trim() ?? result;
  }
}

// 2. Try to parse as JSON if it looks like it
if (result.trim().startsWith('{') && result.trim().endsWith('}')) {
  try {
    final json = jsonDecode(result.trim());
    if (json is Map<String, dynamic>) {
      if (json.containsKey('question')) {
        return json['question'].toString();
      } else if (json.containsKey('advice')) {
        return json['advice'].toString();
      }
    }
  } catch (_) {
    // Not valid JSON, continue
  }
}

// 3. Last resort: simple regex cleanup for "question": "..."
final questionMatch = RegExp(
  r'"question"\s*:\s*"([^"]*)"',
).firstMatch(result);
if (questionMatch != null) {
  return questionMatch.group(1) ?? result;
}

return result; // Return raw text (preserving spaces) if no cleaning matched

}

bool _isEnglishText(String text) {
if (text.isEmpty) return true;

// Strip punctuation, numbers, spaces, and emojis — keep only letters
final lettersOnly = text.replaceAll(
  RegExp(r'[0-9\s\p{P}\p{S}\p{Emoji}]', unicode: true),
  '',
);
if (lettersOnly.isEmpty) return true;

// Count Latin vs non-Latin characters
final latinCount = RegExp(r'[a-zA-Z]').allMatches(lettersOnly).length;
final ratio = latinCount / lettersOnly.length;

// If less than 50% Latin letters, treat as non-English
return ratio >= 0.5;

}

/// Categorize task as "doable now" (< 5 min, can be done immediately)
/// vs "bigger task" (requires scheduling, going outside, etc.)
bool _isDoableNowTask(String task) {
final doableNowKeywords = [
'breath', 'breathing', 'deep breath', 'inhale', 'exhale',
'water', 'hydrate', 'drink',
'stretch', 'stretching',
'gratitude', 'affirmation', 'positive',
'grounding', 'ground yourself', '5-4-3-2-1',
'pause', 'moment', 'relax', 'calm',
'meditat', // covers meditation, meditate
'mindful', 'awareness',
'count', 'counting',
'visualiz', // covers visualization, visualize
'permission', 'rest',
];
final lower = task.toLowerCase();
return doableNowKeywords.any((kw) => lower.contains(kw));
}

Future _onSolutionSelected(String solution) async {
if (!mounted) return;
final repository = ref.read(journalRepositoryProvider);

// Find the category associated with the selected solution
String? selectedCategory;
int? durationMinutes;
for (final sol in _currentSolutions) {
  if (sol['text'] == solution) {
    selectedCategory = sol['category'];
    durationMinutes = int.tryParse(sol['durationMinutes'] ?? '15') ?? 15;
    break;
  }
}

// 1. Save all 3 options + selected task to DB
await repository.saveActionSelection(
  sessionId: _sessionId,
  optionA: _currentSolutions.isNotEmpty
      ? _currentSolutions[0]['text'] ?? ''
      : '',
  optionB: _currentSolutions.length > 1
      ? _currentSolutions[1]['text'] ?? ''
      : '',
  optionC: _currentSolutions.length > 2
      ? _currentSolutions[2]['text'] ?? ''
      : '',
  selectedOption: solution,
  category: selectedCategory,
);

// Also save to solution_feedbacks for follow-up tracking
await repository.saveSolutionFeedback(
  sessionId: _sessionId!,
  selectedOption: solution,
  category: selectedCategory,
  durationMinutes: durationMinutes,
);

log("✅ Voice AI Options Selected: $solution");
log("Current Session ID: $_sessionId");
log("Is Doable Now: ${_isDoableNowTask(solution)}");

// 2. Generate and save conversation title
ref
    .read(journalServiceProvider)
    .generateAndSaveSessionTitle(_sessionId!, _messages);

// 3. Save current messages to DB (session remains incomplete)
if (!mounted) return;
await ref
    .read(voiceJournalPersistenceProvider.notifier)
    .saveMessagesOnly(
      sessionId: _sessionId!,
      messages: _messages,
      mood: widget.initialMood,
    );

// 4. Categorize and handle task differently
final isDoableNow = _isDoableNowTask(solution);

if (isDoableNow) {
  // DOABLE NOW: Add user message selecting task, AI will guide them through it
  if (mounted) {
    setState(() {
      _messages.add({
        'role': 'user',
        'content': 'I want to do: $solution. Please guide me through it.',
      });
    });
    _scrollToBottom(delayed: true);
  }

  // Send the selection to AI so it can guide user through the task
  // The AI should naturally respond based on the conversation context
  // and the message we just added

  if (mounted && context.mounted) {
    WhomieToast.success(
      context: context,
      text: 'Let me guide you through it!',
    );
  }
} else {
  // BIGGER TASK: Show notification for later + continue conversation
  if (!mounted) return;
  await ref
      .read(fcmServiceProvider)
      .showPermanentNotification(
        title: 'Whomie',
        body: solution,
        payload: _sessionId,
      );

  if (mounted && context.mounted) {
    WhomieToast.success(
      context: context,
      text: 'Added to your tasks! You can continue talking.',
    );
  }
}

// 5. Clear suggestions UI and continue conversation
if (mounted) {
  setState(() {
    _currentSolutions = [];
    _lastAdvice = null;
  });
}

}

@OverRide
void dispose() {
// Mark as disposed first to prevent any further recorder access
_disposed = true;

// Use a sync approach to avoid race conditions
// Cancel any active mic subscription immediately
_micSubscription?.cancel();
_micSubscription = null;

// Close stream controllers
if (_geminiStreamController != null && !_geminiStreamController!.isClosed) {
  _geminiStreamController?.close();
  _geminiStreamController = null;
}
if (_stopController != null && !_stopController!.isClosed) {
  _stopController?.add(true);
  _stopController?.close();
}

// Dispose session and audio resources synchronously
_session?.close();
if (_audioSrc != null) {
  try {
    SoLoud.instance.setDataIsEnded(_audioSrc!);
  } catch (_) {}
}
if (_handle != null) {
  try {
    SoLoud.instance.stop(_handle!);
  } catch (_) {}
}

// Dispose recorder - it's safe now as we've cancelled subscriptions
try {
  _recorder.dispose();
} catch (e) {
  log('⚠️ Recorder dispose warning: $e');
}

_pulseController.dispose();
_scrollController.dispose();
super.dispose();

}

@OverRide
Widget build(BuildContext context) {
ref.listen(slowInternetProvider, (previous, next) {
log('🌐 Internet Status Changed: $next');
if (!_conversationActive) return;

  if (next == InternetStatus.noInternet) {
    WhomieToast.error(
      context: context,
      text: 'No internet connection',
      subtitle: 'Please check your connection',
    );
  } else if (next == InternetStatus.slow) {
    WhomieToast.warning(
      context: context,
      text: 'Slow internet detected',
      subtitle: 'You might experience some delays',
    );
  }
});

final optionsStream = ref
    .watch(journalRepositoryProvider)
    .watchOptionsBySessionId(_sessionId!);

return PopScope(
  canPop: false,
  onPopInvokedWithResult: (didPop, result) async {
    if (didPop) return;
    if (_messages.isNotEmpty && _sessionId != null) {
      // Save messages WITHOUT completing session - allows resumption
      await ref
          .read(voiceJournalPersistenceProvider.notifier)
          .saveMessagesOnly(
            sessionId: _sessionId!,
            messages: _messages,
            mood: widget.initialMood,
          );
      // Generate title for history display
      ref
          .read(journalServiceProvider)
          .generateAndSaveSessionTitle(_sessionId!, _messages);
    }
    await _stopConversation(updateUi: false);
    if (context.mounted) {
      context.go(AppRoutes.home);
    }
  },
  child: Container(
    decoration: BoxDecoration(
      gradient: LinearGradient(
        begin: Alignment.topCenter,
        end: Alignment.bottomCenter,
        colors: [
          Colors.white,
          const Color(0xFFF8FBFF),
          AppColors.primary.withValues(alpha: 0.05),
        ],
      ),
    ),
    child: WhomieScaffold(
      backgroundColor: Colors.transparent,
      appBar: WhomieAppBar(
        title: 'Whomie Voice',
        actions: [
          if (FeatureFlags.isPausePlayVoiceAI && _currentSolutions.isEmpty)
            IconButton(
              onPressed: _settingUpSession ? null : _toggleConversation,
              icon: Icon(
                _conversationActive
                    ? Icons.pause_circle_filled
                    : Icons.play_circle_filled,
                color: AppColors.primary,
                size: 32,
              ),
            ),
          if (_conversationActive)
            Padding(
              padding: const EdgeInsets.only(right: 16),
              child: PhosphorIcon(
                PhosphorIcons.broadcast(PhosphorIconsStyle.fill),
                color: Colors.redAccent,
              ),
            ),
        ],
      ),
      body: Column(
        children: [
          Expanded(
            flex: 3,
            child: _messages.isEmpty
                ? Center(
                    child: Column(
                      mainAxisAlignment: MainAxisAlignment.center,
                      children: [
                        Icon(
                          PhosphorIcons.microphone(PhosphorIconsStyle.fill),
                          size: 80,
                          color: AppColors.primaryDark.withValues(
                            alpha: 0.8,
                          ),
                        ),
                        const SizedBox(height: 24),
                        Text(
                          _conversationActive
                              ? 'Whomie is listening...'
                              : 'Please wait, Whomie is starting',
                          style: TextStyle(
                            color: AppColors.textPrimary.withValues(
                              alpha: 0.4,
                            ),
                            fontSize: 18,
                            fontWeight: FontWeight.w500,
                            letterSpacing: 0.5,
                          ),
                        ),
                      ],
                    ),
                  )
                : ListView.builder(
                    controller: _scrollController,
                    padding: const EdgeInsets.all(16),
                    itemCount: _messages.length,
                    itemBuilder: (context, index) {
                      final msg = _messages[index];
                      final isUser = msg['role'] == 'user';
                      final userId = ref
                          .read(authRepositoryProvider)
                          .currentUser
                          ?.uid;

                      return Column(
                        crossAxisAlignment: isUser
                            ? CrossAxisAlignment.end
                            : CrossAxisAlignment.start,
                        children: [
                          Row(
                            mainAxisAlignment: isUser
                                ? MainAxisAlignment.end
                                : MainAxisAlignment.start,
                            crossAxisAlignment: CrossAxisAlignment.end,
                            children: [
                              if (!isUser) ...[
                                CircleAvatar(
                                  radius: 16,
                                  backgroundColor: Colors.white,
                                  child: SvgPicture.asset(
                                    ImagePath.svgLogo,
                                    fit: BoxFit.cover,
                                  ),
                                ),
                                const SizedBox(width: 8),
                              ],
                              Flexible(
                                child: Container(
                                  margin: const EdgeInsets.symmetric(
                                    vertical: 4,
                                  ),
                                  padding: const EdgeInsets.all(12),
                                  decoration: BoxDecoration(
                                    color: isUser
                                        ? AppColors.primaryDark.withValues(
                                            alpha: 0.9,
                                          )
                                        : Colors.white.withValues(
                                            alpha: 0.7,
                                          ),
                                    borderRadius: BorderRadius.circular(20),
                                    border: Border.all(
                                      color: isUser
                                          ? Colors.white.withValues(
                                              alpha: 0.1,
                                            )
                                          : Colors.white.withValues(
                                              alpha: 0.4,
                                            ),
                                      width: 1,
                                    ),
                                    boxShadow: [
                                      BoxShadow(
                                        color: Colors.black.withValues(
                                          alpha: 0.05,
                                        ),
                                        blurRadius: 10,
                                        offset: const Offset(0, 4),
                                      ),
                                    ],
                                  ),
                                  child: RichText(
                                    text: TextHelper.parseMarkdown(
                                      msg['content'] ?? '',
                                      TextStyle(
                                        color: isUser
                                            ? Colors.white
                                            : AppColors.textPrimary,
                                        fontSize: 16,
                                        height: 1.4,
                                      ),
                                    ),
                                  ),
                                ),
                              ),
                              if (isUser) ...[
                                const SizedBox(width: 8),
                                Consumer(
                                  builder: (context, ref, _) {
                                    final profilePictureAsync =
                                        userId != null
                                        ? ref.watch(
                                            profilePicturePathProvider(
                                              userId,
                                            ),
                                          )
                                        : const AsyncValue.data(null);

                                    return profilePictureAsync.when(
                                      data: (path) {
                                        if (path != null &&
                                            File(path).existsSync()) {
                                          return CircleAvatar(
                                            radius: 16,
                                            backgroundImage: FileImage(
                                              File(path),
                                            ),
                                          );
                                        }
                                        return CircleAvatar(
                                          radius: 16,
                                          backgroundColor:
                                              AppColors.primaryDark,
                                          child: PhosphorIcon(
                                            PhosphorIcons.user(
                                              PhosphorIconsStyle.regular,
                                            ),
                                            size: 16,
                                            color: Colors.white,
                                          ),
                                        );
                                      },
                                      loading: () =>
                                          const SizedBox(width: 32),
                                      error: (_, __) =>
                                          const SizedBox(width: 32),
                                    );
                                  },
                                ),
                              ],
                            ],
                          ),
                          const SizedBox(height: 8),
                        ],
                      );
                    },
                  ),
          ),
          StreamBuilder<ActionOption?>(
            stream: optionsStream,
            builder: (context, snapshot) {
              final options = snapshot.data;
              final List<String> displaySolutions =
                  _currentSolutions.isNotEmpty
                  ? _currentSolutions.map((s) => s['text'] ?? '').toList()
                  : (options != null
                        ? [
                            options.optionA ?? '',
                            options.optionB ?? '',
                            options.optionC ?? '',
                          ].where((s) => s.isNotEmpty).toList()
                        : []);

              if (displaySolutions.isEmpty) {
                return Expanded(
                  flex: 1,
                  child: Center(
                    child: _settingUpSession
                        ? const CircularProgressIndicator(
                            color: AppColors.primary,
                          )
                        : _conversationActive
                        ? Lottie.asset(
                            'assets/lottie/voice_visualization.json',
                            width: double.infinity,
                            height: 120,
                            fit: BoxFit.contain,
                            delegates: LottieDelegates(
                              values: [
                                ValueDelegate.color(
                                  const ['**', 'Fill 1'],
                                  value: _isAiSpeaking
                                      ? Colors.greenAccent
                                      : Colors.orangeAccent,
                                ),
                                ValueDelegate.color(
                                  const ['**', 'Fill'],
                                  value: _isAiSpeaking
                                      ? Colors.greenAccent
                                      : Colors.orangeAccent,
                                ),
                                ValueDelegate.color(
                                  const ['**', 'Stroke 1'],
                                  value: _isAiSpeaking
                                      ? Colors.greenAccent
                                      : Colors.orangeAccent,
                                ),
                              ],
                            ),
                          )
                        : const SizedBox.shrink(),
                  ),
                );
              }

              return Padding(
                padding: const EdgeInsets.only(
                  left: 12,
                  right: 12,
                  bottom: 48,
                ),
                child: Column(
                  crossAxisAlignment: CrossAxisAlignment.start,
                  children: [
                    Container(
                      padding: const EdgeInsets.symmetric(
                        vertical: 12,
                        horizontal: 12,
                      ),
                      margin: const EdgeInsets.only(bottom: 8, top: 8),
                      decoration: BoxDecoration(
                        color: AppColors.secondary,
                        borderRadius: BorderRadius.circular(12),
                      ),
                      child: Text(
                        (widget.sessionId == null)
                            ? "Select an option provided by Whomie"
                            : "Actions provided by Whomie",
                        style: TextStyle(
                          color: AppColors.white,
                          fontSize: 17,
                          fontWeight: FontWeight.bold,
                        ),
                      ),
                    ),
                    const SizedBox(height: 12),
                    ...displaySolutions.map((sol) {
                      final isSelected =
                          options != null &&
                          options.selectedOption?.trim() ==
                              sol.toString().trim();
                      return Padding(
                        padding: const EdgeInsets.only(bottom: 12),
                        child: Material(
                          color: Colors.transparent,
                          child: InkWell(
                            onTap: widget.sessionId != null
                                ? null
                                : () => _onSolutionSelected(
                                    sol.toString().trim(),
                                  ),
                            borderRadius: BorderRadius.circular(16),
                            child: Container(
                              padding: const EdgeInsets.symmetric(
                                horizontal: 14,
                                vertical: 12,
                              ),
                              decoration: BoxDecoration(
                                color: const Color(0xFFFFF0ED),
                                borderRadius: BorderRadius.circular(12),
                                border: Border.all(
                                  color: isSelected
                                      ? AppColors.secondary
                                      : AppColors.secondary.withValues(
                                          alpha: 0.4,
                                        ),
                                  width: isSelected ? 2.5 : 1.5,
                                ),
                                boxShadow: const [
                                  BoxShadow(
                                    color: Colors.black12,
                                    blurRadius: 4,
                                    offset: Offset(0, 2),
                                  ),
                                ],
                              ),
                              child: Row(
                                children: [
                                  Expanded(
                                    child: Text(
                                      sol.toString(),
                                      style: const TextStyle(
                                        color: AppColors.textPrimary,
                                        fontWeight: FontWeight.bold,
                                        fontSize: 15,
                                      ),
                                    ),
                                  ),
                                  if (widget.sessionId == null) ...[
                                    const SizedBox(width: 8),
                                    Container(
                                      padding: const EdgeInsets.all(4),
                                      decoration: const BoxDecoration(
                                        color: AppColors.secondary,
                                        shape: BoxShape.circle,
                                      ),
                                      child: const Icon(
                                        Icons.arrow_forward_rounded,
                                        size: 14,
                                        color: Colors.white,
                                      ),
                                    ),
                                  ],
                                ],
                              ),
                            ),
                          ),
                        ),
                      );
                    }),
                    if (widget.sessionId == null)
                      Padding(
                        padding: const EdgeInsets.only(top: 8, bottom: 4),
                        child: Center(
                          child: TextButton(
                            onPressed: () {
                              // No Action = just dismiss suggestions, nothing else
                              // Clear suggestions UI and let user continue voice conversation
                              if (mounted) {
                                setState(() {
                                  _currentSolutions = [];
                                  _lastAdvice = null;
                                });
                              }
                            },
                            style: TextButton.styleFrom(
                              padding: const EdgeInsets.symmetric(
                                horizontal: 24,
                                vertical: 12,
                              ),
                            ),
                            child: Text(
                              'No Action',
                              style: TextStyle(
                                fontWeight: FontWeight.w500,
                                fontSize: 14,
                                color: AppColors.black,
                                decoration: TextDecoration.underline,
                                decorationColor: AppColors.black,
                              ),
                            ),
                          ),
                        ),
                      ),
                  ],
                ),
              );
            },
          ),
        ],
      ),
    ),
  ),
);

}

String _getMoodLabel(double value) {
final index = (value.round() - 1).clamp(0, 6);
const labels = [
'Depressed',
'Very Bad',
'Bad',
'Okay',
'Good',
'Great',
'Awesome',
];
return labels[index];
}
}
`

[Magesh-kanna]

i've tried on Realme GT 6T, Tecno Spark 30C, Moto G86, Redmi Note 11 pro, Redmi Note 8 pro and iOS simulators also - Faced same issue on all.