import { useState } from 'react';
import { View, Button, Text } from 'react-native';
import { createSTT } from 'react-native-sherpa-onnx/stt';
import type { SttEngine } from 'react-native-sherpa-onnx/stt';

export default function STTExample() {
  const [transcription, setTranscription] = useState('');
  const [loading, setLoading] = useState(false);

  const transcribeAudio = async () => {
    setLoading(true);
    let stt: SttEngine | null = null;

    try {
      // Initialize STT
      stt = await createSTT({
        modelPath: {
          type: 'asset',
          path: 'models/sherpa-onnx-whisper-tiny.en',
        },
        modelType: 'whisper',
        numThreads: 2,
      });

      // Transcribe audio file
      const result = await stt.transcribeFile('/path/to/audio.wav');
      setTranscription(result.text);
    } catch (error) {
      console.error('Transcription failed:', error);
    } finally {
      // Clean up
      if (stt) await stt.destroy();
      setLoading(false);
    }
  };

  return (
    <View>
      <Button
        title={loading ? 'Transcribing...' : 'Transcribe Audio'}
        onPress={transcribeAudio}
        disabled={loading}
      />
      {transcription && <Text>Result: {transcription}</Text>}
    </View>
  );
}

import { useState } from 'react';
import { View, TextInput, Button, Text } from 'react-native';
import { createTTS, saveAudioToFile } from 'react-native-sherpa-onnx/tts';
import type { TtsEngine } from 'react-native-sherpa-onnx/tts';
import Sound from 'react-native-sound';

export default function TTSExample() {
  const [text, setText] = useState('Hello, world!');
  const [generating, setGenerating] = useState(false);
  const [audioPath, setAudioPath] = useState<string | null>(null);

  const generateSpeech = async () => {
    setGenerating(true);
    let tts: TtsEngine | null = null;

    try {
      // Initialize TTS
      tts = await createTTS({
        modelPath: {
          type: 'asset',
          path: 'models/vits-piper-en_US-lessac-medium',
        },
        modelType: 'vits',
      });

      // Generate speech
      const audio = await tts.generateSpeech(text, { speed: 1.0 });

      // Save to file
      const outputPath = `/tmp/speech_${Date.now()}.wav`;
      await saveAudioToFile(audio, outputPath);
      setAudioPath(outputPath);

      // Play
      const sound = new Sound(outputPath, '', (error) => {
        if (!error) sound.play();
      });
    } catch (error) {
      console.error('TTS failed:', error);
    } finally {
      if (tts) await tts.destroy();
      setGenerating(false);
    }
  };

  return (
    <View>
      <TextInput
        value={text}
        onChangeText={setText}
        placeholder="Enter text to speak"
      />
      <Button
        title={generating ? 'Generating...' : 'Generate Speech'}
        onPress={generateSpeech}
        disabled={generating}
      />
      {audioPath && <Text>Audio saved to: {audioPath}</Text>}
    </View>
  );
}

import { useState, useRef } from 'react';
import { Button, Text, View } from 'react-native';
import { createStreamingSTT } from 'react-native-sherpa-onnx/stt';
import type { StreamingSttEngine, SttStream } from 'react-native-sherpa-onnx/stt';
import { AudioRecorder, useAudioInput } from 'react-native-audio-api';

export default function MicrophoneSTT() {
  const [isRecording, setIsRecording] = useState(false);
  const [partialText, setPartialText] = useState('');
  const [finalText, setFinalText] = useState('');

  const engineRef = useRef<StreamingSttEngine | null>(null);
  const streamRef = useRef<SttStream | null>(null);
  const recorderRef = useRef<AudioRecorder | null>(null);

  const startRecording = async () => {
    try {
      // Initialize engine
      engineRef.current = await createStreamingSTT({
        modelPath: { type: 'asset', path: 'models/zipformer-en' },
        modelType: 'transducer',
      });

      // Create stream
      streamRef.current = await engineRef.current.createStream();

      // Start microphone recording
      recorderRef.current = new AudioRecorder({
        sampleRate: 16000,
        channelCount: 1,
      });

      recorderRef.current.onDataAvailable((samples) => {
        if (streamRef.current) {
          streamRef.current.acceptWaveform(samples, 16000);
          
          // Get partial result
          streamRef.current.getResult().then((result) => {
            setPartialText(result.text);

            // Check for endpoint
            streamRef.current?.isEndpoint().then((isEnd) => {
              if (isEnd) {
                setFinalText((prev) => prev + ' ' + result.text);
                setPartialText('');
                streamRef.current?.reset();
              }
            });
          });
        }
      });

      recorderRef.current.start();
      setIsRecording(true);
    } catch (error) {
      console.error('Failed to start recording:', error);
    }
  };

  const stopRecording = async () => {
    if (recorderRef.current) {
      recorderRef.current.stop();
    }

    if (streamRef.current) {
      await streamRef.current.destroy();
    }

    if (engineRef.current) {
      await engineRef.current.destroy();
    }

    setIsRecording(false);
  };

  return (
    <View>
      <Button
        title={isRecording ? 'Stop Recording' : 'Start Recording'}
        onPress={isRecording ? stopRecording : startRecording}
      />
      <Text>Partial: {partialText}</Text>
      <Text>Final: {finalText}</Text>
    </View>
  );
}